Android连接热点的Socket文件传输

*本篇文章已授权微信公众号 guolin_blog （郭霖）独家发布

最近把测试丢过来的种种BUG解决后，终于有时间去研究研究Socket通信，再加上以前做的WiFi连接和热点开启，于是有了现在的这篇博文：创建热点发送文件，让另一台手机连接热点接收文件。

效果图：

两台设备是如何传输文件的：

• 发送端->创建WiFi热点
• 接收端->连接热点
• 发送端->发送文件列表
• 接收端->收到后展示文件列表，选择要接收的文件发送给发送端
• 发送端->发送所选文件
• 接收端->开始接收…

发送端->创建WiFi热点：

由于Android没有直接开启热点的API，所以我们这里采用反射。

/**
 * 开启便携热点
 * @param context 上下文
 * @param SSID 便携热点SSID
 * @param password 便携热点密码
 * @return
 */
public static boolean openAp(Context context, String SSID, String password) {
    if(TextUtils.isEmpty(SSID)) {
        return false;
    }
    WifiManager wifiManager = (WifiManager) context.getSystemService(context.WIFI_SERVICE);
    if (wifiManager.isWifiEnabled()) {
        wifiManager.setWifiEnabled(false);
    }
    WifiConfiguration wifiConfiguration = getApConfig(SSID, password);
    try {
        if(wifiManager.isWifiEnabled()) {
            //关闭WiFi
            wifiManager.setWifiEnabled(false);
        }
        if(isApOn(context)) {
            //关闭热点
            closeAp(context);
        }
        //使用反射开启Wi-Fi热点
        Method method = wifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);
        method.invoke(wifiManager, wifiConfiguration, true);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return false;
}

接收端->连接热点：

连接热点前先开启WiFi广播监听事件，然后开启WiFi，扫描周围可用WiFi列表，拿到SSID再进行连接，最后在WiFi广播监听事件中比较已连接WIFI的SSID是否正确。

WiFi广播监听事件：

/**
 * 注册监听WiFi操作的系统广播
 */
private void registerWifiReceiver() {
    IntentFilter filter = new IntentFilter();
    //监听WiFi开启与关闭
    filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
    //监听扫描周围可用WiFi列表结果
    filter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
    //监听WiFi连接与断开
    filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
    //注册广播
    registerReceiver(mWifiBroadcaseReceiver, filter);
}
/**
 * 反注册WiFi相关的系统广播
 */
private void unregisterWifiReceiver() {
    if (mWifiBroadcaseReceiver != null) {
        unregisterReceiver(mWifiBroadcaseReceiver);
        mWifiBroadcaseReceiver = null;
    }
}

WiFi广播接收器：

public abstract class WifiBroadcaseReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        if(intent != null) {
            if(intent.getAction().equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) {
                //监听WiFi开启/关闭事件
                int wifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, 0);
                if(wifiState == WifiManager.WIFI_STATE_ENABLED) {
                    //WiFi已开启
                    onWifiEnabled();
                } else if(wifiState == WifiManager.WIFI_STATE_DISABLED) {
                    //WiFi已关闭
                    onWifiDisabled();
                }
            } else if(intent.getAction().equals(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION)) {
                WifiMgr wifiMgr = new WifiMgr(context);
                List<ScanResult> scanResults = wifiMgr.getScanResults();
                if(wifiMgr.isWifiEnabled() && scanResults != null && scanResults.size() > 0) {
                    //成功扫描
                    onScanResultsAvailable(scanResults);
                }
            } else if(intent.getAction().equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
                //网络状态改变的广播
                NetworkInfo info = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
                if (info != null) {
                    if (info.getState().equals(NetworkInfo.State.CONNECTED)) {
                        //WiFi已连接
                        WifiMgr wifiMgr = new WifiMgr(context);
                        String connectedSSID = wifiMgr.getConnectedSSID();
                        onWifiConnected(connectedSSID);
                    } else if (info.getState().equals(NetworkInfo.State.DISCONNECTED)) {
                        //WiFi已断开连接
                        onWifiDisconnected();
                    }
                }
            }
        }
    }

    public abstract void onWifiEnabled();

    public abstract void onWifiDisabled();

    public abstract void onScanResultsAvailable(List<ScanResult> scanResults);

    public abstract void onWifiConnected(String connectedSSID);

    public abstract void onWifiDisconnected();
}

