wiyun
wiyun

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

PC客户端与Android服务端的Socket同步通信（USB） 博客分类： Android
Socket Android thread .net 设计模式

http://blog.csdn.net/wufenglong/category/687662.aspx

需求：

     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); 
Java代码 复制代码
  1. Runtime.getRuntime().exec("adb forward tcp:12580 tcp:10086"); 
  2.             Thread.sleep(3000); 
Runtime.getRuntime().exec("adb forward tcp:12580 tcp:10086"); Thread.sleep(3000);

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

     

    pc端命令：

 

view plain copy to clipboard print ?
  1. Runtime.getRuntime().exec( 
  2. "adb shell am broadcast -a NotifyServiceStart"); 
Java代码 复制代码
  1. Runtime.getRuntime().exec( 
  2. "adb shell am broadcast -a NotifyServiceStart"); 
Runtime.getRuntime().exec( "adb shell am broadcast -a NotifyServiceStart");

android端的代码:ServiceBroadcastReceiver.java

view plain copy to clipboard print ?
  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. } 

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

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

    android的代码：

view plain copy to clipboard print ?
  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.         } 

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

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

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

   android端接收数据的代码:

view plain copy to clipboard print ?
  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.     } 

Java代码 复制代码
  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.     } 
/** * 功能：从socket流中读取完整文件数据 * * InputStream in：socket输入流 * * byte[] filelength: 流的前4个字节存储要转送的文件的字节数 * * byte[] fileformat：流的前5-8字节存储要转送的文件的格式（如.apk） * * */ public static byte[] receiveFileFromSocket(InputStream in, OutputStream out, byte[] filelength, byte[] fileformat) { byte[] filebytes = null;// 文件数据 try { int filelen = MyUtil.bytesToInt(filelength);// 文件长度从4字节byte[]转成Int String strtmp = "read file length ok:" + filelen; out.write(strtmp.getBytes("utf-8")); out.flush(); filebytes = new byte[filelen]; int pos = 0; int rcvLen = 0; while ((rcvLen = in.read(filebytes, pos, filelen - pos)) > 0) { pos += rcvLen; } Log.v(androidService.TAG, Thread.currentThread().getName() + "---->" + "read file OK:file size=" + filebytes.length); out.write("read file ok".getBytes("utf-8")); out.flush(); } catch (Exception e) { Log.v(androidService.TAG, Thread.currentThread().getName() + "---->" + "receiveFileFromSocket error"); e.printStackTrace(); } return filebytes; }

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

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

源码：

客户端（pc端）：

testPcClient.java

view plain copy to clipboard print ?
  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. } 

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

android服务器端：

主类androidService.java

view plain copy to clipboard print ?
  1. package com.otheri.service; 
  2.  
  3. import java.io.File; 

