怎样从别人的手机上分享无线热点_百度知道
怎样从别人的手机上分享无线热点
我有更好的答案
要从别人的手机上分享无线热点，必须对方的手机开放“便携式WLAN热点”功能。安卓手机：进入手机设置中心，选“无线与网络”“网络分享和便携式热点”，然后在“便携式WLAN热点”里设置WLAN热点的属性，如SSID,密码等。然后返回上层菜单，勾选“便携式WLAN热点”。苹果手机：进入手机设置中心，选“个人热点”，设置无线密码后，点击打开”个人热点“即可。安卓手机图例：
采纳率：88%
来自团队：
对于安卓手机要在他人的手机上开启移动热点 自己手机开启WIFI搜索信号连接即可
对于安卓手机要在他人的手机上开启移动热点 自己手机开启WIFI搜索信号连接即可
本回答被提问者采纳
首先对方一定要先开热点，然后你再点开你的wifi，搜索并连接对方的热点。对方手机热点下面有登陆密码，你找对方索要就OK了(^V^)
打开别人的数据，然后打开便携式热点
其他1条回答
为您推荐：
其他类似问题
无线热点的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。02-1602-1602-1602-1602-1602-1602-1602-1602-1602-16最新范文01-0101-0101-0101-0101-0101-0101-0101-0101-0101-0101-0101-0101-0101-0101-015733人阅读
&|Android|&进阶知识（6）
最近把测试丢过来的种种BUG解决后，终于有时间去研究研究Socket通信，再加上以前做的WiFi连接和热点开启，于是有了现在的这篇博文：创建热点发送文件，让另一台手机连接热点接收文件。
两台设备是如何传输文件的：
发送端-&创建WiFi热点
接收端-&连接热点
发送端-&发送文件列表
接收端-&收到后展示文件列表，选择要接收的文件发送给发送端
发送端-&发送所选文件
接收端-&开始接收…
发送端-&创建WiFi热点：
由于Android没有直接开启热点的API，所以我们这里采用反射。
* 开启便携热点
* context 上下文
* SSID 便携热点SSID
* password 便携热点密码
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);
if(wifiManager.isWifiEnabled()) {
wifiManager.setWifiEnabled(false);
if(isApOn(context)) {
closeAp(context);
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();
filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
filter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
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 {
public void onReceive(Context context, Intent intent) {
if(intent != null) {
if(intent.getAction().equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) {
int wifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, 0);
if(wifiState == WifiManager.WIFI_STATE_ENABLED) {
onWifiEnabled();
} else if(wifiState == WifiManager.WIFI_STATE_DISABLED) {
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)) {
WifiMgr wifiMgr = new WifiMgr(context);
String connectedSSID = wifiMgr.getConnectedSSID();
onWifiConnected(connectedSSID);
} else if (info.getState().equals(NetworkInfo.State.DISCONNECTED)) {
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
public boolean startScan() {
if(isWifiEnabled()) {
return mWifiManager.startScan();
return false;
拿到WiFi扫描结果并且连接热点，当接收端连接成功后，会发一个UDP广播告知局域网内设备连接热点成功：
* WiFi广播接收器
private WifiBroadcaseReceiver mWifiBroadcaseReceiver = new WifiBroadcaseReceiver() {
public void onWifiEnabled() {
mWifiMgr.startScan();
public void onWifiDisabled() {
mSelectedSSID = "";
mScanResults.clear();
setupWifiAdapter();
public void onScanResultsAvailable(List&ScanResult& scanResults) {
mScanResults.clear();
mScanResults.addAll(scanResults);
setupWifiAdapter();
public void onWifiConnected(String connectedSSID) {
if (connectedSSID.equals(mSelectedSSID) && !mIsSendInitOrder) {
mHandler.sendEmptyMessage(MSG_FILE_RECEIVER_INIT_SUCCESS);
mIsSendInitOrder = true;
LogUtils.e("连接到错误WiFi，正在断开重连...");
mWifiMgr.disconnectWifi(connectedSSID);
mWifiMgr.startScan();
public void onWifiDisconnected() {
发送端-&发送文件列表：
当发送端收到初始化完毕指令时，将用UDP广播发送文件列表。
* 等待接收端发送初始化完成指令，向其发送文件列表
* serverPort
* Exception
private void receiveInitSuccessOrder(int serverPort) throws Exception {
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();
sendFileInfoListToFileReceiverWithUdp(inetAddress, port);
} else if(response.equals(Consts.MSG_START_SEND)) {
initSenderServer();
parseFileInfo(response);
* 通过UDP发送文件列表给接收端
* ipAddress IP地址
* 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);
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) {
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, "正在接收");
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() {
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
if(isChecked) {
mSendFileInfos.add(fileInfo);
mSendFileInfos.remove(fileInfo);
btnSendFileList.setEnabled(mSendFileInfos.size() & 0);
mReceiveFilesRecyclerView.setAdapter(mReceiveFilesAdapter);
mReceiveFilesRecyclerView.setLayoutManager(new LinearLayoutManager(getContext()));
mReceiveFilesRecyclerView.addItemDecoration(new DividerItemDecoration(getContext(), DividerItemDecoration.VERTICAL));
* 发送选中的文件列表给发送端
private void sendFileListToFileSender() {
new Thread() {
public void run() {
String serverIp = mWifiMgr.getIpAddressFromHotspot();
if(mDatagramSocket == null) {
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 {
public void run() {
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() {
public void onStart() {
mHandler.obtainMessage(MSG_SET_STATUS, "开始接收"+ FileUtils.getFileName(fileInfoMap.getValue().getFilePath())).sendToTarget();
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 =
msg.arg2 = i_
mHandler.sendMessage(msg);
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 =
msg.arg2 = 100;
mHandler.sendMessage(msg);
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 =
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 mS
private InputStream mInputS
* 待接收的文件数据
private FileInfo mFileI
* 用来控制线程暂停、恢复
private final Object LOCK = new Object();
private boolean mIsPaused = false;
* 设置未执行线程的不执行标识
private boolean mIsS
* 该线程是否执行完毕
private boolean mIsF
* 文件接收监听事件
private OnReceiveListener mOnReceiveL
public FileReceiver(Socket socket, FileInfo fileInfo) {
mFileInfo = fileI
* 设置接收监听事件
* onReceiveListener
public void setOnReceiveListener(OnReceiveListener onReceiveListener) {
mOnReceiveListener = onReceiveL
public void run() {
if(mIsStop) {
if(mOnReceiveListener != null) {
mOnReceiveListener.onStart();
} catch (Exception e) {
e.printStackTrace();
LogUtils.i("FileReceiver init() -------&&& occur expection");
if(mOnReceiveListener != null) {
mOnReceiveListener.onFailure(e, mFileInfo);
parseBody();
} catch (Exception e) {
e.printStackTrace();
LogUtils.i("FileReceiver parseBody() -------&&& occur expection");
if(mOnReceiveListener != null) {
mOnReceiveListener.onFailure(e, mFileInfo);
finishTransfer();
} catch (Exception e) {
e.printStackTrace();
LogUtils.i("FileReceiver finishTransfer() -------&&& occur expection");
if(mOnReceiveListener != null) {
mOnReceiveListener.onFailure(e, mFileInfo);
public void init() throws Exception {
if(mSocket != null) {
mInputStream = mSocket.getInputStream();
public void parseBody() throws Exception {
if(mFileInfo == null) {
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) {
LOCK.wait();
} catch (InterruptedException e) {
e.printStackTrace();
fos.write(bytes, 0, len);
total = total +
eTime = System.currentTimeMillis();
if(eTime - sTime & 200) {
sTime = eT
if(mOnReceiveListener != null) {
mOnReceiveListener.onProgress(mFileInfo, total, fileSize);
if(mOnReceiveListener != null) {
mOnReceiveListener.onSuccess(mFileInfo);
mIsFinish = true;
public void finishTransfer() throws Exception {
if(mInputStream != null) {
mInputStream.close();
} catch (IOException e) {
e.printStackTrace();
if(mSocket != null && mSocket.isConnected()) {
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;
* 文件是否在接收中
public boolean isRunning() {
return !mIsF
* 文件接收监听事件
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 mServerS
public void run() {
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() {
public void onStart() {
mHandler.obtainMessage(MSG_SET_STATUS, "开始发送"+ FileUtils.getFileName(fileInfo.getFilePath())).sendToTarget();
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_
mHandler.sendMessage(msg);
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);
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) {
mServerSocket.close();
mServerSocket = null;
} catch (IOException e) {
e.printStackTrace();
文件发送线程：
public class FileSender extends BaseTransfer implements Runnable {
* 待发送的文件数据
private FileInfo mFileI
* 传送文件的Socket输入输出流
private Socket mS
private OutputStream mOutputS
* 用来控制线程暂停、恢复
private final Object LOCK = new Object();
private boolean mIsP
* 该线程是否执行完毕
private boolean mIsF
* 设置未执行线程的不执行标识
private boolean mIsS
* 文件传送监听事件
private OnSendListener mOnSendL
public FileSender(Socket socket, FileInfo fileInfo) {
mFileInfo = fileI
* 设置发送监听事件
* onSendListener
public void setOnSendListener(OnSendListener onSendListener) {
mOnSendListener = onSendL
public void run() {
if(mIsStop) {
if(mOnSendListener != null) {
mOnSendListener.onStart();
} catch (Exception e) {
e.printStackTrace();
LogUtils.i("FileSender init() -------&&& occur expection");
if(mOnSendListener != null) {
mOnSendListener.onFailure(e, mFileInfo);
parseBody();
} catch (Exception e) {
e.printStackTrace();
LogUtils.i("FileSender parseBody() -------&&& occur expection");
if(mOnSendListener != null) {
mOnSendListener.onFailure(e, mFileInfo);
finishTransfer();
} catch (Exception e) {
e.printStackTrace();
LogUtils.i("FileSender finishTransfer() -------&&& occur expection");
if(mOnSendListener != null) {
mOnSendListener.onFailure(e, mFileInfo);
public void init() throws Exception {
mSocket.setSoTimeout(30 * 1000);
OutputStream os = mSocket.getOutputStream();
mOutputStream = new BufferedOutputStream(os);
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) {
LOCK.wait();
} catch (InterruptedException e) {
e.printStackTrace();
mOutputStream.write(bytes, 0, len);
eTime = System.currentTimeMillis();
if(eTime - sTime & 200) {
sTime = eT
if(mOnSendListener != null) {
mOnSendListener.onProgress(total, fileSize);
mOutputStream.flush();
mOutputStream.close();
if(mOnSendListener != null) {
mOnSendListener.onSuccess(mFileInfo);
mIsFinish = true;
public void finishTransfer() throws Exception {
if(mOutputStream != null) {
mOutputStream.close();
} catch (IOException e) {
if(mSocket != null && mSocket.isConnected()) {
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;
* 文件是否在发送中
public boolean isRunning() {
return !mIsF
public interface OnSendListener {
void onStart();
void onProgress(long progress, long total);
void onSuccess(FileInfo fileInfo);
void onFailure(Throwable throwable, FileInfo fileInfo);
因为懒，以上列出的只是部分核心代码，选择文件的功能也没去做，草草地在Activity中写死了几个文件去上传，具体代码可去Github下载运行，参见SendFilesActivity类，哈哈！
貌似第一次在博客中贴那么长的代码，关于Socket的知识还要学许多许多，而我懂的也只不过是入门的皮毛，以上Demo参考了以下大神博文及资料：