Android连接热点的Socket文件传输

原文链接：http://blog.csdn.net/myatlantis/article/details/68067742

原文参考了以下博客和资料：

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

最近把测试丢过来的种种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;}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

接收端->连接热点：

连接热点前先开启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;    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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();}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

打开和关闭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();}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

扫描周围可用WiFi列表：

/** * 扫描周围可用WiFi * @return */public boolean startScan() {    if(isWifiEnabled()) {        return mWifiManager.startScan();    }    return false;}
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10

拿到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() {    }};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

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

当发送端收到初始化完毕指令时，将用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 + "=== 失败！");        }    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

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

收到文件列表后，接收端会将文件列表展示在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();        }    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

文件接收线程：

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);    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209

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

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

/** * 初始化发送端服务，开始发送文件 */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();            }        }    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

文件发送线程：

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);    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206

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

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

总结：

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

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