你可能感兴趣的:(Android)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）... weixin_39762838 mac备份android手机通讯录导入iphone
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • Android应用性能优化 轻口味 Android
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
  • Android实现监听事件的方法 Amy木婉清
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
  • 高级UI<第二十四篇>：Android中用到的矩阵常识 NoBugException
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
  • RK3229_Android9.0_Box 4G模块EC200A调试 suifen_ 网络
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
  • kt文件和java文件_Java与Kotlin之间怎样进行互操作 铭空间 kt文件和java文件
    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
  • Android shell 常用 debug 命令 晨春计 Audiodebugandroidlinux
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面 2401_84544531 程序员android面试学习
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT) 计算机源码社 Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
  • android ndk 开发jni调用对象方法，数组参数 wulongkou 开发问题安卓的事ndkandroidstudiojni
    一、JNI和NDK关系JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动
  • Android jni中数组参数的传递方式 lokeyme Andriodandroid开发JNINDKjavac语言
    1、背景今天调试了一下Androidjni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是：C代码，入口函数#include#includejintJava_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv*env,jobjectthiz,jintAttr[]){returnAttr[
  • 1-1.Jetpack 之 Navigation 简单编码模板 我命由我12345 Android-Jetpack简化编程javajava-eeandroid-studioandroidstudio安卓androidjetpack
    一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用 erhtre 程序员androidjetpack架构sqlite
    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
  • Android干净架构MVI模板使用指南 井美婵Toby
    Android干净架构MVI模板使用指南android-clean-architecture-mvi-boilerplateAforkofourcleanarchitectureboilerplateusingtheModel-View-Intentpattern项目地址:https://gitcode.com/gh_mirrors/an/android-clean-architecture-mv
  • ⭐Unity 安卓环境中正确地读取和处理 XML 文件 惊鸿醉 Unityunityandroidxml
    写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
  • 《Android进阶之光》读书笔记 soleil雪寂 读书笔记#Android进阶之光
    文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
  • 《Android进阶之光》— Android 书籍 王睿丶 Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
  • 《android进阶之光》——多线程编程（上） TAING要一直努力 读书笔记
    今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
  • android进阶之光！Android面试必备的集合源码详解，系列篇 程序员Sunbu 程序员Android
    前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
  • Android-悬浮窗功能的实现（附Java、KT实现源码）(1) egrhef 程序员androidjava开发语言
    //获取服务的操作对象valbinder=serviceasFloatWinfowServices.MyBinderbinder.service}overridefunonServiceDisconnected(name:ComponentName){}}overridefunonActivityResult(requestCode:Int,resultCode:Int,data:Intent){
  • Visual Studio中的Android模拟器使用详解 wurui8 androidandroidstudioandroidandroid应用
    关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
  • Unity 热更 之 【HybirdCLR】+【YooAsset】 [安卓 Android端] [代码 + 资源热更] 功能的 简单实现演示 仙魁XAN Unity进阶unityHybirdCLRYooAssetHotUpdate热更新
    Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示目录Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示一、简单介绍二、HybridCLR三、YooAsset四、HybirdCLR引入工程五、YooAsset引入工程六、Python服务器简单构建七、Hybir
  • Android 用线程池实现一个简单的任务队列(Kotlin) 深海呐 Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
  • （小白入门）Windows环境下搭建React Native Android开发环境 码农老黑 前端ReactNative移动开发Androidstudio
    ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
  • Android Dialog圆角设置无效的问题 ly969434341 android
    一，参考AndroidDialog圆角设置无效的问题https://blog.csdn.net/woshi_awei/article/details/99664527Android自定义Dialog实现通用圆角对话框https://cloud.tencent.com/developer/article/1740956二，原因Diallog的默认背景是白色（直角背景），我自定义的Dialog背景也是
  • MultiSnapRecyclerView：让Android RecyclerView的滚动停靠更灵活 技术无疆 Androidandroiduiandroidstudioandroid-studiojavaandroidx
    在Android应用开发中，RecyclerView是一个强大且灵活的组件，用于展示大量数据集合。然而，标准的RecyclerView只支持单一的滚动停靠点，这在某些场景下可能不够灵活。为了解决这个问题，TakuSemba开发了一个名为MultiSnapRecyclerView的库，它允许开发者在RecyclerView中实现多个滚动停靠点。文章目录什么是MultiSnapRecyclerView
  • Android界面特效全汇总 小飞鹤 Android开发详解android
    （一）Activity页面切换的效果Android2.0之后有了overridePendingTransition（），其中里面两个参数，一个是前一个activity的退出两一个activity的进入，Java代码1.@OverridepublicvoidonCreate(BundlesavedInstanceState){2.super.onCreate(savedInstanceState);
  • java数字签名三种方式 知了ing javajdk
    以下3钟数字签名都是基于jdk7的 1，RSA String password="test"; // 1.初始化密钥 KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); keyPairGenerator.initialize(51
  • Hibernate学习笔记 caoyong Hibernate
    1>、Hibernate是数据访问层框架，是一个ORM(Object Relation Mapping)框架，作者为:Gavin King 2>、搭建Hibernate的开发环境      a>、添加jar包:      aa>、hibernatte开发包中/lib/required/所
  • 设计模式之装饰器模式Decorator（结构型） 漂泊一剑客 Decorator
    1. 概述        若你从事过面向对象开发，实现给一个类或对象增加行为，使用继承机制，这是所有面向对象语言的一个基本特性。如果已经存在的一个类缺少某些方法，或者须要给方法添加更多的功能（魅力），你也许会仅仅继承这个类来产生一个新类—这建立在额外的代码上。      
  • 读取磁盘文件txt，并输入String 一炮送你回车库 String
    public static void main(String[] args) throws IOException {    String fileContent = readFileContent("d:/aaa.txt");    System.out.println(fileContent);   
  • js三级联动下拉框 3213213333332132 三级联动
    //三级联动 省/直辖市<select id="province"></select> 市/省直辖<select id="city"></select> 县/区 <select id="area"></select>
  • erlang之parse_transform编译选项的应用 616050468 parse_transform游戏服务器属性同步abstract_code
             最近使用erlang重构了游戏服务器的所有代码，之前看过C++/lua写的服务器引擎代码，引擎实现了玩家属性自动同步给前端和增量更新玩家数据到数据库的功能，这也是现在很多游戏服务器的优化方向，在引擎层面去解决数据同步和数据持久化，数据发生变化了业务层不需要关心怎么去同步给前端。由于游戏过程中玩家每个业务中玩家数据更改的量其实是很少
  • JAVA JSON的解析 darkranger java
    // { // “Total”：“条数”， // Code: 1, // // “PaymentItems”:[ // { // “PaymentItemID”:”支款单ID”, // “PaymentCode”:”支款单编号”, // “PaymentTime”:”支款日期”, // ”ContractNo”:”合同号”， //
  • POJ-1273-Drainage Ditches aijuans ACM_POJ
    POJ-1273-Drainage Ditches http://poj.org/problem?id=1273 基本的最大流，按LRJ的白书写的 #include<iostream> #include<cstring> #include<queue> using namespace std; #define INF 0x7fffffff int ma
  • 工作流Activiti5表的命名及含义 atongyeye 工作流Activiti
    activiti5 - http://activiti.org/designer/update在线插件安装 activiti5一共23张表 Activiti的表都以ACT_开头。 第二部分是表示表的用途的两个字母标识。 用途也和服务的API对应。 ACT_RE_*: 'RE'表示repository。 这个前缀的表包含了流程定义和流程静态资源 （图片，规则，等等）。 A
  • android的广播机制和广播的简单使用 百合不是茶 android广播机制广播的注册
          Android广播机制简介 在Android中，有一些操作完成以后，会发送广播，比如说发出一条短信，或打出一个电话，如果某个程序接收了这个广播，就会做相应的处理。这个广播跟我们传统意义中的电台广播有些相似之处。之所以叫做广播，就是因为它只负责“说”而不管你“听不听”，也就是不管你接收方如何处理。另外，广播可以被不只一个应用程序所接收，当然也可能不被任何应
  • Spring事务传播行为详解 bijian1013 javaspring事务传播行为
            在service类前加上@Transactional，声明这个service所有方法需要事务管理。每一个业务方法开始时都会打开一个事务。         Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这
  • eidtplus operate 征客丶 eidtplus
    开启列模式: Alt+C 鼠标选择   OR   Alt+鼠标左键拖动 列模式替换或复制内容(多行): 右键-->格式-->填充所选内容-->选择相应操作 OR Ctrl+Shift+V(复制多行数据,必须行数一致) -------------------------------------------------------
  • 【Kafka一】Kafka入门 bit1129 kafka
    这篇文章来自Spark集成Kafka(http://bit1129.iteye.com/blog/2174765)，这里把它单独取出来，作为Kafka的入门吧   下载Kafka http://mirror.bit.edu.cn/apache/kafka/0.8.1.1/kafka_2.10-0.8.1.1.tgz 2.10表示Scala的版本，而0.8.1.1表示Kafka
  • Spring 事务实现机制 BlueSkator spring代理事务
    Spring是以代理的方式实现对事务的管理。我们在Action中所使用的Service对象，其实是代理对象的实例，并不是我们所写的Service对象实例。既然是两个不同的对象，那为什么我们在Action中可以象使用Service对象一样的使用代理对象呢？为了说明问题，假设有个Service类叫AService，它的Spring事务代理类为AProxyService，AService实现了一个接口
  • bootstrap源码学习与示例：bootstrap-dropdown（转帖） BreakingBad bootstrapdropdown
    bootstrap-dropdown组件是个烂东西，我读后的整体感觉。 一个下拉开菜单的设计： <ul class="nav pull-right"> <li id="fat-menu" class="dropdown">
  • 读《研磨设计模式》-代码笔记-中介者模式-Mediator bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /* * 中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。 * 中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。 * * 在我看来，Mediator模式是把多个对象（
  • 常用代码记录 chenjunt3 UIExcelJ#
      1、单据设置某行或某字段不能修改 //i是行号,"cash"是字段名称 getBillCardPanelWrapper().getBillCardPanel().getBillModel().setCellEditable(i, "cash", false); //取得单据表体所有项用以上语句做循环就能设置整行了 getBillC
  • 搜索引擎与工作流引擎 comsci 算法工作搜索引擎网络应用
          最近在公司做和搜索有关的工作，(只是简单的应用开源工具集成到自己的产品中)工作流系统的进一步设计暂时放在一边了，偶然看到谷歌的研究员吴军写的数学之美系列中的搜索引擎与图论这篇文章中的介绍，我发现这样一个关系(仅仅是猜想)   -----搜索引擎和流程引擎的基础--都是图论，至少像在我在JWFD中引擎算法中用到的是自定义的广度优先
  • oracle Health Monitor daizj oracleHealth Monitor
    About Health Monitor Beginning with Release 11g, Oracle Database includes a framework called Health Monitor for running diagnostic checks on the database. About Health Monitor Checks Health M
  • JSON字符串转换为对象 dieslrae javajson
        作为前言,首先是要吐槽一下公司的脑残编译部署方式,web和core分开部署本来没什么问题,但是这丫居然不把json的包作为基础包而作为web的包,导致了core端不能使用,而且我们的core是可以当web来用的(不要在意这些细节),所以在core中处理json串就是个问题.没办法,跟编译那帮人也扯不清楚,只有自己写json的解析了.   
  • C语言学习八结构体，综合应用，学生管理系统 dcj3sjt126com C语言
    实现功能的代码： # include <stdio.h> # include <malloc.h> struct Student { int age; float score; char name[100]; }; int main(void) { int len; struct Student * pArr; int i,
  • vagrant学习笔记 dcj3sjt126com vagrant
    想了解多主机是如何定义和使用的, 所以又学习了一遍vagrant   1. vagrant virtualbox 下载安装 https://www.vagrantup.com/downloads.html https://www.virtualbox.org/wiki/Downloads   查看安装在命令行输入vagrant     2.
  • 14.性能优化-优化-软件配置优化 frank1234 软件配置性能优化
    1.Tomcat线程池 修改tomcat的server.xml文件： <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" maxThreads="1200" m
  • 一个不错的shell 脚本教程 入门级 HarborChung linuxshell
    一个不错的shell 脚本教程 入门级 建立一个脚本 　　Linux中有好多中不同的shell，但是通常我们使用bash (bourne again shell) 进行shell编程，因为bash是免费的并且很容易使用。所以在本文中笔者所提供的脚本都是使用bash（但是在大多数情况下，这些脚本同样可以在 bash的大姐，bourne shell中运行）。 　　如同其他语言一样
  • Spring4新特性——核心容器的其他改进 jinnianshilongnian spring动态代理spring4依赖注入
    Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
  • Linux设置tomcat开机启动 liuxingguome tomcatlinux开机自启动
    执行命令sudo gedit /etc/init.d/tomcat6 然后把以下英文部分复制过去。（注意第一句#!/bin/sh如果不写，就不是一个shell文件。然后将对应的jdk和tomcat换成你自己的目录就行了。 #!/bin/bash # # /etc/rc.d/init.d/tomcat # init script for tomcat precesses
  • 第13章 Ajax进阶（下） onestopweb Ajax
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • Troubleshooting Crystal Reports off BW blueoxygen BO
    http://wiki.sdn.sap.com/wiki/display/BOBJ/Troubleshooting+Crystal+Reports+off+BW#TroubleshootingCrystalReportsoffBW-TracingBOE   Quite useful, especially this part: SAP BW connectivity For t
  • Java开发熟手该当心的11个错误 tomcat_oracle javajvm多线程单元测试
    #1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收 测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
  • 正则表达式大全 yang852220741 html编程正则表达式
    今天向大家分享正则表达式大全，它可以大提高你的工作效率 正则表达式也可以被当作是一门语言，当你学习一门新的编程语言的时候，他们是一个小的子语言。初看时觉得它没有任何的意义，但是很多时候，你不得不阅读一些教程，或文章来理解这些简单的描述模式。 一、校验数字的表达式 数字：^[0-9]*$ n位的数字：^\d{n}$ 至少n位的数字：^\d{n,}$ m-n位的数字：^\d{m,n}$
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他