打开和关闭WiFi：

mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);

/**
 * 打开WiFi
 */
public void openWifi() {
    if (!mWifiManager.isWifiEnabled()) {
        mWifiManager.setWifiEnabled(true);
    }
}
/**
 * 关闭WiFi
 */
public void closeWifi() {
    if (mWifiManager.isWifiEnabled()) {
        mWifiManager.setWifiEnabled(false);
    }

/**
 * 当前WiFi是否开启
 */
public boolean isWifiEnabled() {
    return mWifiManager.isWifiEnabled();
}

扫描周围可用WiFi列表：

/**
 * 扫描周围可用WiFi
 * @return
 */
public boolean startScan() {
    if(isWifiEnabled()) {
        return mWifiManager.startScan();
    }
    return false;
}

拿到WiFi扫描结果并且连接热点，当接收端连接成功后，会发一个UDP广播告知局域网内设备连接热点成功：

/**
 * WiFi广播接收器
 */
private WifiBroadcaseReceiver mWifiBroadcaseReceiver = new WifiBroadcaseReceiver() {
    @Override
    public void onWifiEnabled() {
        //WiFi已开启，开始扫描可用WiFi
        mWifiMgr.startScan();
    }
    @Override
    public void onWifiDisabled() {
        //WiFi已关闭，清除可用WiFi列表
        mSelectedSSID = "";
        mScanResults.clear();
        setupWifiAdapter();
    }
    @Override
    public void onScanResultsAvailable(List<ScanResult> scanResults) {
        //扫描周围可用WiFi成功，设置可用WiFi列表
        mScanResults.clear();
        mScanResults.addAll(scanResults);
        setupWifiAdapter();
    }
    @Override
    public void onWifiConnected(String connectedSSID) {
        //判断指定WiFi是否连接成功
        if (connectedSSID.equals(mSelectedSSID) && !mIsSendInitOrder) {
            //连接成功
            //告知发送端，接收端初始化完毕
            mHandler.sendEmptyMessage(MSG_FILE_RECEIVER_INIT_SUCCESS);
            mIsSendInitOrder = true;
        } else {
              //连接成功的不是设备WiFi，清除该WiFi，重新扫描周围WiFi
              LogUtils.e("连接到错误WiFi，正在断开重连...");
              mWifiMgr.disconnectWifi(connectedSSID);
              mWifiMgr.startScan();
        }
    }
    @Override
    public void onWifiDisconnected() {
    }
};

发送端->发送文件列表：

当发送端收到初始化完毕指令时，将用UDP广播发送文件列表。

/**
 * 等待接收端发送初始化完成指令，向其发送文件列表
 * @param serverPort
 * @throws Exception
 */
private void receiveInitSuccessOrder(int serverPort) throws Exception {
    //确保WiFi连接后获取正确IP地址
    int tryCount = 0;
    String localIpAddress = ApMgr.getHotspotLocalIpAddress(getContext());
    while (localIpAddress.equals(Consts.DEFAULT_UNKNOW_IP) && tryCount < Consts.DEFAULT_TRY_COUNT) {
        Thread.sleep(1000);
        localIpAddress = ApMgr.getHotspotLocalIpAddress(getContext());
        tryCount ++;
    }
    /** 这里使用UDP发送和接收指令 */
    mDatagramSocket = new DatagramSocket(serverPort);
    while (true) {
        byte[] receiveData = new byte[1024];
        DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
        mDatagramSocket.receive(receivePacket);
        String response = new String(receivePacket.getData()).trim();
        if(isNotEmptyString(response)) {
            LogUtils.e("接收到的消息 -------->>>" + response);
            if(response.equals(Consts.MSG_FILE_RECEIVER_INIT_SUCCESS)) {
                //初始化成功指令
                mHandler.sendEmptyMessage(MSG_FILE_RECEIVER_INIT_SUCCESS);
                //发送文件列表
                InetAddress inetAddress = receivePacket.getAddress();
                int port = receivePacket.getPort();
                //通过UDP发送文件列表给接收端
                sendFileInfoListToFileReceiverWithUdp(inetAddress, port);
            } else if(response.equals(Consts.MSG_START_SEND)) {
                //开始发送指令
                initSenderServer();
            } else {
                //接收端发来的待发送文件列表
                parseFileInfo(response);
            }
        }
    }
}

/**
 * 通过UDP发送文件列表给接收端
 * @param ipAddress IP地址
 * @param serverPort 端口号
 */
private void sendFileInfoListToFileReceiverWithUdp(InetAddress ipAddress, int serverPort) {
    if(!isEmptyList(mAllFileInfos)) {
        String jsonStr = FileInfo.toJsonStr(mAllFileInfos);
        DatagramPacket sendFileInfoPacket = new DatagramPacket(jsonStr.getBytes(), jsonStr.getBytes().length, ipAddress, serverPort);
        try {
            //发送文件列表
            mDatagramSocket.send(sendFileInfoPacket);
            LogUtils.i("发送消息 --------->>>" + jsonStr + "=== Success!");
            mHandler.obtainMessage(MSG_SET_STATUS, "成功发送文件列表...").sendToTarget();
        } catch (IOException e) {
            e.printStackTrace();
            LogUtils.i("发送消息 --------->>>" + jsonStr + "=== 失败！");
        }
    }
}

接收端->选择文件，并告知发送端开始发送：

收到文件列表后，接收端会将文件列表展示在RecyclerView控件，通过选择需要接收的文件，点击“开始发送”按钮，将发送“开始发送”指令到发送端，开启端口进行文件接收。

/**
 * 设置接收文件列表适配器
 */
private void setupReceiveFilesAdapter() {
    List<Map.Entry<String, FileInfo>> fileInfos = AppContext.getAppContext().getReceiverFileInfoMap();
    Collections.sort(fileInfos, Consts.DEFAULT_COMPARATOR);
    //设置适配器
    mReceiveFilesAdapter = new CommonAdapter<Map.Entry<String, FileInfo>>(getContext(), R.layout.item_files_selector, fileInfos) {
        @Override
        protected void convert(ViewHolder holder, Map.Entry<String, FileInfo> fileInfoMap, int position) {
            final FileInfo fileInfo = fileInfoMap.getValue();
            //文件路径
            holder.setText(R.id.tv_item_files_selector_file_path, fileInfo.getFilePath());
            //文件大小
            holder.setText(R.id.tv_item_files_selector_size, FileUtils.FormetFileSize(fileInfo.getSize()));
            //文件接收状态
            if(fileInfo.getProgress() >= 100) {
                holder.setText(R.id.tv_item_files_selector_status, "接收完毕");
            } else if(fileInfo.getProgress() == 0) {
                holder.setText(R.id.tv_item_files_selector_status, "准备接收");
            } else if(fileInfo.getProgress() < 100) {
                holder.setText(R.id.tv_item_files_selector_status, "正在接收");
            } else {
                holder.setText(R.id.tv_item_files_selector_status, "接收失败");
            }
            //文件接收进度
            ProgressBar progressBar = holder.getView(R.id.pb_item_files_selector);
            progressBar.setProgress(fileInfo.getProgress());
            //选中文件
            CheckBox checkBox = holder.getView(R.id.cb_item_files_selector);
            checkBox.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
                @Override
                public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                    if(isChecked) {
                        mSendFileInfos.add(fileInfo);
                    } else {
                        mSendFileInfos.remove(fileInfo);
                    }
                    //选中的文件个数大于零才可点击底部按钮
                    btnSendFileList.setEnabled(mSendFileInfos.size() > 0);
                }
            });
        }
    };
    mReceiveFilesRecyclerView.setAdapter(mReceiveFilesAdapter);
    //设置ListView样式
    mReceiveFilesRecyclerView.setLayoutManager(new LinearLayoutManager(getContext()));
    //分割线
    mReceiveFilesRecyclerView.addItemDecoration(new DividerItemDecoration(getContext(), DividerItemDecoration.VERTICAL));
}

