需求：

1.一个android端的service后台运行的程序，作为socket的服务器端;用于接收Pc client端发来的命令，来处理数据后，把结果发给PC client

2.PC端程序，作为socket的客户端，用于给android手机端发操作命令

难点分析：

1.手机一定要有adb模式，即插上USB线时马上提示的对话框选adb。好多对手机的操作都可以用adb直接作。

不过，我发现LG GW880就没有，要去下载个

2.android默认手机端的IP为“127.0.0.1”

3.要想联通PC与android手机的sokcet，一定要用adb forward 来作下端口转发才能连上socket.

[java] view plain copy

1. Runtime.getRuntime().exec("adbforwardtcp:12580tcp:10086");
2. Thread.sleep(3000);

4.android端的service程序Install到手机上容易，但是还要有方法来从PC的client端来启动手机上的service ，这个办法可以通过PC端adb命令来发一个Broastcast，手机端再写个接收BroastcastReceive来接收这个Broastcast，在这个BroastcastReceive来启动service

pc端命令：

[java] view plain copy

1. Runtime.getRuntime().exec(
2. "adbshellambroadcast-aNotifyServiceStart");

android端的代码:ServiceBroadcastReceiver.java

[java] view plain copy

1. packagecom.otheri.service;
3. importandroid.content.BroadcastReceiver;
4. importandroid.content.Context;
5. importandroid.content.Intent;
6. importandroid.util.Log;
8. publicclassServiceBroadcastReceiverextendsBroadcastReceiver{
9. privatestaticStringSTART_ACTION="NotifyServiceStart";
10. privatestaticStringSTOP_ACTION="NotifyServiceStop";
12. @Override
13. publicvoidonReceive(Contextcontext,Intentintent){
14. Log.d(androidService.TAG,Thread.currentThread().getName()+"---->"
15. +"ServiceBroadcastReceiveronReceive");
17. Stringaction=intent.getAction();
18. if(START_ACTION.equalsIgnoreCase(action)){
19. context.startService(newIntent(context,androidService.class));
21. Log.d(androidService.TAG,Thread.currentThread().getName()+"---->"
22. +"ServiceBroadcastReceiveronReceivestartend");
23. }elseif(STOP_ACTION.equalsIgnoreCase(action)){
24. context.stopService(newIntent(context,androidService.class));
25. Log.d(androidService.TAG,Thread.currentThread().getName()+"---->"
26. +"ServiceBroadcastReceiveronReceivestopend");
27. }
28. }
30. }

5.由于是USB连接，所以socket就可以设计为一但连接就一直联通，即在new socket和开完out,in流后，就用个while(true){}来循环PC端和android端的读和写

android的代码：

[java] view plain copy

