Android通过USB与PC通信

        最近项目中有一个功能需要用到Android与PC端同步数据。查阅了相关资料后，采取了一种建立在adb基础之上的Usb通信方式：由于adb可以将Usb模拟为网卡，所以可以利用socket通信的方式实现Android与PC机的通信，以完成同步功能。

一、Android与PC通信的实现

        在《PC客户端与Android服务端的Sockect同步通信》一文详细介绍了建立在adb基础之上的usb(socket)实现的具体方法。大体上的思路如下：

①Android作为server，侦探socket连接请求；添加一个服务类来实现侦听功能。

②PC端作为Client，请求建立socket连接。

③Android端添加一个广播接收类，接受PC端通过Adb发送的广播消息，以启动或者停止①中添加的服务。

④PC端通过Adb发送广播消息通知Android端启动或停止用来侦听socket连接的服务。

        1、PC端通过Adb发送广播，使Android端开启侦听Socket的服务，然后再请求连接。代码如下：

1. //连接
2. public bool DoConnect()
3. {
4. string strCmd = 'adb shell am broadcast -a NotifyServiceStop';
5. Execute(strCmd, wait_ms);
6. Thread.Sleep(wait_ms);
7. strCmd = 'adb forward tcp:12580 tcp:10086';
8. Execute(strCmd, wait_ms);
9. Thread.Sleep(wait_ms);
10. strCmd = 'adb shell am broadcast -a NotifyServiceStart';
11. Execute(strCmd, wait_ms);
12. Thread.Sleep(wait_ms);
14. IPAddress ipaddress = IPAddress.Parse('127.0.0.1');
16. tcpClient.Connect(ipaddress, 12580);
17. Thread.Sleep(wait_ms);
18. if (tcpClient != null)
19. {
20. NetworkStream networkkStream = tcpClient.GetStream();
21. networkkStream.ReadTimeout = timeOut;
22. networkkStream.WriteTimeout = timeOut;
23. reader = new BinaryReader(networkkStream);
24. writer = new BinaryWriter(networkkStream);
25. return true;
26. }
27. else
28. return false;
29. }

         其中，Execute()函数用来执行cmd命令，

private string Execute(string command, int seconds)
{
	string output = ''; //输出字符串
	if (command != null && !command.Equals(''))
	{
		Process process = new Process();//创建进程对象
		ProcessStartInfo startInfo = new ProcessStartInfo();
		startInfo.FileName = 'cmd.exe';//设定需要执行的命令
		startInfo.Arguments = '/C ' + command;//“/C”表示执行完命令后马上退出
		startInfo.UseShellExecute = false;//不使用系统外壳程序启动
		startInfo.RedirectStandardInput = false;//不重定向输入
		startInfo.RedirectStandardOutput = true; //重定向输出
		startInfo.CreateNoWindow = true;//不创建窗口
		process.StartInfo = startInfo;
		try
		{
			if (process.Start())//开始进程
			{
				if (seconds == 0)
				{
					process.WaitForExit();//这里无限等待进程结束
				}
				else
				{
					process.WaitForExit(seconds); //等待进程结束，等待时间为指定的毫秒
				}
				output = process.StandardOutput.ReadToEnd();//读取进程的输出
			}
		}
		finally
		{
			if (process != null)
				process.Close();
		}
	}
	return output;
}

        2、在Android端，首先需要添加一个广播接收类来处理广播消息，当接受到广播消息是“启动”消息时启动侦听服务，“关闭“消息时停止服务：

