PC 与 Android 的adb同步通信（一）

公司只能上csdn，作为中转站传资料。原文地址http://www.yidin.net/discuz/forum.php?mod=viewthread&tid=172&extra=page%3D1

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.

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

复制代码

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

        pc端命令：

1. Runtime.getRuntime().exec( 
   
2. "adb shell am broadcast -a NotifyServiceStart");

复制代码

android端的代码:ServiceBroadcastReceiver.java

1. 
   
2. package eoe.otheri.service; 
   
3. 
   
4. 
   
5. import android.content.BroadcastReceiver; 
   
6. import android.content.Context; 
   
7. import android.content.Intent; 
   
8. import android.util.Log; 
   
9. 
   
10. 
    
11. public class ServiceBroadcastReceiver extends BroadcastReceiver { 
    
12. private static String START_ACTION = "NotifyServiceStart"; 
    
13. private static String STOP_ACTION = "NotifyServiceStop"; 
    
14. 
    
15. 
    
16. @Override 
    
17. public void onReceive(Context context, Intent intent) { 
    
18. Log.d(androidService.TAG, Thread.currentThread().getName() + "---->" 
    
19. + "ServiceBroadcastReceiver onReceive"); 
    
20. String action = intent.getAction(); 
    
21. if (START_ACTION.equalsIgnoreCase(action)) { 
    
22. context.startService(new Intent(context, androidService.class)); 
    
23. Log.d(androidService.TAG, Thread.currentThread().getName() + "---->" 
    
24. + "ServiceBroadcastReceiver onReceive start end"); 
    
25. } else if (STOP_ACTION.equalsIgnoreCase(action)) { 
    
26. context.stopService(new Intent(context, androidService.class)); 
    
27. Log.d(androidService.TAG, Thread.currentThread().getName() + "---->" 
    
28. + "ServiceBroadcastReceiver onReceive stop end"); 
    
29. } 
    
30. } 
    
31. 
    
32. 
    
33. } 
    

复制代码

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

        android的代码：

1. 
   
