Android 中的 IPC 方式

    1. Activity，Service，Receiver 都支持在 Intent 中传递 Bundle 数据，而 Bundle 实现了 Parcelable 接口，可以在不同的进程间进行传输。
    2. 在一个进程中启动了另一个进程的 Activity，Service 和 Receiver ，可以在 Bundle 中附加要传递的数据通过 Intent 发送出去。

    二、使用文件共享

    1. Windows 上，一个文件如果被加了排斥锁会导致其他线程无法对其进行访问，包括读和写；而 Android 系统基于 Linux ，使得其并发读取文件没有限制地进行，甚至允许两个线程同时对一个文件进行读写操作，尽管这样可能会出问题。
    2. 可以在一个进程中序列化一个对象到文件系统中，在另一个进程中反序列化恢复这个对象（注意：并不是同一个对象，只是内容相同。）。
    3. SharedPreferences 是个特例，系统对它的读 / 写有一定的缓存策略，即内存中会有一份 ShardPreferences 文件的缓存，系统对他的读 / 写就变得不可靠，当面对高并发的读写访问，SharedPreferences 有很多大的几率丢失数据。因此，IPC 不建议采用 SharedPreferences。
    • 服务端进程：服务端创建一个 Service 来处理客户端请求，同时通过一个 Handler 对象来实例化一个 Messenger 对象，然后在 Service 的 onBind 中返回这个 Messenger 对象底层的 Binder 即可。
    • 客户端进程：首先绑定服务端 Service ，绑定成功之后用服务端的 IBinder 对象创建一个 Messenger ，通过这个 Messenger 就可以向服务端发送消息了，消息类型是 Message 。如果需要服务端响应，则需要创建一个 Handler 并通过它来创建一个 Messenger（和服务端一样），并通过 Message 的 replyTo 参数传递给服务端。服务端通过 Message 的 replyTo 参数就可以回应客户端了。
    2.     private static final String TAG = MainActivity.class.getSimpleName();
    3.     private Messenger mGetReplyMessenger = new Messenger(new MessageHandler());
    4.     private Messenger mService;
    6.     private class MessageHandler extends Handler {
    7.         @Override
    8.         public void handleMessage(Message msg) {
    9.             switch (msg.what) {
    10.                 case Constants.MSG_FROM_SERVICE:
    11.                     Log.d(TAG, "received msg form service: msg = [" + msg.getData().getString(Constants.MSG_KEY) + "]");
    12.                     Toast.makeText(MainActivity.this, "received msg form service: msg = [" + msg.getData().getString(Constants.MSG_KEY) + "]", Toast.LENGTH_SHORT).show();
    13.                     break;
    14.                 default:
    15.                     super.handleMessage(msg);
    16.             }
    17.         }
    18.     }
    22.     @Override
    23.     protected void onCreate(Bundle savedInstanceState) {
    24.         super.onCreate(savedInstanceState);
    25.         setContentView(R.layout.activity_main);
    27.     }
    29.     public void bindService(View v) {
    30.         Intent mIntent = new Intent(this, MessengerService.class);
    31.         bindService(mIntent, mServiceConnection, Context.BIND_AUTO_CREATE);
    32.     }
    34.     public void sendMessage(View v) {
    35.         Message msg = Message.obtain(null,Constants.MSG_FROM_CLIENT);
    36.         Bundle data = new Bundle();
    37.         data.putString(Constants.MSG_KEY, "Hello! This is client.");
    38.         msg.setData(data);
    39.         msg.replyTo = mGetReplyMessenger;
    40.         try {
    41.             mService.send(msg);
    42.         } catch (RemoteException e) {
    43.             e.printStackTrace();
    44.         }
    46.     }
    48.     @Override
    49.     protected void onDestroy() {
    50.         unbindService(mServiceConnection);
    51.         super.onDestroy();
    52.     }
    54.     private ServiceConnection mServiceConnection = new ServiceConnection() {
    55.         /**
    56.          * @param name
    57.          * @param service
    58.          */
    59.         @Override
    60.         public void onServiceConnected(ComponentName name, IBinder service) {
    61.             mService = new Messenger(service);
    62.             Message msg = Message.obtain(null,Constants.MSG_FROM_CLIENT);
    63.             Bundle data = new Bundle();
    64.             data.putString(Constants.MSG_KEY, "Hello! This is client.");
    65.             msg.setData(data);
    66.             //
    67.             msg.replyTo = mGetReplyMessenger;
    68.             try {
    69.                 mService.send(msg);
    70.             } catch (RemoteException e) {
    71.                 e.printStackTrace();
    72.             }
    74.         }
    76.         /**
    77.          * @param name
    78.          */
    79.         @Override
    80.         public void onServiceDisconnected(ComponentName name) {
    83.         }
    84.     };
    85. }

    注意：客户端和服务端是通过拿到对方的 Messenger 来发送 Message 的。只不过客户端通过 bindService onServiceConnected 而服务端通过 message.replyTo 来获得对方的 Messenger 。Messenger 中有一个 Hanlder 以串行的方式处理队列中的消息。不存在并发执行，因此我们不用考虑线程同步的问题。

    四、使用 AIDL

    Messenger 是以串行的方式处理客户端发来的消息，如果大量消息同时发送到服务端，服务端只能一个一个处理，所以大量并发请求就不适合用 Messenger ，而且 Messenger 只适合传递消息，不能跨进程调用服务端的方法。AIDL 可以解决并发和跨进程调用方法的问题，要知道 Messenger 本质上也是 AIDL ，只不过系统做了封装方便上层的调用而已。

    • 基本数据类型；
    • String 和 CharSequence
    • ArrayList ，里面的元素必须能够被 AIDL 支持；
    • HashMap ，里面的元素必须能够被 AIDL 支持；
    • Parcelable ，实现 Parcelable 接口的对象；
      注意：如果 AIDL 文件中用到了自定义的 Parcelable 对象，必须新建一个和它同名的 AIDL 文件。
    • AIDL ，AIDL 接口本身也可以在 AIDL 文件中使用。

    服务端创建一个 Service 用来监听客户端的连接请求，然后创建一个 AIDL 文件，将暴露给客户端的接口在这个 AIDL 文件中声明，最后在 Service 中实现这个 AIDL 接口即可。

    绑定服务端的 Service ，绑定成功后，将服务端返回的 Binder 对象转成 AIDL 接口所属的类型，然后就可以调用 AIDL 中的方法了。客户端调用远程服务的方法，被调用的方法运行在服务端的 Binder 线程池中，同时客户端的线程会被挂起，如果服务端方法执行比较耗时，就会导致客户端线程长时间阻塞，导致 ANR 。客户端的 onServiceConnected 和 onServiceDisconnected 方法都在 UI 线程中。

    • 使用 Permission 验证，在 manifest 中声明
    1. <permission android:name="com.jc.ipc.ACCESS_BOOK_SERVICE"
    2.     android:protectionLevel="normal"/>
    3. <uses-permission android:name="com.jc.ipc.ACCESS_BOOK_SERVICE"/>

    服务端 onBinder 方法中

    1. public IBinder onBind(Intent intent) {
    2.     //Permission 权限验证
    3.     int check = checkCallingOrSelfPermission("com.jc.ipc.ACCESS_BOOK_SERVICE");
    4.     if (check == PackageManager.PERMISSION_DENIED) {
    5.         return null;
    6.     }
    8.     return mBinder;
    9. }
    • Pid Uid 验证
    1. // IBookManager.aidl
    2. package com.jc.ipc.aidl;
    4. import com.jc.ipc.aidl.Book;
    5. import com.jc.ipc.aidl.INewBookArrivedListener;
    7. // AIDL 接口中只支持方法，不支持静态常量，区别于传统的接口
    8. interface IBookManager {
    9.     List<Book> getBookList();
    11.     // AIDL 中除了基本数据类型，其他数据类型必须标上方向,in,out 或者 inout
    12.     // in 表示输入型参数
    13.     // out 表示输出型参数
    14.     // inout 表示输入输出型参数
    16.     void addBook(in Book book);
    18.     void registerListener(INewBookArrivedListener listener);
    19.     void unregisterListener(INewBookArrivedListener listener);
    21. }
    1. // INewBookArrivedListener.aidl
    2. package com.jc.ipc.aidl;
    3. import com.jc.ipc.aidl.Book;
    5. // 提醒客户端新书到来
    7. interface INewBookArrivedListener {
    8.     void onNewBookArrived(in Book newBook);
    9. }
    1. public class BookManagerActivity extends AppCompatActivity {
    2.     private static final String TAG = BookManagerActivity.class.getSimpleName();
    3.     private static final int MSG_NEW_BOOK_ARRIVED = 0x10;
    4.     private Button getBookListBtn,addBookBtn;
    5.     private TextView displayTextView;
    6.     private IBookManager bookManager;
    7.     private Handler mHandler = new Handler(){
    8.         @Override
    9.         public void handleMessage(Message msg) {
    10.             switch (msg.what) {
    11.                 case MSG_NEW_BOOK_ARRIVED:
    12.                     Log.d(TAG, "handleMessage: new book arrived " + msg.obj);
    13.                     Toast.makeText(BookManagerActivity.this, "new book arrived " + msg.obj, Toast.LENGTH_SHORT).show();
    14.                     break;
    15.                 default:
    16.                     super.handleMessage(msg);
    17.             }
    19.         }
    20.     };
    22.     private ServiceConnection mServiceConn = new ServiceConnection() {
    23.         @Override
    24.         public void onServiceConnected(ComponentName name, IBinder service) {
    25.             bookManager = IBookManager.Stub.asInterface(service);
    26.             try {
    27.                 bookManager.registerListener(listener);
    28.             } catch (RemoteException e) {
    29.                 e.printStackTrace();
    30.             }
    32.         }
    34.         @Override
    35.         public void onServiceDisconnected(ComponentName name) {
    37.         }
    38.     };
    39.     private INewBookArrivedListener listener = new INewBookArrivedListener.Stub() {
    40.         @Override
    41.         public void onNewBookArrived(Book newBook) throws RemoteException {
    42.             mHandler.obtainMessage(MSG_NEW_BOOK_ARRIVED, newBook).sendToTarget();
    44.         }
    45.     };
    47.     @Override
    48.     protected void onCreate(@Nullable Bundle savedInstanceState) {
    49.         super.onCreate(savedInstanceState);
    50.         setContentView(R.layout.book_manager);
    51.         displayTextView = (TextView) findViewById(R.id.displayTextView);
    52.         Intent intent = new Intent(this, BookManagerService.class);
    55.     }
    58.     public void getBookList(View view) {
    59.         try {
    60.             List<Book> list = bookManager.getBookList();
    61.             Log.d(TAG, "getBookList: " + list.toString());
    62.             displayTextView.setText(list.toString());
    63.         } catch (RemoteException e) {
    64.             e.printStackTrace();
    65.         }
    67.     }
    69.     public void addBook(View view) {
    70.         try {
    71.             bookManager.addBook(new Book(3, "天龙八部"));
    72.         } catch (RemoteException e) {
    73.             e.printStackTrace();
    74.         }
    75.     }
    77.     @Override
    78.     protected void onDestroy() {
    79.         if (bookManager != null && bookManager.asBinder().isBinderAlive()) {
    80.             Log.d(TAG, "unregister listener " + listener);
    81.             try {
    82.                 bookManager.unregisterListener(listener);
    83.             } catch (RemoteException e) {
    84.                 e.printStackTrace();
    85.             }
    86.         }
    87.         unbindService(mServiceConn);
    88.         super.onDestroy();
    89.     }
    90. }

    用于不同应用间数据共享，和 Messenger 底层实现同样是 Binder 和 AIDL，系统做了封装，使用简单。
    系统预置了许多 ContentProvider ，如通讯录、日程表，需要跨进程访问。
    使用方法：继承 ContentProvider 类实现 6 个抽象方法，这六个方法均运行在 ContentProvider 进程中，除 onCreate 运行在主线程里，其他五个方法均由外界回调运行在 Binder 线程池中。

    ContentProvider 的底层数据，可以是 SQLite 数据库，可以是文件，也可以是内存中的数据。

    详见代码：

    1. public class BookProvider extends ContentProvider {
    2.     private static final String TAG = "BookProvider";
    3.     public static final String AUTHORITY = "com.jc.ipc.Book.Provider";
    5.     public static final Uri BOOK_CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/book");
    6.     public static final Uri USER_CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/user");
    8.     public static final int BOOK_URI_CODE = 0;
    9.     public static final int USER_URI_CODE = 1;
    10.     private static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
    12.     static {
    13.         sUriMatcher.addURI(AUTHORITY, "book", BOOK_URI_CODE);
    14.         sUriMatcher.addURI(AUTHORITY, "user", USER_URI_CODE);
    15.     }
    17.     private Context mContext;
    18.     private SQLiteDatabase mDB;
    20.     @Override
    21.     public boolean onCreate() {
    22.         mContext = getContext();
    23.         initProviderData();
    25.         return true;
    26.     }
    28.     private void initProviderData() {
    29.         //不建议在 UI 线程中执行耗时操作
    30.         mDB = new DBOpenHelper(mContext).getWritableDatabase();
    31.         mDB.execSQL("delete from " + DBOpenHelper.BOOK_TABLE_NAME);
    32.         mDB.execSQL("delete from " + DBOpenHelper.USER_TABLE_NAME);
    33.         mDB.execSQL("insert into book values(3,'Android');");
    34.         mDB.execSQL("insert into book values(4,'iOS');");
    35.         mDB.execSQL("insert into book values(5,'Html5');");
    36.         mDB.execSQL("insert into user values(1,'haohao',1);");
    37.         mDB.execSQL("insert into user values(2,'nannan',0);");
    39.     }
    41.     @Nullable
    42.     @Override
    43.     public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
    44.         Log.d(TAG, "query, current thread"+ Thread.currentThread());
    45.         String table = getTableName(uri);
    46.         if (table == null) {
    47.             throw new IllegalArgumentException("Unsupported URI" + uri);
    48.         }
    50.         return mDB.query(table, projection, selection, selectionArgs, null, null, sortOrder, null);
    51.     }
    53.     @Nullable
    54.     @Override
    55.     public String getType(Uri uri) {
    56.         Log.d(TAG, "getType");
    57.         return null;
    58.     }
    60.     @Nullable
    61.     @Override
    62.     public Uri insert(Uri uri, ContentValues values) {
    63.         Log.d(TAG, "insert");
    64.         String table = getTableName(uri);
    65.         if (table == null) {
    66.             throw new IllegalArgumentException("Unsupported URI" + uri);
    67.         }
    68.         mDB.insert(table, null, values);
    69.         // 通知外界 ContentProvider 中的数据发生变化
    70.         mContext.getContentResolver().notifyChange(uri, null);
    71.         return uri;
    72.     }
    74.     @Override
    75.     public int delete(Uri uri, String selection, String[] selectionArgs) {
    76.         Log.d(TAG, "delete");
    77.         String table = getTableName(uri);
    78.         if (table == null) {
    79.             throw new IllegalArgumentException("Unsupported URI" + uri);
    80.         }
    81.         int count = mDB.delete(table, selection, selectionArgs);
    82.         if (count > 0) {
    83.             mContext.getContentResolver().notifyChange(uri, null);
    84.         }
    86.         return count;
    87.     }
    89.     @Override
    90.     public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
    91.         Log.d(TAG, "update");
    92.         String table = getTableName(uri);
    93.         if (table == null) {
    94.             throw new IllegalArgumentException("Unsupported URI" + uri);
    95.         }
    96.         int row = mDB.update(table, values, selection, selectionArgs);
    97.         if (row > 0) {
    98.             getContext().getContentResolver().notifyChange(uri, null);
    99.         }
    100.         return row;
    101.     }
    103.     private String getTableName(Uri uri) {
    104.         String tableName = null;
    105.         switch (sUriMatcher.match(uri)) {
    106.             case BOOK_URI_CODE:
    107.                 tableName = DBOpenHelper.BOOK_TABLE_NAME;
    108.                 break;
    109.             case USER_URI_CODE:
    110.                 tableName = DBOpenHelper.USER_TABLE_NAME;
    111.                 break;
    112.             default:
    113.                 break;
    114.         }
    116.         return tableName;
    118.     }
    119. }
    1. public class DBOpenHelper extends SQLiteOpenHelper {
    3.     private static final String DB_NAME = "book_provider.db";
    4.     public static final String BOOK_TABLE_NAME = "book";
    5.     public static final String USER_TABLE_NAME = "user";
    7.     private static final int DB_VERSION = 1;
    9.     private String CREATE_BOOK_TABLE = "CREATE TABLE IF NOT EXISTS "
    10.             + BOOK_TABLE_NAME + "(_id INTEGER PRIMARY KEY," + "name TEXT)";
    12.     private String CREATE_USER_TABLE = "CREATE TABLE IF NOT EXISTS "
    13.             + USER_TABLE_NAME + "(_id INTEGER PRIMARY KEY," + "name TEXT,"
    14.             + "sex INT)";
    18.     public DBOpenHelper(Context context) {
    19.         super(context, DB_NAME, null, DB_VERSION);
    21.     @Override
    22.     public void onCreate(SQLiteDatabase db) {
    24.         db.execSQL(CREATE_USER_TABLE);
    26.     }
    28.     @Override
    29.     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    31.     }
    32. }
    1. public class ProviderActivity extends AppCompatActivity {
    2.     private static final String TAG = ProviderActivity.class.getSimpleName();
    3.     private TextView displayTextView;
    4.     private Handler mHandler;
    6.     @Override
    7.     protected void onCreate(@Nullable Bundle savedInstanceState) {
    8.         super.onCreate(savedInstanceState);
    9.         setContentView(R.layout.activity_provider);
    10.         displayTextView = (TextView) findViewById(R.id.displayTextView);
    11.         mHandler = new Handler();
    13.         getContentResolver().registerContentObserver(BookProvider.BOOK_CONTENT_URI, true, new ContentObserver(mHandler) {
    14.             @Override
    15.             public boolean deliverSelfNotifications() {
    16.                 return super.deliverSelfNotifications();
    17.             }
    19.             @Override
    20.             public void onChange(boolean selfChange) {
    21.                 super.onChange(selfChange);
    22.             }
    24.             @Override
    25.             public void onChange(boolean selfChange, Uri uri) {
    26.                 Toast.makeText(ProviderActivity.this, uri.toString(), Toast.LENGTH_SHORT).show();
    27.                 super.onChange(selfChange, uri);
    28.             }
    29.         });
    34.     }
    36.     public void insert(View v) {
    37.         ContentValues values = new ContentValues();
    38.         values.put("_id",1123);
    39.         values.put("name", "三国演义");
    40.         getContentResolver().insert(BookProvider.BOOK_CONTENT_URI, values);
    42.     }
    43.     public void delete(View v) {
    44.         getContentResolver().delete(BookProvider.BOOK_CONTENT_URI, "_id = 4", null);
    47.     }
    48.     public void update(View v) {
    49.         ContentValues values = new ContentValues();
    50.         values.put("_id",1123);
    51.         values.put("name", "三国演义新版");
    52.         getContentResolver().update(BookProvider.BOOK_CONTENT_URI, values , "_id = 1123", null);
    55.     }
    56.     public void query(View v) {
    57.         Cursor bookCursor = getContentResolver().query(BookProvider.BOOK_CONTENT_URI, new String[]{"_id", "name"}, null, null, null);
    58.         StringBuilder sb = new StringBuilder();
    59.         while (bookCursor.moveToNext()) {
    60.             Book book = new Book(bookCursor.getInt(0),bookCursor.getString(1));
    61.             sb.append(book.toString()).append("\n");
    62.         }
    63.         sb.append("--------------------------------").append("\n");
    64.         bookCursor.close();
    66.         Cursor userCursor = getContentResolver().query(BookProvider.USER_CONTENT_URI, new String[]{"_id", "name", "sex"}, null, null, null);
    67.         while (userCursor.moveToNext()) {
    68.             sb.append(userCursor.getInt(0))
    69.                     .append(userCursor.getString(1)).append(" ,")
    70.                     .append(userCursor.getInt(2)).append(" ,")
    71.                     .append("\n");
    72.         }
    73.         sb.append("--------------------------------");
    74.         userCursor.close();
    75.         displayTextView.setText(sb.toString());
    76.     }
    77. }

    六、使用 Socket

    Socket 本身可以传输任意字节流。

    • 应用层：规定应用程序的数据格式，主要的协议 HTTP，FTP，WebSocket，POP3 等；
    • 传输层：建立“端口到端口” 的通信，主要的协议：TCP，UDP；
    • 网络层：建立”主机到主机”的通信，主要的协议：IP，ARP ，IP 协议的主要作用：一个是为每一台计算机分配 IP 地址，另一个是确定哪些地址在同一子网；
    • 数据链路层：确定电信号的分组方式，主要的协议：以太网协议；
    • 物理层：负责电信号的传输。

    Socket 是连接应用层与传输层之间接口（API）。

    只实现 TCP Socket 。

    Client 端代码：

    Server 端代码：

    1. public class TCPServerService extends Service {
    2.     private static final String TAG = "TCPServerService";
    3.     private boolean isServiceDestroyed = false;
    4.     private String[] mMessages = new String[]{
    5.             "Hello! Body!",
    6.             "用户不在线！请稍后再联系！",
    7.             "请问你叫什么名字呀？",
    8.             "厉害了，我的哥！",
    9.             "Google 不需要科学上网是真的吗？",
    10.             "扎心了，老铁！！！"
    11.     };
    14.     @Override
    15.     public void onCreate() {
    16.         new Thread(new TCPServer()).start();
    17.         super.onCreate();
    18.     }
    20.     @Override
    21.     public void onDestroy() {
    22.         isServiceDestroyed = true;
    23.         super.onDestroy();
    24.     }
    26.     @Nullable
    27.     @Override
    28.     public IBinder onBind(Intent intent) {
    29.         return null;
    30.     }
    32.     private class TCPServer implements Runnable {
    34.         @Override
    35.         public void run() {
    36.             ServerSocket serverSocket = null;
    37.             try {
    38.                 serverSocket = new ServerSocket(8888);
    39.             } catch (IOException e) {
    40.                 e.printStackTrace();
    41.                 return;
    42.             }
    43.             while (!isServiceDestroyed) {
    44.                 // receive request from client
    45.                 try {
    46.                     final Socket client = serverSocket.accept();
    47.                     Log.d(TAG, "=============== accept ==================");
    48.                     new Thread(){
    49.                         @Override
    50.                         public void run() {
    51.                             try {
    52.                                 responseClient(client);
    53.                             } catch (IOException e) {
    54.                                 e.printStackTrace();
    55.                             }
    56.                         }
    57.                     }.start();
    58.                 } catch (IOException e) {
    59.                     e.printStackTrace();
    60.                 }
    61.             }
    63.         }
    64.     }
    67.     private void responseClient(Socket client) throws IOException {
    68.         //receive message
    69.         BufferedReader in = new BufferedReader(
    70.                 new InputStreamReader(client.getInputStream()));
    71.         //send message
    72.         PrintWriter out = new PrintWriter(
    73.                 new BufferedWriter(
    74.                         new OutputStreamWriter(
    75.                                 client.getOutputStream())),true);
    76.         out.println("欢迎来到聊天室！");
    78.         while (!isServiceDestroyed) {
    79.             String str = in.readLine();
    80.             Log.d(TAG, "message from client: " + str);
    81.             if (str == null) {
    82.                 return;
    83.             }
    84.             Random random = new Random();
    85.             int index = random.nextInt(mMessages.length);
    86.             String msg = mMessages[index];
    87.             out.println(msg);
    88.             Log.d(TAG, "send Message: " + msg);
    89.         }
    90.         out.close();
    91.         in.close();
    92.         client.close();
    95. }

    演示：

    UDP Socket 可以自己尝试着实现。