1. publicvoidrun(){
2. Log.d(androidService.TAG,Thread.currentThread().getName()+"---->"
3. +"aclienthasconnectedtoserver!");
4. BufferedOutputStreamout;
5. BufferedInputStreamin;
6. try{
7. /*PC端发来的数据msg*/
8. StringcurrCMD="";
9. out=newBufferedOutputStream(client.getOutputStream());
10. in=newBufferedInputStream(client.getInputStream());
11. //testSocket();//测试socket方法
12. androidService.ioThreadFlag=true;
13. while(androidService.ioThreadFlag){
14. try{
15. if(!client.isConnected()){
16. break;
17. }
19. /*接收PC发来的数据*/
20. Log.v(androidService.TAG,Thread.currentThread().getName()
21. +"---->"+"willread......");
22. /*读操作命令*/
23. currCMD=readCMDFromSocket(in);
24. Log.v(androidService.TAG,Thread.currentThread().getName()
25. +"---->"+"**currCMD===="+currCMD);
27. /*根据命令分别处理数据*/
28. if(currCMD.equals("1")){
29. out.write("OK".getBytes());
30. out.flush();
31. }elseif(currCMD.equals("2")){
32. out.write("OK".getBytes());
33. out.flush();
34. }elseif(currCMD.equals("3")){
35. out.write("OK".getBytes());
36. out.flush();
37. }elseif(currCMD.equals("4")){
38. /*准备接收文件数据*/
39. try{
40. out.write("servicereceiveOK".getBytes());
41. out.flush();
42. }catch(IOExceptione){
43. e.printStackTrace();
44. }
46. /*接收文件数据，4字节文件长度，4字节文件格式，其后是文件数据*/
47. byte[]filelength=newbyte[4];
48. byte[]fileformat=newbyte[4];
49. byte[]filebytes=null;
51. /*从socket流中读取完整文件数据*/
52. filebytes=receiveFileFromSocket(in,out,filelength,
53. fileformat);
55. //Log.v(Service139.TAG,"receivedata="+new
56. //String(filebytes));
57. try{
58. /*生成文件*/
59. Filefile=FileHelper.newFile("R0013340.JPG");
60. FileHelper.writeFile(file,filebytes,0,
61. filebytes.length);
62. }catch(IOExceptione){
63. e.printStackTrace();
64. }
65. }elseif(currCMD.equals("exit")){
67. }
68. }catch(Exceptione){
69. //try{
70. //out.write("error".getBytes("utf-8"));
71. //out.flush();
72. //}catch(IOExceptione1){
73. //e1.printStackTrace();
74. //}
75. Log.e(androidService.TAG,Thread.currentThread().getName()
76. +"---->"+"readwriteerror111111");
77. }
78. }
79. out.close();
80. in.close();
81. }catch(Exceptione){
82. Log.e(androidService.TAG,Thread.currentThread().getName()
83. +"---->"+"readwriteerror222222");
84. e.printStackTrace();
85. }finally{
86. try{
87. if(client!=null){
88. Log.v(androidService.TAG,Thread.currentThread().getName()
89. +"---->"+"client.close()");
90. client.close();
91. }
92. }catch(IOExceptione){
93. Log.e(androidService.TAG,Thread.currentThread().getName()
94. +"---->"+"readwriteerror333333");
95. e.printStackTrace();
96. }
97. }

6.如果是在PC端和android端的读写操作来while(true){}循环，这样socket流的结尾不好判断，不能用“-1”来判断，因为“-1”是只有在socket关闭时才作为判断结尾。

7.socket在out.write(bytes);时，要是数据太大时，超过socket的缓存，socket自动分包发送，所以对方就一定要用循环来多次读。最好的办法就是服务器和客户端协议好，比如发文件时，先写过来一个要发送的文件的大小，然后再发送文件;对方用这个大小，来循环读取数据。

android端接收数据的代码:

[java] view plain copy

1. /**
2. *功能：从socket流中读取完整文件数据
3. *
4. *InputStreamin：socket输入流
5. *
6. *byte[]filelength:流的前4个字节存储要转送的文件的字节数
7. *
8. *byte[]fileformat：流的前5-8字节存储要转送的文件的格式（如.apk）
9. *
10. **/
11. publicstaticbyte[]receiveFileFromSocket(InputStreamin,
12. OutputStreamout,byte[]filelength,byte[]fileformat){
13. byte[]filebytes=null;//文件数据
14. try{
15. intfilelen=MyUtil.bytesToInt(filelength);//文件长度从4字节byte[]转成Int
16. Stringstrtmp="readfilelengthok:"+filelen;
17. out.write(strtmp.getBytes("utf-8"));
18. out.flush();
20. filebytes=newbyte[filelen];
21. intpos=0;
22. intrcvLen=0;
23. while((rcvLen=in.read(filebytes,pos,filelen-pos))>0){
24. pos+=rcvLen;
25. }
26. Log.v(androidService.TAG,Thread.currentThread().getName()
27. +"---->"+"readfileOK:filesize="+filebytes.length);
28. out.write("readfileok".getBytes("utf-8"));
29. out.flush();
30. }catch(Exceptione){
31. Log.v(androidService.TAG,Thread.currentThread().getName()
32. +"---->"+"receiveFileFromSocketerror");
33. e.printStackTrace();
34. }
35. returnfilebytes;
36. }

8.socket的最重要的机制就是读写采用的是阻塞的方式，如果客户端作为命令发起者，服务器端作为接收者的话，只有当客户端client用out.writer()写到输出流里后，即流中有数据service的read才会执行，不然就会一直停在read()那里等数据。

9.还要让服务器端可以同时连接多个client，即服务器端用new thread()来作数据读取操作。

源码：

客户端（pc端）：

testPcClient.java

[java] view plain copy

1. importjava.io.BufferedInputStream;
2. importjava.io.BufferedOutputStream;
3. importjava.io.BufferedReader;
4. importjava.io.ByteArrayOutputStream;
5. importjava.io.IOException;
6. importjava.io.InputStream;
7. importjava.io.InputStreamReader;
8. importjava.net.InetAddress;
9. importjava.net.Socket;
10. importjava.net.UnknownHostException;
12. publicclasstestPcClient{
14. /**
15. *@paramargs
16. *@throwsInterruptedException
17. */
18. publicstaticvoidmain(String[]args)throwsInterruptedException{
19. try{
20. Runtime.getRuntime().exec(
21. "adbshellambroadcast-aNotifyServiceStop");
22. Thread.sleep(3000);
23. Runtime.getRuntime().exec("adbforwardtcp:12580tcp:10086");
24. Thread.sleep(3000);
25. Runtime.getRuntime().exec(
26. "adbshellambroadcast-aNotifyServiceStart");
27. Thread.sleep(3000);
28. }catch(IOExceptione3){
29. e3.printStackTrace();
30. }
32. Socketsocket=null;
33. try{
34. InetAddressserverAddr=null;
35. serverAddr=InetAddress.getByName("127.0.0.1");
36. System.out.println("TCP1111"+"C:Connecting...");
37. socket=newSocket(serverAddr,12580);
38. Stringstr="hi,wufenglong";
39. System.out.println("TCP221122"+"C:RECEIVE");
40. BufferedOutputStreamout=newBufferedOutputStream(socket
41. .getOutputStream());
42. BufferedInputStreamin=newBufferedInputStream(socket
43. .getInputStream());
44. BufferedReaderbr=newBufferedReader(newInputStreamReader(
45. System.in));
46. booleanflag=true;
47. while(flag){
48. System.out.print("请输入1~6的数字,退出输入exit：");
49. StringstrWord=br.readLine();//从控制台输入1~6
50. if(strWord.equals("1")){
51. out.write("1".getBytes());
52. out.flush();
53. System.out.println("1finishsendingthedata");
54. StringstrFormsocket=readFromSocket(in);
55. System.out.println("thedatasentbyserveris:/r/n"
56. +strFormsocket);
57. System.out
58. .println("=============================================");
59. }elseif(strWord.equals("2")){
60. out.write("2".getBytes());
61. out.flush();
62. System.out.println("2finishsendingthedata");
63. StringstrFormsocket=readFromSocket(in);
64. System.out.println("thedatasentbyserveris:/r/n"
65. +strFormsocket);
66. System.out
67. .println("=============================================");
68. }elseif(strWord.equals("3")){
69. out.write("3".getBytes());
70. out.flush();
71. System.out.println("3finishsendingthedata");
72. StringstrFormsocket=readFromSocket(in);
73. System.out.println("thedatasentbyserveris:/r/n"
74. +strFormsocket);
75. System.out
76. .println("=============================================");
77. }elseif(strWord.equals("4")){
78. /*发送命令*/
79. out.write("4".getBytes());
80. out.flush();
81. System.out.println("sendfilefinishsendingtheCMD：");
82. /*服务器反馈：准备接收*/
83. StringstrFormsocket=readFromSocket(in);
84. System.out
85. .println("servicereadyreceicedata:UPDATE_CONTACTS:"
86. +strFormsocket);
87. byte[]filebytes=FileHelper.readFile("R0013340.JPG");
88. System.out.println("filesize="+filebytes.length);
89. /*将整数转成4字节byte数组*/
90. byte[]filelength=newbyte[4];
91. filelength=tools.intToByte(filebytes.length);
92. /*将.apk字符串转成4字节byte数组*/
93. byte[]fileformat=null;
94. fileformat=".apk".getBytes();
95. System.out
96. .println("fileformatlength="+fileformat.length);
97. /*字节流中前4字节为文件长度，4字节文件格式，以后是文件流*/
98. /*注意如果write里的byte[]超过socket的缓存，系统自动分包写过去，所以对方要循环写完*/
99. out.write(filelength);
100. out.flush();
101. Stringstrok1=readFromSocket(in);
102. System.out.println("servicereceivefilelength:"+strok1);
103. //out.write(fileformat);
104. //out.flush();
105. //Stringstrok2=readFromSocket(in);
106. //System.out.println("servicereceivefileformat:"+
107. //strok2);
108. System.out.println("writedatatoandroid");
109. out.write(filebytes);
110. out.flush();
111. System.out.println("*********");
113. /*服务器反馈：接收成功*/
114. Stringstrread=readFromSocket(in);
115. System.out.println("senddatasuccess:"+strread);
116. System.out
117. .println("=============================================");
118. }elseif(strWord.equalsIgnoreCase("EXIT")){
119. out.write("EXIT".getBytes());
120. out.flush();
121. System.out.println("EXITfinishsendingthedata");
122. StringstrFormsocket=readFromSocket(in);
123. System.out.println("thedatasentbyserveris:/r/n"
124. +strFormsocket);
125. flag=false;
126. System.out
127. .println("=============================================");
128. }
129. }
131. }catch(UnknownHostExceptione1){
132. System.out.println("TCP331133"+"ERROR:"+e1.toString());
133. }catch(Exceptione2){
134. System.out.println("TCP441144"+"ERROR:"+e2.toString());
135. }finally{
136. try{
137. if(socket!=null){
138. socket.close();
139. System.out.println("socket.close()");
140. }
141. }catch(IOExceptione){
142. System.out.println("TCP5555"+"ERROR:"+e.toString());
143. }
144. }
145. }
147. /*从InputStream流中读数据*/
148. publicstaticStringreadFromSocket(InputStreamin){
149. intMAX_BUFFER_BYTES=4000;
150. Stringmsg="";
151. byte[]tempbuffer=newbyte[MAX_BUFFER_BYTES];
152. try{
153. intnumReadedBytes=in.read(tempbuffer,0,tempbuffer.length);
154. msg=newString(tempbuffer,0,numReadedBytes,"utf-8");
156. tempbuffer=null;
157. }catch(Exceptione){
158. e.printStackTrace();
159. }
160. //Log.v(Service139.TAG,"msg="+msg);
161. returnmsg;
162. }
163. }

android服务器端：

主类androidService.java

[java] view plain copy

1. packagecom.otheri.service;
3. importjava.io.File;
4. importjava.io.IOException;
5. importjava.net.ServerSocket;
6. importjava.net.Socket;
8. importandroid.app.Service;
9. importandroid.content.BroadcastReceiver;
10. importandroid.content.Context;
11. importandroid.content.Intent;
12. importandroid.content.IntentFilter;
13. importandroid.os.IBinder;
14. importandroid.util.Log;
16. /**
17. *设置：android手机
18. *
19. *
20. **/
21. publicclassandroidServiceextendsService{
22. publicstaticfinalStringTAG="TAG";
23. publicstaticBooleanmainThreadFlag=true;
24. publicstaticBooleanioThreadFlag=true;
25. ServerSocketserverSocket=null;
26. finalintSERVER_PORT=10086;
27. FiletestFile;
28. privatesysBroadcastReceiversysBR;
30. @Override
31. publicvoidonCreate(){
32. super.onCreate();
33. Log.v(TAG,Thread.currentThread().getName()+"---->"+"onCreate");
34. /*创建内部类sysBroadcastReceiver并注册registerReceiver*/
35. sysRegisterReceiver();
36. newThread(){
37. publicvoidrun(){
38. doListen();
39. };
40. }.start();
41. }
43. privatevoiddoListen(){
44. Log.d(TAG,Thread.currentThread().getName()+"---->"
45. +"doListen()START");
46. serverSocket=null;
47. try{
48. Log.d(TAG,Thread.currentThread().getName()+"---->"
49. +"doListen()newserverSocket");
50. serverSocket=newServerSocket(SERVER_PORT);
52. booleanmainThreadFlag=true;
53. while(mainThreadFlag){
54. Log.d(TAG,Thread.currentThread().getName()+"---->"
55. +"doListen()listen");
57. Socketclient=serverSocket.accept();
59. newThread(newThreadReadWriterIOSocket(this,client)).start();
60. }
61. }catch(IOExceptione1){
62. Log.v(androidService.TAG,Thread.currentThread().getName()
63. +"---->"+"newserverSocketerror");
64. e1.printStackTrace();
65. }
66. }
68. /*创建内部类sysBroadcastReceiver并注册registerReceiver*/
69. privatevoidsysRegisterReceiver(){
70. Log.v(TAG,Thread.currentThread().getName()+"---->"
71. +"sysRegisterReceiver");
72. sysBR=newsysBroadcastReceiver();
73. /*注册BroadcastReceiver*/
74. IntentFilterfilter1=newIntentFilter();
75. /*新的应用程序被安装到了设备上的广播*/
76. filter1.addAction("android.intent.action.PACKAGE_ADDED");
77. filter1.addDataScheme("package");
78. filter1.addAction("android.intent.action.PACKAGE_REMOVED");
79. filter1.addDataScheme("package");
80. registerReceiver(sysBR,filter1);
81. }
83. /*内部类：BroadcastReceiver用于接收系统事件*/
84. privateclasssysBroadcastReceiverextendsBroadcastReceiver{
86. @Override
87. publicvoidonReceive(Contextcontext,Intentintent){
88. Stringaction=intent.getAction();
89. if(action.equalsIgnoreCase("android.intent.action.PACKAGE_ADDED")){
90. //ReadInstalledAPP();
91. }elseif(action
92. .equalsIgnoreCase("android.intent.action.PACKAGE_REMOVED")){
93. //ReadInstalledAPP();
94. }
95. Log.v(TAG,Thread.currentThread().getName()+"---->"
96. +"sysBroadcastReceiveronReceive");
97. }
98. }
100. @Override
101. publicvoidonDestroy(){
102. super.onDestroy();
104. //关闭线程
105. mainThreadFlag=false;
106. ioThreadFlag=false;
107. //关闭服务器
108. try{
109. Log.v(TAG,Thread.currentThread().getName()+"---->"
110. +"serverSocket.close()");
111. serverSocket.close();
112. }catch(IOExceptione){
113. e.printStackTrace();
114. }
115. Log.v(TAG,Thread.currentThread().getName()+"---->"
116. +"****************onDestroy****************");
117. }
119. @Override
120. publicvoidonStart(Intentintent,intstartId){
121. Log.d(TAG,Thread.currentThread().getName()+"---->"+"onStart()");
122. super.onStart(intent,startId);
124. }
126. @Override
127. publicIBinderonBind(Intentarg0){
128. Log.d(TAG,"onBind");
129. returnnull;
130. }
132. }

用于接收PC发来的Broastcast并启动主类service的ServiceBroadcastReceiver.java

[java] view plain copy

1. packagecom.otheri.service;
3. importandroid.content.BroadcastReceiver;
4. importandroid.content.Context;
5. importandroid.content.Intent;
6. importandroid.util.Log;
8. publicclassServiceBroadcastReceiverextendsBroadcastReceiver{
9. privatestaticStringSTART_ACTION="NotifyServiceStart";
10. privatestaticStringSTOP_ACTION="NotifyServiceStop";
12. @Override
13. publicvoidonReceive(Contextcontext,Intentintent){
14. Log.d(androidService.TAG,Thread.currentThread().getName()+"---->"
15. +"ServiceBroadcastReceiveronReceive");
17. Stringaction=intent.getAction();
18. if(START_ACTION.equalsIgnoreCase(action)){
19. context.startService(newIntent(context,androidService.class));
21. Log.d(androidService.TAG,Thread.currentThread().getName()+"---->"
22. +"ServiceBroadcastReceiveronReceivestartend");
23. }elseif(STOP_ACTION.equalsIgnoreCase(action)){
24. context.stopService(newIntent(context,androidService.class));
25. Log.d(androidService.TAG,Thread.currentThread().getName()+"---->"
26. +"ServiceBroadcastReceiveronReceivestopend");
27. }
28. }
30. }

用于新socket连接的读写线程类ThreadReadWriterIOSocket.java

[java] view plain copy

1. packagecom.otheri.service;
3. importjava.io.BufferedInputStream;
4. importjava.io.BufferedOutputStream;
5. importjava.io.ByteArrayOutputStream;
6. importjava.io.File;
7. importjava.io.IOException;
8. importjava.io.InputStream;
9. importjava.io.OutputStream;
10. importjava.net.Socket;
12. importandroid.content.Context;
13. importandroid.util.Log;
15. importcom.otheri.util.FileHelper;
16. importcom.otheri.util.MyUtil;
18. /**
19. *功能：用于socket的交互
20. *
21. *@authorwufenglong
22. *
23. */
24. publicclassThreadReadWriterIOSocketimplementsRunnable{
25. privateSocketclient;
26. privateContextcontext;
28. ThreadReadWriterIOSocket(Contextcontext,Socketclient){
30. this.client=client;
31. this.context=context;
32. }
34. @Override
35. publicvoidrun(){
36. Log.d(androidService.TAG,Thread.currentThread().getName()+"---->"
37. +"aclienthasconnectedtoserver!");
38. BufferedOutputStreamout;
39. BufferedInputStreamin;
40. try{
41. /*PC端发来的数据msg*/
42. StringcurrCMD="";
43. out=newBufferedOutputStream(client.getOutputStream());
44. in=newBufferedInputStream(client.getInputStream());
45. //testSocket();//测试socket方法
46. androidService.ioThreadFlag=true;
47. while(androidService.ioThreadFlag){
48. try{
49. if(!client.isConnected()){
50. break;
51. }
53. /*接收PC发来的数据*/
54. Log.v(androidService.TAG,Thread.currentThread().getName()
55. +"---->"+"willread......");
56. /*读操作命令*/
57. currCMD=readCMDFromSocket(in);
58. Log.v(androidService.TAG,Thread.currentThread().getName()
59. +"---->"+"**currCMD===="+currCMD);
61. /*根据命令分别处理数据*/
62. if(currCMD.equals("1")){
63. out.write("OK".getBytes());
64. out.flush();
65. }elseif(currCMD.equals("2")){
66. out.write("OK".getBytes());
67. out.flush();
68. }elseif(currCMD.equals("3")){
69. out.write("OK".getBytes());
70. out.flush();
71. }elseif(currCMD.equals("4")){
72. /*准备接收文件数据*/
73. try{
74. out.write("servicereceiveOK".getBytes());
75. out.flush();
76. }catch(IOExceptione){
77. e.printStackTrace();
78. }
80. /*接收文件数据，4字节文件长度，4字节文件格式，其后是文件数据*/
81. byte[]filelength=newbyte[4];
82. byte[]fileformat=newbyte[4];
83. byte[]filebytes=null;
85. /*从socket流中读取完整文件数据*/
86. filebytes=receiveFileFromSocket(in,out,filelength,
87. fileformat);
89. //Log.v(Service139.TAG,"receivedata="+new
90. //String(filebytes));
91. try{
92. /*生成文件*/
93. Filefile=FileHelper.newFile("R0013340.JPG");
94. FileHelper.writeFile(file,filebytes,0,
95. filebytes.length);
96. }catch(IOExceptione){
97. e.printStackTrace();
98. }
99. }elseif(currCMD.equals("exit")){
101. }
102. }catch(Exceptione){
103. //try{
104. //out.write("error".getBytes("utf-8"));
105. //out.flush();
106. //}catch(IOExceptione1){
107. //e1.printStackTrace();
108. //}
109. Log.e(androidService.TAG,Thread.currentThread().getName()
110. +"---->"+"readwriteerror111111");
111. }
112. }
113. out.close();
114. in.close();
115. }catch(Exceptione){
116. Log.e(androidService.TAG,Thread.currentThread().getName()
117. +"---->"+"readwriteerror222222");
118. e.printStackTrace();
119. }finally{
120. try{
121. if(client!=null){
122. Log.v(androidService.TAG,Thread.currentThread().getName()
123. +"---->"+"client.close()");
124. client.close();
125. }
126. }catch(IOExceptione){
127. Log.e(androidService.TAG,Thread.currentThread().getName()
128. +"---->"+"readwriteerror333333");
129. e.printStackTrace();
130. }
131. }
132. }
134. /**
135. *功能：从socket流中读取完整文件数据
136. *
137. *InputStreamin：socket输入流
138. *
139. *byte[]filelength:流的前4个字节存储要转送的文件的字节数
140. *
141. *byte[]fileformat：流的前5-8字节存储要转送的文件的格式（如.apk）
142. *
143. **/
144. publicstaticbyte[]receiveFileFromSocket(InputStreamin,
145. OutputStreamout,byte[]filelength,byte[]fileformat){
146. byte[]filebytes=null;//文件数据
147. try{
148. in.read(filelength);//读文件长度
149. intfilelen=MyUtil.bytesToInt(filelength);//文件长度从4字节byte[]转成Int
150. Stringstrtmp="readfilelengthok:"+filelen;
151. out.write(strtmp.getBytes("utf-8"));
152. out.flush();
154. filebytes=newbyte[filelen];
155. intpos=0;
156. intrcvLen=0;
157. while((rcvLen=in.read(filebytes,pos,filelen-pos))>0){
158. pos+=rcvLen;
159. }
160. Log.v(androidService.TAG,Thread.currentThread().getName()
161. +"---->"+"readfileOK:filesize="+filebytes.length);
162. out.write("readfileok".getBytes("utf-8"));
163. out.flush();
164. }catch(Exceptione){
165. Log.v(androidService.TAG,Thread.currentThread().getName()
166. +"---->"+"receiveFileFromSocketerror");
167. e.printStackTrace();
168. }
169. returnfilebytes;
170. }
172. /*读取命令*/
173. publicstaticStringreadCMDFromSocket(InputStreamin){
174. intMAX_BUFFER_BYTES=2048;
175. Stringmsg="";
176. byte[]tempbuffer=newbyte[MAX_BUFFER_BYTES];
177. try{
178. intnumReadedBytes=in.read(tempbuffer,0,tempbuffer.length);
179. msg=newString(tempbuffer,0,numReadedBytes,"utf-8");
180. tempbuffer=null;
181. }catch(Exceptione){
182. Log.v(androidService.TAG,Thread.currentThread().getName()
183. +"---->"+"readFromSocketerror");
184. e.printStackTrace();
185. }
186. //Log.v(Service139.TAG,"msg="+msg);
187. returnmsg;
188. }
189. }

后面是两个辅助类：

[java] view plain copy

1. packagecom.otheri.util;
3. importjava.io.BufferedInputStream;
4. importjava.io.File;
5. importjava.io.FileInputStream;
6. importjava.io.FileOutputStream;
7. importjava.io.IOException;
9. importcom.otheri.service.androidService;
11. importandroid.util.Log;
13. publicclassFileHelper{
14. //privatestaticStringFILEPATH="/data/local/tmp";
16. privatestaticStringFILEPATH="/sdcard";
18. //privatestaticStringFILEPATH="/tmp";
20. publicstaticFilenewFile(StringfileName){
21. Filefile=null;
22. try{
23. file=newFile(FILEPATH,fileName);
24. file.delete();
25. file.createNewFile();
26. }catch(IOExceptione){
27. //TODOAuto-generatedcatchblock
28. e.printStackTrace();
29. }
30. returnfile;
31. }
33. publicstaticvoidwriteFile(Filefile,byte[]data,intoffset,intcount)
34. throwsIOException{
36. FileOutputStreamfos=newFileOutputStream(file,true);
37. fos.write(data,offset,count);
38. fos.flush();
39. fos.close();
40. }
42. publicstaticbyte[]readFile(StringfileName)throwsIOException{
43. Filefile=newFile(FILEPATH,fileName);
44. file.createNewFile();
45. FileInputStreamfis=newFileInputStream(file);
46. BufferedInputStreambis=newBufferedInputStream(fis);
47. intleng=bis.available();
48. Log.v(androidService.TAG,"filesize="+leng);
49. byte[]b=newbyte[leng];
50. bis.read(b,0,leng);
51. //Inputin=newInput(fis);
52. //byte[]ret=in.readAll();
53. //in.close();
54. bis.close();
55. returnb;
57. }
58. }

[java] view plain copy

1. packagecom.otheri.util;
3. importjava.io.InputStream;
5. importandroid.util.Log;
7. importcom.otheri.service.androidService;
9. publicclassMyUtil{
10. /*byte[]转Int*/
11. publicstaticintbytesToInt(byte[]bytes){
12. intaddr=bytes[0]&0xFF;
13. addr|=((bytes[1]<<8)&0xFF00);
14. addr|=((bytes[2]<<16)&0xFF0000);
15. addr|=((bytes[3]<<24)&0xFF000000);
16. returnaddr;
17. }
19. /*Int转byte[]*/
20. publicstaticbyte[]intToByte(inti){
21. byte[]abyte0=newbyte[4];
22. abyte0[0]=(byte)(0xff&i);
23. abyte0[1]=(byte)((0xff00&i)>>8);
24. abyte0[2]=(byte)((0xff0000&i)>>16);
25. abyte0[3]=(byte)((0xff000000&i)>>24);
26. returnabyte0;
27. }
32. }
    

更多相关文章

1. 一款常用的 Squid 日志分析工具
2. GitHub 标星 8K+！一款开源替代 ls 的工具你值得拥有！
3. “罗永浩抖音首秀”销售数据的可视化大屏是怎么做出来的呢？
4. Nginx系列教程（三）| 一文带你读懂Nginx的负载均衡
5. RHEL 6 下 DHCP+TFTP+FTP+PXE+Kickstart 实现无人值守安装
6. Linux 环境下实战 Rsync 备份工具及配置 rsync+inotify 实时同步
7. 不吹不黑！GitHub 上帮助人们学习编码的 12 个资源，错过血亏...
8. Android(安卓)自定义 View 之使用 SurfaceView 实现动画
9. Android(安卓)NDK下编译google protocol buffer(protobuf)

随机推荐

1. Android(安卓)自定义View基本用法
2. 大话Fragment管理
3. Android:Exported receiver does not req
4. Android-Adapter适配器
5. Intellij Idea gradle Android(安卓)depe
6. Android：apk签名
7. 安卓入门 之 开发环境搭建
8. Android(安卓)RecyclerView 的点击事件
9. android一键退出
10. Android的TextView与Html相结合的用法