/**
 * 发送选中的文件列表给发送端
 */
private void sendFileListToFileSender() {
    new Thread() {
        @Override
        public void run() {
            try {
                //获取IP地址
                String serverIp = mWifiMgr.getIpAddressFromHotspot();
                if(mDatagramSocket == null) {
                    //解决：java.net.BindException: bind failed: EADDRINUSE (Address already in use)
                    mDatagramSocket = new DatagramSocket(null);
                    mDatagramSocket.setReuseAddress(true);
                    mDatagramSocket.bind(new InetSocketAddress(Consts.DEFAULT_SERVER_UDP_PORT));
                }
                //发送选中的文件列表
                InetAddress ipAddress = InetAddress.getByName(serverIp);
                String jsonStr = FileInfo.toJsonStr(mSendFileInfos);
                DatagramPacket sendPacket = new DatagramPacket(jsonStr.getBytes(), jsonStr.getBytes().length, ipAddress, Consts.DEFAULT_SERVER_UDP_PORT);
                mDatagramSocket.send(sendPacket);
                LogUtils.i("发送消息 ------->>>" + jsonStr);
                //发送开始发送文件指令
                byte[] sendData = Consts.MSG_START_SEND.getBytes(BaseTransfer.UTF_8);
                DatagramPacket sendPacket2 = new DatagramPacket(sendData, sendData.length, ipAddress, Consts.DEFAULT_SERVER_UDP_PORT);
                mDatagramSocket.send(sendPacket2);
                LogUtils.i("发送消息 ------->>>" + sendData);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }.start();
}

/**
 * ServerSocket启动线程
 */
private class ReceiveServerRunnable implements Runnable {
    @Override
    public void run() {
        try {
            //开始接收文件
            String serverIp = mWifiMgr.getIpAddressFromHotspot();
            List<Map.Entry<String, FileInfo>> fileInfoList = AppContext.getAppContext().getReceiverFileInfoMap();
            Collections.sort(fileInfoList, Consts.DEFAULT_COMPARATOR);
            for(final Map.Entry<String, FileInfo> fileInfoMap : fileInfoList) {
                //连接发送端，逐个文件进行接收
                final int position = fileInfoList.indexOf(fileInfoMap);
                mClientSocket = new Socket(serverIp, Consts.DEFAULT_FILE_RECEIVE_SERVER_PORT);
                FileReceiver fileReceiver = new FileReceiver(mClientSocket, fileInfoMap.getValue());
                fileReceiver.setOnReceiveListener(new FileReceiver.OnReceiveListener() {
                    @Override
                    public void onStart() {
                        mHandler.obtainMessage(MSG_SET_STATUS, "开始接收"+ FileUtils.getFileName(fileInfoMap.getValue().getFilePath())).sendToTarget();
                    }
                    @Override
                    public void onProgress(FileInfo fileInfo, long progress, long total) {
                        //更新接收进度视图
                        int i_progress = (int) (progress * 100 / total);
                        LogUtils.e("正在接收：" + fileInfo.getFilePath() + "\n当前进度：" + i_progress);
                        Message msg = new Message();
                        msg.what = MSG_UPDATE_PROGRESS;
                        msg.arg1 = position;
                        msg.arg2 = i_progress;
                        mHandler.sendMessage(msg);
                    }
                    @Override
                    public void onSuccess(FileInfo fileInfo) {
                        //接收成功
                        mHandler.obtainMessage(MSG_SET_STATUS, "文件：" + FileUtils.getFileName(fileInfo.getFilePath()) + "接收成功").sendToTarget();
                        fileInfo.setResult(FileInfo.FLAG_SUCCESS);
                        AppContext.getAppContext().updateReceiverFileInfo(fileInfo);
                        Message msg = new Message();
                        msg.what = MSG_UPDATE_PROGRESS;
                        msg.arg1 = position;
                        msg.arg2 = 100;
                        mHandler.sendMessage(msg);
                    }
                    @Override
                    public void onFailure(Throwable throwable, FileInfo fileInfo) {
                        if(fileInfo != null) {
                            //接收失败
                            mHandler.obtainMessage(MSG_SET_STATUS, "文件：" + FileUtils.getFileName(fileInfo.getFilePath()) + "接收失败").sendToTarget();
                            fileInfo.setResult(FileInfo.FLAG_FAILURE);
                            AppContext.getAppContext().updateReceiverFileInfo(fileInfo);
                            Message msg = new Message();
                            msg.what = MSG_UPDATE_PROGRESS;
                            msg.arg1 = position;
                            msg.arg2 = -1;
                            mHandler.sendMessage(msg);
                        }
                    }
                });
                //加入线程池执行
                mFileReceiverList.add(fileReceiver);
                AppContext.getAppContext().MAIN_EXECUTOR.execute(fileReceiver);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

文件接收线程：

public class FileReceiver extends BaseTransfer implements Runnable {

    /**
     * 接收文件的Socket的输入输出流
     */
    private Socket mSocket;
    private InputStream mInputStream;

    /**
     * 待接收的文件数据
     */
    private FileInfo mFileInfo;

    /**
     * 用来控制线程暂停、恢复
     */
    private final Object LOCK = new Object();
    private boolean mIsPaused = false;

    /**
     * 设置未执行线程的不执行标识
     */
    private boolean mIsStop;

    /**
     * 该线程是否执行完毕
     */
    private boolean mIsFinish;

    /**
     * 文件接收监听事件
     */
    private OnReceiveListener mOnReceiveListener;


    public FileReceiver(Socket socket, FileInfo fileInfo) {
        mSocket = socket;
        mFileInfo = fileInfo;
    }

    /**
     * 设置接收监听事件
     * @param onReceiveListener
     */
    public void setOnReceiveListener(OnReceiveListener onReceiveListener) {
        mOnReceiveListener = onReceiveListener;
    }

    @Override
    public void run() {
        if(mIsStop) {
            return;
        }

        //初始化
        try {
            if(mOnReceiveListener != null) {
                mOnReceiveListener.onStart();
            }
            init();
        } catch (Exception e) {
            e.printStackTrace();
            LogUtils.i("FileReceiver init() ------->>> occur expection");
            if(mOnReceiveListener != null) {
                mOnReceiveListener.onFailure(e, mFileInfo);
            }
        }

        //发送文件实体数据
        try {
            parseBody();
        } catch (Exception e) {
            e.printStackTrace();
            LogUtils.i("FileReceiver parseBody() ------->>> occur expection");
            if(mOnReceiveListener != null) {
                mOnReceiveListener.onFailure(e, mFileInfo);
            }
        }

        //文件传输完毕
        try {
            finishTransfer();
        } catch (Exception e) {
            e.printStackTrace();
            LogUtils.i("FileReceiver finishTransfer() ------->>> occur expection");
            if(mOnReceiveListener != null) {
                mOnReceiveListener.onFailure(e, mFileInfo);
            }
        }
    }

    @Override
    public void init() throws Exception {
        if(mSocket != null) {
            mInputStream = mSocket.getInputStream();
        }
    }

    @Override
    public void parseBody() throws Exception {
        if(mFileInfo == null) {
            return;
        }

        long fileSize = mFileInfo.getSize();
        OutputStream fos = new FileOutputStream(FileUtils.gerateLocalFile(mFileInfo.getFilePath()));

        byte[] bytes = new byte[BYTE_SIZE_DATA];
        long total = 0;
        int len = 0;

        long sTime = System.currentTimeMillis();
        long eTime = 0;
        while ((len = mInputStream.read(bytes)) != -1) {
            synchronized (LOCK) {
                if(mIsPaused) {
                    try {
                        LOCK.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                //写入文件
                fos.write(bytes, 0, len);
                total = total + len;

                //每隔200毫秒返回一次进度
                eTime = System.currentTimeMillis();
                if(eTime - sTime > 200) {
                    sTime = eTime;
                    if(mOnReceiveListener != null) {
                        mOnReceiveListener.onProgress(mFileInfo, total, fileSize);
                    }
                }
            }
        }

        //文件接收成功
        if(mOnReceiveListener != null) {
            mOnReceiveListener.onSuccess(mFileInfo);
        }
        mIsFinish = true;
    }

    @Override
    public void finishTransfer() throws Exception {
        if(mInputStream != null) {
            try {
                mInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        if(mSocket != null && mSocket.isConnected()) {
            try {
                mSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 暂停接收线程
     */
    public void pause() {
        synchronized (LOCK) {
            mIsPaused = true;
            LOCK.notifyAll();
        }
    }

    /**
     * 恢复接收线程
     */
    public void resume() {
        synchronized (LOCK) {
            mIsPaused = false;
            LOCK.notifyAll();
        }
    }

    /**
     * 设置当前的接收任务不执行
     */
    public void stop() {
        mIsStop = true;
    }

    /**
     * 文件是否在接收中
     * @return
     */
    public boolean isRunning() {
        return !mIsFinish;
    }

    /**
     * 文件接收监听事件
     */
    public interface OnReceiveListener {
        void onStart();
        void onProgress(FileInfo fileInfo, long progress, long total);
        void onSuccess(FileInfo fileInfo);
        void onFailure(Throwable throwable, FileInfo fileInfo);
    }
}

发送端->发送所选文件：

收到接收端发来的文件列表和“开始发送”指令后，发送端将会把所选文件逐个发送给接收端。

/**
 * 初始化发送端服务，开始发送文件
 */
private void initSenderServer() {
    mSenderServerRunnable = new SenderServerRunnable();
    new Thread(mSenderServerRunnable).start();
}

/**
 * 文件发送线程
 */
private class SenderServerRunnable implements Runnable {
    private ServerSocket mServerSocket;
    @Override
    public void run() {
        try {
            //获取待发送的文件列表数据，按position索引排序
            List<Map.Entry<String, FileInfo>> fileInfoList = AppContext.getAppContext().getSendFileInfoMap();
            Collections.sort(fileInfoList, Consts.DEFAULT_COMPARATOR);
            mServerSocket = new ServerSocket(Consts.DEFAULT_FILE_RECEIVE_SERVER_PORT);
            //逐个文件进行发送
            for(final Map.Entry<String, FileInfo> fileInfoMap : fileInfoList) {
                final FileInfo fileInfo = fileInfoMap.getValue();
                Socket socket = mServerSocket.accept();
                FileSender fileSender = new FileSender(socket, fileInfo);
                fileSender.setOnSendListener(new FileSender.OnSendListener() {
                    @Override
                    public void onStart() {
                        mHandler.obtainMessage(MSG_SET_STATUS, "开始发送"+ FileUtils.getFileName(fileInfo.getFilePath())).sendToTarget();
                    }
                    @Override
                    public void onProgress(long progress, long total) {
                        //更新发送进度视图
                        int i_progress = (int) (progress * 100 / total);
                        LogUtils.e("正在发送：" + fileInfo.getFilePath() + "\n当前进度：" + i_progress);
                        Message msg = new Message();
                        msg.what = MSG_UPDATE_PROGRESS;
                        msg.arg1 = fileInfo.getPosition();
                        msg.arg2 = i_progress;
                        mHandler.sendMessage(msg);
                    }
                    @Override
                    public void onSuccess(FileInfo fileInfo) {
                        //发送成功
                        mHandler.obtainMessage(MSG_SET_STATUS, "文件：" + FileUtils.getFileName(fileInfo.getFilePath()) + "发送成功").sendToTarget();
                        fileInfo.setResult(FileInfo.FLAG_SUCCESS);
                        AppContext.getAppContext().updateSendFileInfo(fileInfo);
                        Message msg = new Message();
                        msg.what = MSG_UPDATE_PROGRESS;
                        msg.arg1 = fileInfo.getPosition();
                        msg.arg2 = 100;
                        mHandler.sendMessage(msg);
                    }
                    @Override
                    public void onFailure(Throwable throwable, FileInfo fileInfo) {
                        //发送失败
                        mHandler.obtainMessage(MSG_SET_STATUS, "文件：" + FileUtils.getFileName(fileInfo.getFilePath()) + "发送失败").sendToTarget();
                        fileInfo.setResult(FileInfo.FLAG_FAILURE);
                        AppContext.getAppContext().updateSendFileInfo(fileInfo);
                        Message msg = new Message();
                        msg.what = MSG_UPDATE_PROGRESS;
                        msg.arg1 = fileInfo.getPosition();
                        msg.arg2 = -1;
                        mHandler.sendMessage(msg);
                    }
                });
                //添加到线程池执行
                mFileSenderList.add(fileSender);
                AppContext.FILE_SENDER_EXECUTOR.execute(fileSender);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /**
     * 关闭Socket连接
     */
    public void closeServerSocket() {
        if(mServerSocket != null) {
            try {
                mServerSocket.close();
                mServerSocket = null;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

文件发送线程：

public class FileSender extends BaseTransfer implements Runnable {

    /**
     * 待发送的文件数据
     */
    private FileInfo mFileInfo;

    /**
     * 传送文件的Socket输入输出流
     */
    private Socket mSocket;
    private OutputStream mOutputStream;

    /**
     * 用来控制线程暂停、恢复
     */
    private final Object LOCK = new Object();
    private boolean mIsPause;

    /**
     * 该线程是否执行完毕
     */
    private boolean mIsFinish;

    /**
     * 设置未执行线程的不执行标识
     */
    private boolean mIsStop;

    /**
     * 文件传送监听事件
     */
    private OnSendListener mOnSendListener;


    public FileSender(Socket socket, FileInfo fileInfo) {
        mSocket = socket;
        mFileInfo = fileInfo;
    }

    /**
     * 设置发送监听事件
     * @param onSendListener
     */
    public void setOnSendListener(OnSendListener onSendListener) {
        mOnSendListener = onSendListener;
    }

    @Override
    public void run() {
        if(mIsStop) {
            return;
        }

        //初始化
        try {
            if(mOnSendListener != null) {
                mOnSendListener.onStart();
            }
            init();
        } catch (Exception e) {
            e.printStackTrace();
            LogUtils.i("FileSender init() ------->>> occur expection");
            if(mOnSendListener != null) {
                mOnSendListener.onFailure(e, mFileInfo);
            }
        }

        //发送文件实体数据
        try {
            parseBody();
        } catch (Exception e) {
            e.printStackTrace();
            LogUtils.i("FileSender parseBody() ------->>> occur expection");
            if(mOnSendListener != null) {
                mOnSendListener.onFailure(e, mFileInfo);
            }
        }

        //文件传输完毕
        try {
            finishTransfer();
        } catch (Exception e) {
            e.printStackTrace();
            LogUtils.i("FileSender finishTransfer() ------->>> occur expection");
            if(mOnSendListener != null) {
                mOnSendListener.onFailure(e, mFileInfo);
            }
        }
    }

    @Override
    public void init() throws Exception {
        mSocket.setSoTimeout(30 * 1000);
        OutputStream os = mSocket.getOutputStream();
        mOutputStream = new BufferedOutputStream(os);
    }

    @Override
    public void parseBody() throws Exception {
        long fileSize = mFileInfo.getSize();
        File file = new File(mFileInfo.getFilePath());
        InputStream fis = new FileInputStream(file);

        int len = 0;
        long total = 0;
        byte[] bytes = new byte[BYTE_SIZE_DATA];

        long sTime = System.currentTimeMillis();
        long eTime = 0;
        while ((len = fis.read(bytes)) != -1) {
            synchronized (LOCK) {
                if(mIsPause) {
                    try {
                        LOCK.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                //写入文件
                mOutputStream.write(bytes, 0, len);
                total += len;

                //每隔200毫秒返回一次进度
                eTime = System.currentTimeMillis();
                if(eTime - sTime > 200) {
                    sTime = eTime;
                    if(mOnSendListener != null) {
                        mOnSendListener.onProgress(total, fileSize);
                    }
                }
            }
        }

        //关闭Socket输入输出流
        mOutputStream.flush();
        mOutputStream.close();
        //文件发送成功
        if(mOnSendListener != null) {
            mOnSendListener.onSuccess(mFileInfo);
        }
        mIsFinish = true;
    }

    @Override
    public void finishTransfer() throws Exception {
        if(mOutputStream != null) {
            try {
                mOutputStream.close();
            } catch (IOException e) {

            }
        }

        if(mSocket != null && mSocket.isConnected()) {
            try {
                mSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 暂停发送线程
     */
    public void pause() {
        synchronized (LOCK) {
            mIsPause = true;
            LOCK.notifyAll();
        }
    }

    /**
     * 恢复发送线程
     */
    public void resume() {
        synchronized (LOCK) {
            mIsPause = false;
            LOCK.notifyAll();
        }
    }

    /**
     * 设置当前的发送任务不执行
     */
    public void stop() {
        mIsStop = true;
    }

    /**
     * 文件是否在发送中
     * @return
     */
    public boolean isRunning() {
        return !mIsFinish;
    }

    public interface OnSendListener {
        void onStart();
        void onProgress(long progress, long total);
        void onSuccess(FileInfo fileInfo);
        void onFailure(Throwable throwable, FileInfo fileInfo);
    }
}

因为懒，以上列出的只是部分核心代码，选择文件的功能也没去做，草草地在Activity中写死了几个文件去上传，具体代码可去Github下载运行，参见SendFilesActivity类，哈哈！

Github源码：https://github.com/WhoIsAA/SocketDemo

总结：

貌似第一次在博客中贴那么长的代码，关于Socket的知识还要学许多许多，而我懂的也只不过是入门的皮毛，以上Demo参考了以下大神博文及资料：

• Android如何实现茄子快传
• [Java TCP/IP Socket] — 单播、广播、组播
• java socket传多个文件的疑问