2. public void run() { 
   
3. Log.d(androidService.TAG, Thread.currentThread().getName() + "---->" 
   
4. + "a client has connected to server!"); 
   
5. BufferedOutputStream out; 
   
6. BufferedInputStream in; 
   
7. try { 
   
8. /* PC端发来的数据msg */ 
   
9. String currCMD = ""; 
   
10. out = new BufferedOutputStream(client.getOutputStream()); 
    
11. in = new BufferedInputStream(client.getInputStream()); 
    
12. // testSocket();// 测试socket方法 
    
13. androidService.ioThreadFlag = true; 
    
14. while (androidService.ioThreadFlag) { 
    
15. try { 
    
16. if (!client.isConnected()) { 
    
17. break; 
    
18. } 
    
19. 
    
20. 
    
21. /* 接收PC发来的数据 */ 
    
22. Log.v(androidService.TAG, Thread.currentThread().getName() 
    
23. + "---->" + "will read......"); 
    
24. /* 读操作命令 */ 
    
25. currCMD = readCMDFromSocket(in); 
    
26. Log.v(androidService.TAG, Thread.currentThread().getName() 
    
27. + "---->" + "**currCMD ==== " + currCMD); 
    
28. 
    
29. 
    
30. /* 根据命令分别处理数据 */ 
    
31. if (currCMD.equals("1")) { 
    
32. out.write("OK".getBytes()); 
    
33. out.flush(); 
    
34. } else if (currCMD.equals("2")) { 
    
35. out.write("OK".getBytes()); 
    
36. out.flush(); 
    
37. } else if (currCMD.equals("3")) { 
    
38. out.write("OK".getBytes()); 
    
39. out.flush(); 
    
40. } else if (currCMD.equals("4")) { 
    
41. 
    
42. 
    
43. /* 准备接收文件数据 */ 
    
44. try { 
    
45. out.write("service receive OK".getBytes()); 
    
46. out.flush(); 
    
47. } catch (IOException e) { 
    
48. e.printStackTrace(); 
    
49. } 
    
50. 
    
51. 
    
52. /* 接收文件数据，4字节文件长度，4字节文件格式，其后是文件数据 */ 
    
53. byte[] filelength = new byte[4]; 
    
54. byte[] fileformat = new byte[4]; 
    
55. byte[] filebytes = null; 
    
56. 
    
57. 
    
58. /* 从socket流中读取完整文件数据 */ 
    
59. filebytes = receiveFileFromSocket(in, out, filelength,fileformat); 
    
60. // Log.v(Service139.TAG, "receive data =" + new 
    
61. // String(filebytes)); 
    
62. try { 
    
63. 
    
64. 
    
65. /* 生成文件 */ 
    
66. File file = FileHelper.newFile("R0013340.JPG"); 
    
67. FileHelper.writeFile(file, filebytes, 0, 
    
68. filebytes.length); 
    
69. } catch (IOException e) { 
    
70. e.printStackTrace(); 
    
71. } 
    
72. } else if (currCMD.equals("exit")) { 
    
73. } 
    
74. } catch (Exception e) { 
    
75. // try { 
    
76. // out.write("error".getBytes("utf-8")); 
    
77. // out.flush(); 
    
78. // } catch (IOException e1) { 
    
79. // e1.printStackTrace(); 
    
80. // } 
    
81. Log.e(androidService.TAG, Thread.currentThread().getName() 
    
82. + "---->" + "read write error111111"); 
    
83. } 
    
84. } 
    
85. out.close(); 
    
86. in.close(); 
    
87. } catch (Exception e) { 
    
88. Log.e(androidService.TAG, Thread.currentThread().getName() 
    
89. + "---->" + "read write error222222"); 
    
90. e.printStackTrace(); 
    
91. } finally { 
    
92. try { 
    
93. if (client != null) { 
    
94. Log.v(androidService.TAG, Thread.currentThread().getName() 
    
95. + "---->" + "client.close()"); 
    
96. client.close(); 
    
97. } 
    
98. } catch (IOException e) { 
    
99. Log.e(androidService.TAG, Thread.currentThread().getName() 
    
100. + "---->" + "read write error333333"); 
     
101. e.printStackTrace(); 
     
102. } 
     
103. } 
     

复制代码

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

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

       android端接收数据的代码:

1. /** 
   
2. * 功能：从socket流中读取完整文件数据 
   
3. * 
   
4. * InputStream in：socket输入流 
   
5. * 
   
6. * byte[] filelength: 流的前4个字节存储要转送的文件的字节数 
   
7. * 
   
8. * byte[] fileformat：流的前5-8字节存储要转送的文件的格式（如.apk） 
   
9. * 
   
10. * */ 
    
11. public static byte[] receiveFileFromSocket(InputStream in, 
    
12. OutputStream out, byte[] filelength, byte[] fileformat) { 
    
13. byte[] filebytes = null;// 文件数据 
    
14. try { 
    
15. int filelen = MyUtil.bytesToInt(filelength);// 文件长度从4字节byte[]转成Int 
    
16. String strtmp = "read file length ok:" + filelen; 
    
17. out.write(strtmp.getBytes("utf-8")); 
    
18. out.flush(); 
    
19. filebytes = new byte[filelen]; 
    
20. int pos = 0; 
    
21. int rcvLen = 0; 
    
22. while ((rcvLen = in.read(filebytes, pos, filelen - pos)) > 0) { 
    
23. pos += rcvLen; 
    
24. } 
    
25. Log.v(androidService.TAG, Thread.currentThread().getName() 
    
26. + "---->" + "read file OK:file size=" + filebytes.length); 
    
27. out.write("read file ok".getBytes("utf-8")); 
    
28. out.flush(); 
    
29. } catch (Exception e) { 
    
30. Log.v(androidService.TAG, Thread.currentThread().getName() 
    
31. + "---->" + "receiveFileFromSocket error"); 
    
32. e.printStackTrace(); 
    
33. } 
    
34. return filebytes; 
    
35. } 
    

复制代码

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

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