IPC进程间通信

IPC机制

1. 为何要开启多进程

为何开启android应用要开启多进程，主要有以下几点：
(1)单进程所分配的内存不够，需要更多的内存。在早期android系统只为一个单进程的应用分配了16M的可用内存，随着手机的硬件的提升和android系统的改进，虽然可分配内存越来越多，但仍旧可以通过开启多进程来获取更多的内存来处理自己App的业务
(2)独立运行的组件，比如个推，它的服务会另开一个进程。
(3)运行一些”不可见人”的操作，比如获取用户的隐私数据，比如双守护进程来防止被用户杀掉

2. 开启多进程

android:process=":remote" //进程名
用adb命令可以查看进程信息 adb shell ps

用Messenger进行进程间通信 :

Messenger可以在不同进程中传递Message对象，我们在Message中加入我们想要传的数据就可以在进程间的进行数据传递了。
服务端：

public class MyService extends Service {
   public MyService() {
   }

   @Override
   public IBinder onBind(Intent intent) {
       Log.d("TAG", "onBind: ");
       // TODO: Return the communication channel to the service.
       //Messenger创建一个IBinder，服务端通过onBind()方法使其返回客户端
       return new Messenger(handler).getBinder();
   }

   @Override
   public void onCreate() {
       super.onCreate();
       Log.d("TAG", "onCreate: ");
   }

   private Handler handler = new Handler(){
       @Override
       public void handleMessage(@NonNull Message msg) {
           super.handleMessage(msg);
           switch (msg.what){
               //1 客户端传来的消息
               case 1:
                   //接收到客户端的消息
                   Log.d("TAG", "我是服务端，收到你的消息: "+msg.getData().get("lala"));
                   //返回给客户端的消息
                   Message msgToClient = Message.obtain(null,2);
                   //得到客户端传来的Messenger对象
                   Messenger clientMessenger = msg.replyTo;
                   try {
                       clientMessenger.send(msgToClient);
                   } catch (RemoteException e) {
                       e.printStackTrace();
                   }
                   break;
           }
       }
   };
}

AndroidMainfest.xml

 <service
            android:name=".MyService"
            android:enabled="true"
            android:exported="true">
            <intent-filter>
                <action android:name="haha"/>
            </intent-filter>
</service>

客户端

public class MainActivity extends AppCompatActivity {
   private Messenger mMessenger;
   
   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
       //绑定服务
       Intent intent = new Intent("haha");
       intent.setPackage("com.thundersoft.ipcdemo");
       bindService(intent,conn,BIND_AUTO_CREATE);
   }
   private ServiceConnection conn = new ServiceConnection() {
       @Override
       public void onServiceConnected(ComponentName name, IBinder service) {
           Log.d("TAG", "已经绑定服务: ");
           //客户端使用IBinder将Messenger（引用服务的Handler）实例化，
           mMessenger = new Messenger(service);
           Message message = Message.obtain(null,1);
           Bundle bundle = new Bundle();
           bundle.putString("lala","你好，我是客户端，请问你收到信息了吗？");
           message.setData(bundle);
           //将Messenger传递给服务端
           message.replyTo=new Messenger(mHandler);
           try {
               mMessenger.send(message);
           } catch (RemoteException e) {
               e.printStackTrace();
           }
       }

       @Override
       public void onServiceDisconnected(ComponentName name) {

       }
   };
   private Handler mHandler = new Handler(){
       @Override
       public void handleMessage(@NonNull Message msg) {
           super.handleMessage(msg);
           switch (msg.what){
               case 2:
                   Log.d("TAG", "服务端返回的消息: ");
                   break;
           }

       }
   };
}

注意：在客户端的AndroidMainfest.xml中导入服务的包 ：

 <queries>
        <package android:name="com.thundersoft.ipcdemo"/>
    </queries>

总结：
（1） <服务端>Messenger创建一个IBinder，服务端通过onBind()方法使其返回客户端
（2）<客户端>客户端使用IBinder将Messenger（引用服务的Handler）实例化，然后使用后者将Message对象发送给服务端。

（3）服务端收到了客户端的消息，服务端回应客户端。
首先在handleMessage回调中收到客户端信息时，我们调用Message.replyTo得到客户端传过来的Messenger对象，创建消息并通过Messenger发送给客户端。

: 是通过各自的messenger来进行通信的，所以思想是想法获得对方的messenger

通过Binder的onTransact完成跨进程通信

我们 android studio 新建两个工程（两个 moudle 也可以，这里目的为创建两个运行在不同进程的app），一个Server，一个Client，而后，在Server中，创建类继承android.os.Binder，重写方法onTransact(int code, Parcel data, Parcel reply, int flags),注意这四个参数;
(1) code：方法标识符，因为Client端对Server端的所有调用都会走到Server端的这个方法，所以理所应当Client端应该传递一个参数过来用以表示要调用哪个方法,注意这个int类型的标识必须介于 FIRST_CALL_TRANSACTION 和 LAST_CALL_TRANSACTION之间，所以我们给方法分配code的时候最好使用FIRST_CALL_TRANSACTION+n 这种方式
(2)data ：Client传递过来的序列化数据包，Parcel类型
(3)reply： 如果Client端调用时需要返回值，Server通过这个对象将返回值传递回去，同样Parcel类型
(4)flag 用来区分这个调用是普通调用还是单边调用，普通调用时，Client端线程会阻塞，直到从Server端接收到返回值（所以如果Client端是主线程调用，其调用的Server端不宜做耗时操作，这会让造成Client的ANR），若flag==IBinder.FLAG_ONEWAY，则这次调用是单边调用，Client在传出数据后会立即执行下一段代码，此时两端异步执行，单边调用时函数返回值必须为void （也就是异步调用必须舍弃返回值，要返回值就必须阻塞等待）

