PC客户端与Android服务端的Socket同步通信（USB）

最新推荐文章于 2023-10-06 00:42:44 发布
最新推荐文章于 2023-10-06 00:42:44 发布
阅读量797 收藏 1
点赞数
分类专栏： android 文章标签： android socket

需求：

     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("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端命令：

  

[java]  view plain copy
  1. Runtime.getRuntime().exec(  
  2. "adb shell am broadcast -a NotifyServiceStart");  

 android端的代码:ServiceBroadcastReceiver.java

 

 

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

 

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

    android的代码：

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

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

 

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

 

源码：

客户端（pc端）：

 

testPcClient.java

[java]  view plain copy
  1. import java.io.BufferedInputStream;  
  2. import java.io.BufferedOutputStream;  
  3. import java.io.BufferedReader;  
  4. import java.io.ByteArrayOutputStream;  
  5. import java.io.IOException;  
  6. import java.io.InputStream;  
  7. import java.io.InputStreamReader;  
  8. import java.net.InetAddress;  
  9. import java.net.Socket;  
  10. import java.net.UnknownHostException;  
  11.   
  12. public class testPcClient {  
  13.   
  14.     /** 
  15.      * @param args 
  16.      * @throws InterruptedException 
  17.      */  
  18.     public static void main(String[] args) throws InterruptedException {  
  19.         try {  
  20.             Runtime.getRuntime().exec(  
  21.                     "adb shell am broadcast -a NotifyServiceStop");  
  22.             Thread.sleep(3000);  
  23.             Runtime.getRuntime().exec("adb forward tcp:12580 tcp:10086");  
  24.             Thread.sleep(3000);  
  25.             Runtime.getRuntime().exec(  
  26.                     "adb shell am broadcast -a NotifyServiceStart");  
  27.             Thread.sleep(3000);  
  28.         } catch (IOException e3) {  
  29.             e3.printStackTrace();  
  30.         }  
  31.   
  32.         Socket socket = null;  
  33.         try {  
  34.             InetAddress serverAddr = null;  
  35.             serverAddr = InetAddress.getByName("127.0.0.1");  
  36.             System.out.println("TCP 1111" + "C: Connecting...");  
  37.             socket = new Socket(serverAddr, 12580);  
  38.             String str = "hi,wufenglong";  
  39.             System.out.println("TCP 221122" + "C:RECEIVE");  
  40.             BufferedOutputStream out = new BufferedOutputStream(socket  
  41.                     .getOutputStream());  
  42.             BufferedInputStream in = new BufferedInputStream(socket  
  43.                     .getInputStream());  
  44.             BufferedReader br = new BufferedReader(new InputStreamReader(  
  45.                     System.in));  
  46.             boolean flag = true;  
  47.             while (flag) {  
  48.                 System.out.print("请输入1~6的数字,退出输入exit：");  
  49.                 String strWord = br.readLine();// 从控制台输入1~6  
  50.                 if (strWord.equals("1")) {  
  51.                     out.write("1".getBytes());  
  52.                     out.flush();  
  53.                     System.out.println("1 finish sending the data");  
  54.                     String strFormsocket = readFromSocket(in);  
  55.                     System.out.println("the data sent by server is:/r/n"  
  56.                             + strFormsocket);  
  57.                     System.out  
  58.                             .println("=============================================");  
  59.                 } else if (strWord.equals("2")) {  
  60.                     out.write("2".getBytes());  
  61.                     out.flush();  
  62.                     System.out.println("2 finish sending the data");  
  63.                     String strFormsocket = readFromSocket(in);  
  64.                     System.out.println("the data sent by server is:/r/n"  
  65.                             + strFormsocket);  
  66.                     System.out  
  67.                             .println("=============================================");  
  68.                 } else if (strWord.equals("3")) {  
  69.                     out.write("3".getBytes());  
  70.                     out.flush();  
  71.                     System.out.println("3 finish sending the data");  
  72.                     String strFormsocket = readFromSocket(in);  
  73.                     System.out.println("the data sent by server is:/r/n"  
  74.                             + strFormsocket);  
  75.                     System.out  
  76.                             .println("=============================================");  
  77.                 } else if (strWord.equals("4")) {  
  78.                     /* 发送命令 */  
  79.                     out.write("4".getBytes());  
  80.                     out.flush();  
  81.                     System.out.println("send file finish sending the CMD：");  
  82.                     /* 服务器反馈：准备接收 */  
  83.                     String strFormsocket = readFromSocket(in);  
  84.                     System.out  
  85.                             .println("service ready receice data:UPDATE_CONTACTS:"  
  86.                                     + strFormsocket);  
  87.                     byte[] filebytes = FileHelper.readFile("R0013340.JPG");  
  88.                     System.out.println("file size=" + filebytes.length);  
  89.                     /* 将整数转成4字节byte数组 */  
  90.                     byte[] filelength = new byte[4];  
  91.                     filelength = tools.intToByte(filebytes.length);  
  92.                     /* 将.apk字符串转成4字节byte数组 */  
  93.                     byte[] fileformat = null;  
  94.                     fileformat = ".apk".getBytes();  
  95.                     System.out  
  96.                             .println("fileformat length=" + fileformat.length);  
  97.                     /* 字节流中前4字节为文件长度，4字节文件格式，以后是文件流 */  
  98.                     /* 注意如果write里的byte[]超过socket的缓存，系统自动分包写过去，所以对方要循环写完 */  
  99.                     out.write(filelength);  
  100.                     out.flush();  
  101.                     String strok1 = readFromSocket(in);  
  102.                     System.out.println("service receive filelength :" + strok1);  
  103.                     // out.write(fileformat);  
  104.                     // out.flush();  
  105.                     // String strok2 = readFromSocket(in);  
  106.                     // System.out.println("service receive fileformat :" +  
  107.                     // strok2);  
  108.                     System.out.println("write data to android");  
  109.                     out.write(filebytes);  
  110.                     out.flush();  
  111.                     System.out.println("*********");  
  112.   
  113.                     /* 服务器反馈：接收成功 */  
  114.                     String strread = readFromSocket(in);  
  115.                     System.out.println(" send data success:" + strread);  
  116.                     System.out  
  117.                             .println("=============================================");  
  118.                 } else if (strWord.equalsIgnoreCase("EXIT")) {  
  119.                     out.write("EXIT".getBytes());  
  120.                     out.flush();  
  121.                     System.out.println("EXIT finish sending the data");  
  122.                     String strFormsocket = readFromSocket(in);  
  123.                     System.out.println("the data sent by server is:/r/n"  
  124.                             + strFormsocket);  
  125.                     flag = false;  
  126.                     System.out  
  127.                             .println("=============================================");  
  128.                 }  
  129.             }  
  130.   
  131.         } catch (UnknownHostException e1) {  
  132.             System.out.println("TCP 331133" + "ERROR:" + e1.toString());  
  133.         } catch (Exception e2) {  
  134.             System.out.println("TCP 441144" + "ERROR:" + e2.toString());  
  135.         } finally {  
  136.             try {  
  137.                 if (socket != null) {  
  138.                     socket.close();  
  139.                     System.out.println("socket.close()");  
  140.                 }  
  141.             } catch (IOException e) {  
  142.                 System.out.println("TCP 5555" + "ERROR:" + e.toString());  
  143.             }  
  144.         }  
  145.     }  
  146.   
  147.     /* 从InputStream流中读数据 */  
  148.     public static String readFromSocket(InputStream in) {  
  149.         int MAX_BUFFER_BYTES = 4000;  
  150.         String msg = "";  
  151.         byte[] tempbuffer = new byte[MAX_BUFFER_BYTES];  
  152.         try {  
  153.             int numReadedBytes = in.read(tempbuffer, 0, tempbuffer.length);  
  154.             msg = new String(tempbuffer, 0, numReadedBytes, "utf-8");  
  155.   
  156.             tempbuffer = null;  
  157.         } catch (Exception e) {  
  158.             e.printStackTrace();  
  159.         }  
  160.         // Log.v(Service139.TAG, "msg=" + msg);  
  161.         return msg;  
  162.     }  
  163. }  

 

android服务器端：

 

主类androidService.java

 

[java]  view plain copy
  1. package com.otheri.service;  
  2.   
  3. import java.io.File;  
  4. import java.io.IOException;  
  5. import java.net.ServerSocket;  
  6. import java.net.Socket;  
  7.   
  8. import android.app.Service;  
  9. import android.content.BroadcastReceiver;  
  10. import android.content.Context;  
  11. import android.content.Intent;  
  12. import android.content.IntentFilter;  
  13. import android.os.IBinder;  
  14. import android.util.Log;  
  15.   
  16. /** 
  17.  * 设置：android手机 
  18.  *  
  19.  *  
  20.  * */  
  21. public class androidService extends Service {  
  22.     public static final String TAG = "TAG";  
  23.     public static Boolean mainThreadFlag = true;  
  24.     public static Boolean ioThreadFlag = true;  
  25.     ServerSocket serverSocket = null;  
  26.     final int SERVER_PORT = 10086;  
  27.     File testFile;  
  28.     private sysBroadcastReceiver sysBR;  
  29.   
  30.     @Override  
  31.     public void onCreate() {  
  32.         super.onCreate();  
  33.         Log.v(TAG, Thread.currentThread().getName() + "---->" + "  onCreate");  
  34.         /* 创建内部类sysBroadcastReceiver 并注册registerReceiver */  
  35.         sysRegisterReceiver();  
  36.         new Thread() {  
  37.             public void run() {  
  38.                 doListen();  
  39.             };  
  40.         }.start();  
  41.     }  
  42.   
  43.     private void doListen() {  
  44.         Log.d(TAG, Thread.currentThread().getName() + "---->"  
  45.                 + " doListen() START");  
  46.         serverSocket = null;  
  47.         try {  
  48.             Log.d(TAG, Thread.currentThread().getName() + "---->"  
  49.                     + " doListen() new serverSocket");  
  50.             serverSocket = new ServerSocket(SERVER_PORT);  
  51.   
  52.             boolean mainThreadFlag = true;  
  53.             while (mainThreadFlag) {  
  54.                 Log.d(TAG, Thread.currentThread().getName() + "---->"  
  55.                         + " doListen() listen");  
  56.   
  57.                 Socket client = serverSocket.accept();  
  58.   
  59.                 new Thread(new ThreadReadWriterIOSocket(this, client)).start();  
  60.             }  
  61.         } catch (IOException e1) {  
  62.             Log.v(androidService.TAG, Thread.currentThread().getName()  
  63.                     + "---->" + "new serverSocket error");  
  64.             e1.printStackTrace();  
  65.         }  
  66.     }  
  67.   
  68.     /* 创建内部类sysBroadcastReceiver 并注册registerReceiver */  
  69.     private void sysRegisterReceiver() {  
  70.         Log.v(TAG, Thread.currentThread().getName() + "---->"  
  71.                 + "sysRegisterReceiver");  
  72.         sysBR = new sysBroadcastReceiver();  
  73.         /* 注册BroadcastReceiver */  
  74.         IntentFilter filter1 = new IntentFilter();  
  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.     }  
  82.   
  83.     /* 内部类：BroadcastReceiver 用于接收系统事件 */  
  84.     private class sysBroadcastReceiver extends BroadcastReceiver {  
  85.   
  86.         @Override  
  87.         public void onReceive(Context context, Intent intent) {  
  88.             String action = intent.getAction();  
  89.             if (action.equalsIgnoreCase("android.intent.action.PACKAGE_ADDED")) {  
  90.                 // ReadInstalledAPP();  
  91.             } else if (action  
  92.                     .equalsIgnoreCase("android.intent.action.PACKAGE_REMOVED")) {  
  93.                 // ReadInstalledAPP();  
  94.             }  
  95.             Log.v(TAG, Thread.currentThread().getName() + "---->"  
  96.                     + "sysBroadcastReceiver onReceive");  
  97.         }  
  98.     }  
  99.   
  100.     @Override  
  101.     public void onDestroy() {  
  102.         super.onDestroy();  
  103.   
  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 (IOException e) {  
  113.             e.printStackTrace();  
  114.         }  
  115.         Log.v(TAG, Thread.currentThread().getName() + "---->"  
  116.                 + "**************** onDestroy****************");  
  117.     }  
  118.   
  119.     @Override  
  120.     public void onStart(Intent intent, int startId) {  
  121.         Log.d(TAG, Thread.currentThread().getName() + "---->" + " onStart()");  
  122.         super.onStart(intent, startId);  
  123.   
  124.     }  
  125.   
  126.     @Override  
  127.     public IBinder onBind(Intent arg0) {  
  128.         Log.d(TAG, "  onBind");  
  129.         return null;  
  130.     }  
  131.   
  132. }  

 

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

 

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

 

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

[java]  view plain copy
  1. package com.otheri.service;  
  2.   
  3. import java.io.BufferedInputStream;  
  4. import java.io.BufferedOutputStream;  
  5. import java.io.ByteArrayOutputStream;  
  6. import java.io.File;  
  7. import java.io.IOException;  
  8. import java.io.InputStream;  
  9. import java.io.OutputStream;  
  10. import java.net.Socket;  
  11.   
  12. import android.content.Context;  
  13. import android.util.Log;  
  14.   
  15. import com.otheri.util.FileHelper;  
  16. import com.otheri.util.MyUtil;  
  17.   
  18. /** 
  19.  * 功能：用于socket的交互 
  20.  *  
  21.  * @author wufenglong 
  22.  *  
  23.  */  
  24. public class ThreadReadWriterIOSocket implements Runnable {  
  25.     private Socket client;  
  26.     private Context context;  
  27.   
  28.     ThreadReadWriterIOSocket(Context context, Socket client) {  
  29.   
  30.         this.client = client;  
  31.         this.context = context;  
  32.     }  
  33.   
  34.     @Override  
  35.     public void run() {  
  36.         Log.d(androidService.TAG, Thread.currentThread().getName() + "---->"  
  37.                 + "a client has connected to server!");  
  38.         BufferedOutputStream out;  
  39.         BufferedInputStream in;  
  40.         try {  
  41.             /* PC端发来的数据msg */  
  42.             String currCMD = "";  
  43.             out = new BufferedOutputStream(client.getOutputStream());  
  44.             in = new BufferedInputStream(client.getInputStream());  
  45.             // testSocket();// 测试socket方法  
  46.             androidService.ioThreadFlag = true;  
  47.             while (androidService.ioThreadFlag) {  
  48.                 try {  
  49.                     if (!client.isConnected()) {  
  50.                         break;  
  51.                     }  
  52.   
  53.                     /* 接收PC发来的数据 */  
  54.                     Log.v(androidService.TAG, Thread.currentThread().getName()  
  55.                             + "---->" + "will read......");  
  56.                     /* 读操作命令 */  
  57.                     currCMD = readCMDFromSocket(in);  
  58.                     Log.v(androidService.TAG, Thread.currentThread().getName()  
  59.                             + "---->" + "**currCMD ==== " + currCMD);  
  60.   
  61.                     /* 根据命令分别处理数据 */  
  62.                     if (currCMD.equals("1")) {  
  63.                         out.write("OK".getBytes());  
  64.                         out.flush();  
  65.                     } else if (currCMD.equals("2")) {  
  66.                         out.write("OK".getBytes());  
  67.                         out.flush();  
  68.                     } else if (currCMD.equals("3")) {  
  69.                         out.write("OK".getBytes());  
  70.                         out.flush();  
  71.                     } else if (currCMD.equals("4")) {  
  72.                         /* 准备接收文件数据 */  
  73.                         try {  
  74.                             out.write("service receive OK".getBytes());  
  75.                             out.flush();  
  76.                         } catch (IOException e) {  
  77.                             e.printStackTrace();  
  78.                         }  
  79.   
  80.                         /* 接收文件数据，4字节文件长度，4字节文件格式，其后是文件数据 */  
  81.                         byte[] filelength = new byte[4];  
  82.                         byte[] fileformat = new byte[4];  
  83.                         byte[] filebytes = null;  
  84.   
  85.                         /* 从socket流中读取完整文件数据 */  
  86.                         filebytes = receiveFileFromSocket(in, out, filelength,  
  87.                                 fileformat);  
  88.   
  89.                         // Log.v(Service139.TAG, "receive data =" + new  
  90.                         // String(filebytes));  
  91.                         try {  
  92.                             /* 生成文件 */  
  93.                             File file = FileHelper.newFile("R0013340.JPG");  
  94.                             FileHelper.writeFile(file, filebytes, 0,  
  95.                                     filebytes.length);  
  96.                         } catch (IOException e) {  
  97.                             e.printStackTrace();  
  98.                         }  
  99.                     } else if (currCMD.equals("exit")) {  
  100.   
  101.                     }  
  102.                 } catch (Exception e) {  
  103.                     // try {  
  104.                     // out.write("error".getBytes("utf-8"));  
  105.                     // out.flush();  
  106.                     // } catch (IOException e1) {  
  107.                     // e1.printStackTrace();  
  108.                     // }  
  109.                     Log.e(androidService.TAG, Thread.currentThread().getName()  
  110.                             + "---->" + "read write error111111");  
  111.                 }  
  112.             }  
  113.             out.close();  
  114.             in.close();  
  115.         } catch (Exception e) {  
  116.             Log.e(androidService.TAG, Thread.currentThread().getName()  
  117.                     + "---->" + "read write error222222");  
  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 (IOException e) {  
  127.                 Log.e(androidService.TAG, Thread.currentThread().getName()  
  128.                         + "---->" + "read write error333333");  
  129.                 e.printStackTrace();  
  130.             }  
  131.         }  
  132.     }  
  133.   
  134.     /** 
  135.      * 功能：从socket流中读取完整文件数据 
  136.      *  
  137.      * InputStream in：socket输入流 
  138.      *  
  139.      * byte[] filelength: 流的前4个字节存储要转送的文件的字节数 
  140.      *  
  141.      * byte[] fileformat：流的前5-8字节存储要转送的文件的格式（如.apk） 
  142.      *  
  143.      * */  
  144.     public static byte[] receiveFileFromSocket(InputStream in,  
  145.             OutputStream out, byte[] filelength, byte[] fileformat) {  
  146.         byte[] filebytes = null;// 文件数据  
  147.         try {  
  148.             in.read(filelength);// 读文件长度  
  149.             int filelen = MyUtil.bytesToInt(filelength);// 文件长度从4字节byte[]转成Int  
  150.             String strtmp = "read file length ok:" + filelen;  
  151.             out.write(strtmp.getBytes("utf-8"));  
  152.             out.flush();  
  153.   
  154.             filebytes = new byte[filelen];  
  155.             int pos = 0;  
  156.             int rcvLen = 0;  
  157.             while ((rcvLen = in.read(filebytes, pos, filelen - pos)) > 0) {  
  158.                 pos += rcvLen;  
  159.             }  
  160.             Log.v(androidService.TAG, Thread.currentThread().getName()  
  161.                     + "---->" + "read file OK:file size=" + filebytes.length);  
  162.             out.write("read file ok".getBytes("utf-8"));  
  163.             out.flush();  
  164.         } catch (Exception e) {  
  165.             Log.v(androidService.TAG, Thread.currentThread().getName()  
  166.                     + "---->" + "receiveFileFromSocket error");  
  167.             e.printStackTrace();  
  168.         }  
  169.         return filebytes;  
  170.     }  
  171.   
  172.     /* 读取命令 */  
  173.     public static String readCMDFromSocket(InputStream in) {  
  174.         int MAX_BUFFER_BYTES = 2048;  
  175.         String msg = "";  
  176.         byte[] tempbuffer = new byte[MAX_BUFFER_BYTES];  
  177.         try {  
  178.             int numReadedBytes = in.read(tempbuffer, 0, tempbuffer.length);  
  179.             msg = new String(tempbuffer, 0, numReadedBytes, "utf-8");  
  180.             tempbuffer = null;  
  181.         } catch (Exception e) {  
  182.             Log.v(androidService.TAG, Thread.currentThread().getName()  
  183.                     + "---->" + "readFromSocket error");  
  184.             e.printStackTrace();  
  185.         }  
  186.         // Log.v(Service139.TAG, "msg=" + msg);  
  187.         return msg;  
  188.     }  
  189. }  

 

后面是两个辅助类：

[java]  view plain copy
  1. package com.otheri.util;  
  2.   
  3. import java.io.BufferedInputStream;  
  4. import java.io.File;  
  5. import java.io.FileInputStream;  
  6. import java.io.FileOutputStream;  
  7. import java.io.IOException;  
  8.   
  9. import com.otheri.service.androidService;  
  10.   
  11. import android.util.Log;  
  12.   
  13. public class FileHelper {  
  14.     // private static String FILEPATH = "/data/local/tmp";  
  15.   
  16.     private static String FILEPATH = "/sdcard";  
  17.   
  18.     // private static String FILEPATH = "/tmp";  
  19.   
  20.     public static File newFile(String fileName) {  
  21.         File file = null;  
  22.         try {  
  23.             file = new File(FILEPATH, fileName);  
  24.             file.delete();  
  25.             file.createNewFile();  
  26.         } catch (IOException e) {  
  27.             // TODO Auto-generated catch block  
  28.             e.printStackTrace();  
  29.         }  
  30.         return file;  
  31.     }  
  32.   
  33.     public static void writeFile(File file, byte[] data, int offset, int count)  
  34.             throws IOException {  
  35.   
  36.         FileOutputStream fos = new FileOutputStream(file, true);  
  37.         fos.write(data, offset, count);  
  38.         fos.flush();  
  39.         fos.close();  
  40.     }  
  41.   
  42.     public static byte[] readFile(String fileName) throws IOException {  
  43.         File file = new File(FILEPATH, fileName);  
  44.         file.createNewFile();  
  45.         FileInputStream fis = new FileInputStream(file);  
  46.         BufferedInputStream bis = new BufferedInputStream(fis);  
  47.         int leng = bis.available();  
  48.         Log.v(androidService.TAG, "filesize = " + leng);  
  49.         byte[] b = new byte[leng];  
  50.         bis.read(b, 0, leng);  
  51.         // Input in = new Input(fis);  
  52.         // byte[] ret = in.readAll();  
  53.         // in.close();  
  54.         bis.close();  
  55.         return b;  
  56.   
  57.     }  
  58. }  

 

[java]  view plain copy
  1. package com.otheri.util;  
  2.   
  3. import java.io.InputStream;  
  4.   
  5. import android.util.Log;  
  6.   
  7. import com.otheri.service.androidService;  
  8.   
  9. public class MyUtil {  
  10.     /* byte[]转Int */  
  11.     public static int bytesToInt(byte[] bytes) {  
  12.         int addr = bytes[0] & 0xFF;  
  13.         addr |= ((bytes[1] << 8) & 0xFF00);  
  14.         addr |= ((bytes[2] << 16) & 0xFF0000);  
  15.         addr |= ((bytes[3] << 24) & 0xFF000000);  
  16.         return addr;  
  17.     }  
  18.   
  19.     /* Int转byte[] */  
  20.     public static byte[] intToByte(int i) {  
  21.         byte[] abyte0 = new byte[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.         return abyte0;  
  27.     }  
  28.   
  29.       
  30.       
  31.       
  32. }  

line1213
关注
专栏目录
PC客户端与Android服务端的Socket同步通信.docx
04-21
PC客户端与Android服务端的Socket同步通信.docx
Android设备和PC端通过USB线通信
dami_lixm的专栏
07-13 1826
一、原理 通过 adb forward来实现，adb forward tcp:7777 tcp:8888。将本机7777端口收到的数据，转发到android设备的8888端口上。 二、实现步骤 1、在android设备上建立一个端口为8888的SocketServer，并打开server到监听状态，即serverSocket.accept()。 2、监听PC上的7777端口，即执行adb for...
android与pc的简单交互(udp+tcp的socket方式)
u012302460的专栏
03-09 1449
近段时间,公司提出数据本地化的要求,即把数据放到用户的电脑客户端内,而android客户端则通过wifi局域网和用户所使用的电脑里的 客户端程序进行交互..那么这样一来第一个难题 摆在我的面前.就是我如何与用户的电脑里的客户端和我android建立连接 .两个应用程序之间要相互连接必然要知道彼此的ip和统一的端口号才能进行连接那么如何获得ip呢? android端  // 获取本机WIFI
Android端通过usb和pc端互传json数据
Jacky_Can的博客
05-17 4099
一、关于android端和usb的通信问题 原本对usb通信相关并不是很了解，但是涉及到了usb传输数据和pc交互，于是就开始了解起来，开始查阅了很多资料，同时也问了相关的朋友，感觉都很少有涉及到的，这里来做一个简单的总结，android和pc短通过usb通信这里主要是依赖于socket通信，大概的思路如下：第一步，Android端注册一个开启和关闭Android端服务的广播，用于监听pc端要
PC客户端与Android服务端的Socket同步通信
11-01
### PC客户端与Android服务端的Socket同步通信 #### 需求分析 在现代移动设备与个人电脑(PC)之间的通信中，实现稳定的双向数据传输变得越来越重要。本篇将详细介绍如何构建一个基于Socket的同步通信系统，其中...
PC客户端与Android服务端的Socket同步通信（USB） demo
10-25
标题中的“PC客户端与Android服务端的Socket同步通信（USB）demo”指的是一个示例项目，它演示了如何使用Socket编程实现PC（个人计算机）与Android设备通过USB接口进行双向通信。这种通信方式通常用于开发者调试、...
PC客户端与Android服务端的Socket同步通信（USB)
07-23
在IT领域，尤其是在移动设备和桌面系统的交互中，"PC客户端与Android服务端的Socket同步通信（USB）"是一个重要的技术主题。这个话题涉及到多个关键知识点，包括Android的USB通信、Socket编程以及客户端-服务器架构...
PC客户端与Android手机USB Socket同步通信实现策略
本文档主要探讨了PC客户端与Android服务端之间的Socket同步通信问题，尤其关注在USB连接模式下的实现。首先，我们明确了需求背景，即需要创建一个在Android设备上后台运行的Service，作为Socket服务器端，以便处理...
Android USB 主机模式
热门推荐
莫小莫Online
12-20 2万+
Android USB Host(Android USB 主机通讯)     翻译很烂，纯当练手，大家权当消遣好了…   :》          当你的Android手机是在USB主机模式下，它充当USB主机，开启设备，并列举已连接的USB设备。 这种模式，在Android 3.1及以上版本的支持。          API 预览     在开始学习USB Host之前，理解并
Android通过USB与PC端双向通信【支持字符、文件】
04-28
Android通过USB与PC端双向通信【支持字符、文件】 代码Demo
Android手机通过usb与PC通讯
01-10
Android手机通过usb连接手机后，通过adb进行端口映射，然后使用socket通讯，包含。本资源包含pcclient和phoneserver端。如果运行不起来，注意adb的使用，安卓开发者都懂的。
Android的USB通信（AOA连接）
分享技术与经验的博客
05-09 8229
USB 主机和配件概览 Android 通过 USB 配件和 USB 主机两种模式支持各种 USB 外围设备和 Android USB 配件（实现 Android 配件协议的硬件）。在 USB 配件模式下，外部 USB 硬件充当 USB 主机。配件示例可能包括机器人控制器、扩展坞、诊断和音乐设备、自助服务终端、读卡器等等。这样，不具备主机功能的 Android 设备就能够与 USB 硬件互动。Android USB 配件必须设计为与 Android 设备兼容，并且必须遵守 Android 配件通信协议。在
通过usb利用adb实现android手机和pc机通信
u012765781的博客
01-12 3244
如：adb forward tcp:8000 tcp:9000 的意思是，将PC端的 8000 端口收到的数据，转发给手机中的 9000 端口。（3）启动PC端应用，连接端口为8000的 server（adb 创建的）之后，就可以传输数据了。（3）adbd 进程将数据发送给端口为9000的 server（手机端应用创建的）传递是双向的，（2）启动手机端应用，建立端口为9000的 server，并处于监听状态（LISTENING）（1）PC端应用将数据发送给端口为8000的 server（adb 创建的）
android 移动 app和pc 浏览器之间的对等通信
love android
12-18 2049
在项目中遇到一个问题，需要使我的androdi 移动app和 pc电脑的浏览器进行交互，需要通过WiFi，pc和手机同时连接到wifi。 手机app想浏览器发送一些数据，浏览器接收后执行一些操作后，把结果反馈给手机， 我最初的想法是移动app和一个中间端点进行通信，然后中间点在和浏览器进行交互. 有什么其他更好的解决方法吗？ 更新 我不确定 Socket.io 能否有效的解决这个，因为他
android socket编程手机做服务端,Android手机终端与PC实现socket通讯 Socket编程
weixin_29790175的博客
05-26 503
预置条件：1.Android手机和PC位于同一局域网，手机为客户端，PC为服务器2.开发平台为Eclipse+android 4.4.2, PC端为Windows XPAndroid端源码：package com.example.socketclientapp;import java.io.BufferedReader;import java.io.BufferedWriter;import ja...
Android客户端 和 pc服务器 建立socket连接并发送数据
MR_D_j的专栏
01-11 7386
文章讲解了基本的 socket连接知识 提供了一个pc服务端和安卓客户端建立socket连接的例子 并简单的消息发送
Android模拟器与PC之间的Socket通信编程
最新发布
CyberLynxO的博客
10-06 370
通过以上步骤，我们实现了Android模拟器与PC之间的Socket通信。在Android模拟器中，我们创建了一个Socket客户端来发送数据，而在PC上，我们创建了一个Socket服务器来接收数据。通过这种方式，我们可以方便地在Android开发中与PC进行通信。在Android开发中，经常需要与PC进行数据交互，而Socket通信是一种常见的实现方式。本文将介绍如何在Android模拟器和PC之间进行Socket通信，并提供相应的源代码。希望本文对你有所帮助！如有任何问题，请随时提问。
Android 与 PC通讯Socket详解
静虚待令，有物混成
06-29 877
1. 参考文章：https://blog.csdn.net/u013553529/article/details/80296870 2. PC --- Android多台设备注意事项： 2.1 adb 指令需要添加指定设备 比如：输入 adb devices 显示：AAAAAAAAAAAA device -->设备A BBBBBBBBBBBB device -->设备B 那么跟设备A 用adb通讯应操作如下： adb -s AAAAAAAAAAAA ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值