1. public class ServiceBroadcastReceiver extends BroadcastReceiver {
3. private static String START_ACTION = 'NotifyServiceStart';
4. private static String STOP_ACTION = 'NotifyServiceStop';
6. @Override
7. public void onReceive(Context context, Intent intent) {
8. Log.d(ConnectService.TAG, Thread.currentThread().getName() + '---->'
9. + 'ServiceBroadcastReceiver onReceive');
11. String action = intent.getAction();
12. if (START_ACTION.equalsIgnoreCase(action)) {
13. context.startService(new Intent(context, ConnectService.class));
15. Log.d(ConnectService.TAG, Thread.currentThread().getName() + '---->'
16. + 'ServiceBroadcastReceiver onReceive start end');
17. } else if (STOP_ACTION.equalsIgnoreCase(action)) {
18. context.stopService(new Intent(context, ConnectService.class));
19. Log.d(ConnectService.TAG, Thread.currentThread().getName() + '---->'
20. + 'ServiceBroadcastReceiver onReceive stop end');
21. }
22. }
23. }

       然后，添加一个服务类，用来侦听客户端的连接请求：

public class ConnectService extends Service{
	public static final String TAG = 'chl';
	public static Boolean mainThreadFlag = true;
	public static Boolean ioThreadFlag = true;
	ServerSocket serverSocket = null;
	final int SERVER_PORT = 10086;
	@Override
	public IBinder onBind(Intent intent)
	{
		return null;
	}
	@Override
	public void onCreate()
	{
		super.onCreate();
		Log.d(TAG, 'androidService--->onCreate()');
	}
	@Override
	public int onStartCommand(Intent intent, int flags, int startId)
	{
		mainThreadFlag = true;
		new Thread()
		{
			public void run()
			{
				doListen();
			};
		}.start();
		return START_NOT_STICKY;
	}
	private void doListen()
	{
		serverSocket = null;
		try
		{
			serverSocket = new ServerSocket(SERVER_PORT);
			while (mainThreadFlag)
			{
				Socket socket = serverSocket.accept();
				new Thread(new ThreadReadWriterIOSocket(this, socket)).start();
			}
		} catch (IOException e)
		{
			e.printStackTrace();
		}
	}
	@Override
	public void onDestroy()
	{
		super.onDestroy();
		mainThreadFlag = false;
		ioThreadFlag = false;	
		try
		{
			if (serverSocket != null) 
				serverSocket.close();
		} catch (IOException e)
		{
			e.printStackTrace();
		}
	}
}

         还需要添加一个线程类，来处理客户端的连接请求。建立一个连接后，启动一个此线程来完成与客户端的通信。在这里可以定义与实际需求相应的通信协议。

1. public class ThreadReadWriterIOSocket implements Runnable{
3. private Socket client;
4. private Context context;
5. private PigProtocol pigProtocol;
7. public ThreadReadWriterIOSocket(Context context, Socket client)
8. {
9. this.client = client;
10. this.context = context;
11. pigProtocol = new PigProtocol();
12. }
14. @Override
15. public void run(){
17. BufferedOutputStream out;
18. BufferedInputStream in;
20. try {
22. Header header = null;
23. out = new BufferedOutputStream(client.getOutputStream());
24. in = new BufferedInputStream(client.getInputStream());
25. ConnectService.ioThreadFlag = true;
26. while (ConnectService.ioThreadFlag){
27. try {
29. if(!client.isConnected()){
30. break;
31. }
33. header = pigProtocol.readHeaderFromSocket(in);
34. switch (header.CmdId) {
35. case 0x0001:
36. //
37. break;
38. case 0x0002:
39. //
40. break;
41. default:
42. break;
43. }
44. }
45. catch (Exception e)
46. {
47. // TODO: handle exception
48. e.printStackTrace();
49. }
50. }
51. out.close();
52. in.close();
53. }
54. catch (Exception e)
55. {
56. // TODO: handle exception
57. e.printStackTrace();
58. }
59. finally
60. {
61. try
62. {
63. if (client != null)
64. {
65. client.close();
66. }
67. } catch (IOException e)
68. {
69. e.printStackTrace();
70. }
71. }
72. }
73. }

         最后，还需要修改程序清单manifest.xml，加入代码，使程序能够接收到广播消息，并且指定处理消息的类。注意，在指定接收广播消息类、服务类时，一定要指出完整名称，如com.example.connect.ServiceBroadcastReceiver。

 <!--    添加权限    -->
 <uses-permission android:name='android.permission.INTERNET'/>
 <uses-permission android:name='android.permission.WRITE_EXTERNAL_STORAGE'/>
 <application>
     <!--    指定接受广播的类    -->
     <receiver android:name='.ServiceBroadcastReceiver'>
         <intent-filter >
             <action android:name='NotifyServiceStart'/>
             <action android:name='NotifyServiceStop' />
         </intent-filter>
     </receiver>
     <!--指定服务类-->
     <service 
         android:name='.ConnectService'>       
     </service>
 </application>