那我们先来看一下Parcel 的用法 ：
（1）Parcel的获取： Parcel parcle = Parcel.Obtain(); <Parcel的初始化也是由其对象池进行初始化的，Parcel是一个容器>
（2）向Parcel中传入一个Int型的数据 ：parcel.writeString(String val);
（3）在完成了数据的写入之后，就需要进行数据的序列化：parcel.marshall();
（4）在经过上一步的处理之后，返回了一个byte数组，主要的IPC相关的操作主要就是围绕此byte数组进行的。
（5）parcel的销毁 ：parcel.recycle();
（6）再进行了IPC的操作之后，一般读取出来的就是之前序列化的byte数组，所以，首先要进行一个反序列化操作，即如下的操作:
parcel.unmarshall(byte[] data, int offest, int length); 其中的参数分别是这个byte数组，以及读取偏移量，以及数组的长度。
（7）parcel.readInt();
（8）parcel.recycle();
详细请参考
链接: https://blog.csdn.net/rainbowchou/article/details/54294394?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163288163116780261933448%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=163288163116780261933448&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_allsobaiduend~default-2-54294394.first_rank_v2_pc_rank_v29&utm_term=Parcel&spm=1018.2226.3001.4187
Service :

public class Stub extends android.os.Binder {
    //用于标识调用的Binder
    private static final java.lang.String DESCRIPTOR = "MyBinder";
    //方法标识，这里我们准备两个方法，一个无参，一个有参
    private static final int TRANSACTION_method0 = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    private static final int TRANSACTION_method1 = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
    //服务端的data 是读，reply是写
    @Override
    public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
        switch (code) {
            case TRANSACTION_method0: {
                //Store or read an IBinder interface token
                //验证Binder标识
                data.enforceInterface(DESCRIPTOR);
                //调用实现方法
                this.method0();
                reply.writeNoException();
                return true;
            }
            case TRANSACTION_method1: {
                data.enforceInterface(DESCRIPTOR);
                int _arg0;
                //按写入的顺序读取数据
                _arg0 = data.readInt();           
                int _arg1;
                _arg1 = data.readInt();
                int _result = this.method1(_arg0, _arg1);
                reply.writeNoException();
                //向Client写回返回值
                reply.writeInt(_result);          
                return true;
            }
        }
        return super.onTransact(code, data, reply, flags);
    }
    //Server端真正实现业务的两个方法
    public void method0() throws RemoteException {
        Log.e("Server", Process.myPid() + "  " + Process.myTid() + "  " + Process.myUid() + "  " + "method0");
    }
    public int method1(int a, int b) throws RemoteException {
        Log.e("Server", Process.myPid() + "  " + Process.myTid() + "  " + Process.myUid() + "  " + "method1" + "  " + a + " " + b);
        return a + b;
    }
}

绑定服务否返回Binder对象： 通信的桥梁

    @Override
    public IBinder onBind(Intent intent) {
        return new Stub();
    }

client端 ：
（1）绑定服务

   //定义常量
   //注意两个工程中对应的标识符必须相同
   static final String DESCRIPTOR = "MyBinder";
   //方法标识
   static final int TRANSACTION_method0 = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
   static final int TRANSACTION_method1 = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
       Intent intent = new Intent();
       intent.setComponent(new ComponentName("com.xxx.server", "com.xxx.server.ServerService"));
       boolean b = bindService(intent, conn, BIND_AUTO_CREATE);
       Log.e("Client", "      "+b);
   }
    ```
  （2）bindService 的第二个参数，ServiceConnnection，在这个回调中我们取得IBinder对象，这个对象是Server端在Client中的一个代理对象
    ```
        ServiceConnection conn = new ServiceConnection() {
       @Override
       public void onServiceConnected(ComponentName name, IBinder iBinder) {
           //这个IBinder对象iBinder，可以调用c++层Binder代理并最终通过Binder驱动传递数据
           Parcel _data0 = Parcel.obtain();//申请传递参数的Parcel对象（从Parcel池中取出）
           Parcel _reply0 = Parcel.obtain();//申请接收返回值的Parcel对象，相当于数据载体
           Parcel _data1 = Parcel.obtain();
           Parcel _reply1 = Parcel.obtain();
           try {
               //调用第一个方法
               //写入Binder标识，以便服务端验证
               _data0.writeInterfaceToken(DESCRIPTOR);
               //传入方法标识，以便服务端知道我们要调用哪个方法，注意最后一个参数，就是上面提到的                  //flag，如果我们传入IBinder.FLAG_ONEWAY，则这次调用为单边调用，这个方法会立即返                //回，不会等服务端方法返回
               iBinder.transact(TRANSACTION_method0, _data0, _reply0, 0);
               _reply0.readException();
               //调用第二个方法
               _data1.writeInterfaceToken(DESCRIPTOR);
               //按顺序写入参数
               _data1.writeInt(1);
               _data1.writeInt(2);
               //从下面这行代码开始本线程会阻塞，直到服务端进程中调用的方法完成计算返回后这个线程继                 //续运行，计算的返回值放入_reply1中
               iBinder.transact(TRANSACTION_method1, _data1, _reply1, 0);
               _reply1.readException();
               int i = _reply1.readInt();//从reply中读取返回值，这里我们就得到了服务端计算后的结果
           } catch (RemoteException e) {
               e.printStackTrace();
           } finally {
               //回收Parcel
               _data0.recycle();
               _reply0.recycle();
               _data1.recycle();
               _reply1.recycle();
           }
           Log.e("Client", Process.myPid() + "  " + Process.myTid() + "  " + Process.myUid() + "  " + "method0");
       }
       @Override
       public void onServiceDisconnected(ComponentName name) {
       }
   };