二、Android与PC端传通过socket传递对象

　　有了上面的工作，就可以实现Android与PC端通过socket(usb)传递简单的字符串了。但是在实际使用过程中，我们更多的往往是传递对象而不是简单的字符串。最简单的方法是定义相应的协议，在发送端将对象拼接为字符串，然后在接收将接收到的字符串端拆分组合为对象。但是这样实现起来不是很方便，《C#(服务器)与Java(客户端)通过Socket传递对象》一文介绍了利用Json来传递对象的方法。利用文中介绍的方法可以很方便的实现对象传递。《DataContractJsonSerializer类操作json类型数据》一文介绍了C#端json类型数据的具体使用方法。

　　我们知道，C#和Java都是完全面向对象的语言，它们都提供了List<T>泛型，所以我们可以利用List<T>泛型实现一次发送一组对象。

　　1、在PC端，首先需要完成Json类型与List<T>类型的相互转换。转换得到的Json字符串通过socket发送给Android端，或者读取得到的Json字符串转换为相应的泛型对象，这样就实现了一次发送一组对象的功能。下面是Json字符串与泛型对象相互转换的实现过程，实现了Json类型字符串与C#对象(包括List<T>类型的对象)的相互转换。

1. public static string Obj2Json<T>(T data)
2. {
3. try
4. {
5. DataContractJsonSerializer json = new DataContractJsonSerializer(data.GetType());
6. using (MemoryStream ms = new MemoryStream())
7. {
8. json.WriteObject(ms, data);
9. return Encoding.UTF8.GetString(ms.ToArray());
10. }
11. }
12. catch (System.Exception ex)
13. {
14. throw ex;
15. }
16. }
18. public static object Json2Obj(string strJson, Type t)
19. {
20. try
21. {
22. DataContractJsonSerializer json = new DataContractJsonSerializer(t);
23. using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(strJson)))
24. {
25. return json.ReadObject(ms);
26. }
27. }
28. catch (System.Exception ex)
29. {
30. throw ex;
31. }
32. }

        2、Android端Json与对象的相互转换通过开源项目google-gson实现。下载包后在项目中导入，并且添加引用import com.google.gson.Gson;就可以使用了。

        对象转换为Json字符串：

	try {
		String strTmp = gson.toJson(content);
		out.write(strTmp.getBytes());
		out.flush();
	} catch (Exception e) {
		// TODO: handle exception
		Log.d('error','writeHeaderFromSocket' + e.getMessage());
	}

        Json字符串转换为对象：

1. byte[] tempbuffer = new byte[MAX_BUFFER_BYTES];
2. try
3. {
4. int numReadedBytes = in.read(tempbuffer, 0, MAX_BUFFER_BYTES);
5. String strJson = new String(tempbuffer, 0, numReadedBytes, 'utf-8');
6. MyType myType = gson.fromJson(strJson, MyType.class);
8. tempbuffer = null;
9. } catch (Exception e)
10. {
11. e.printStackTrace();
12. }

        Json字符串转换为List<T>:

	byte[] tempbuffer = new byte[MAX_BUFFER_BYTES];
	try
	{
		int numReadedBytes = in.read(tempbuffer, 0, MAX_BUFFER_BYTES);
		String strJson = new String(tempbuffer, 0, numReadedBytes, 'utf-8');
		List<MyType> listMyType = gson.fromJson(strJson, 
				new TypeToken<List<MyType>>(){}.getType());
		tempbuffer = null;
	} catch (Exception e)
	{
		e.printStackTrace();
	}