进程间通信

A:作为服务端进程
B:作为客户端进程
问题场景:
服务端进程Crash了，而客户端进程想要调用服务端方法，这样就调用不到了。

DeathRecipient对象

此时我们可以给Binder设置一个DeathRecipient对象，当Binder意外挂了的时候，我们可以在DeathRecipient接口的回调方法中收到通知，并作出相应的操作，比如重连服务等等。

DeathRecipient的使用如下：

• 服务端进程发生了crash，客户端这个时候该怎么办？当然是想办法重新bind服务端了。
  客户端使用DeathRecipient对象，可以知道服务端binder何时死完。有两个重要的方法：

1. linkToDeath -> 设置死亡代理 DeathRecipient 对象；
2. unlinkToDeath -> Binder死亡的情况下，解除该代理。
3. 此外，Binder中的isBinderAlive也可以判断Binder是否死亡

声明DeathRecipient对象，实现其binderDied方法，
给Binder对象设置DeathRecipient对象。
当binder死亡时，会回调binderDied方法,在该回调重决定重新bind服务端,或者其他策略
在客户端LocalActivity中

	private IBinder.DeathRecipient mDeathRecipient = new IBinder.DeathRecipient() {
        @Override
        public void binderDied() {
            Log.i(tag, "binderDied");
        }
    };
    
	connection = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                Log.i(tag, "onServiceConnected");
                mMessageSender = MessageSender.Stub.asInterface(service);
                try {
                    mMessageSender.asBinder().linkToDeath(mDeathRecipient,0);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
 
            @Override
            public void onServiceDisconnected(ComponentName name) {
                Log.i(tag, "onServiceDisconnected");
            }
        };
	bindService(new Intent(this, RemoteService.class), connection, Context.BIND_AUTO_CREATE);

这样一旦服务端进程销毁了，就会回调binderDied方法，异常终止服务端进程
以上是客户端知道服务端异常终止

服务端监听客户端是否终止

方法是一样的,
客户端监听服务端:服务端会传过来一个binder对象,对binder对象 设置 DeathRecipient 回调.
反过来
服务端监听客户端:客户端将自己的binder对象传递给服务端, 服务端设置自己的DeathRecipient 回调
问题在于 客户端并没有这个binger,所以可以手动创建一个binger

1. 定义远程回调接口

interface MessageSender {
    void sendMessage(in MessageModel model);
    void setBinder(in IBinder client);
}

2. Activity中

private IBinder client = new Binder();
connection = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                Log.i(tag, "onServiceConnected");
                mMessageSender = MessageSender.Stub.asInterface(service);
                try {
                    mMessageSender.asBinder().linkToDeath(mDeathRecipient,0);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                 try {
                    mMessageSender.setBinder(client);//在此处将客户端的binder设置给服务端
                } catch (RemoteException e) {
                    e.printStackTrace();
                }

            }
 
            @Override
            public void onServiceDisconnected(ComponentName name) {
                Log.i(tag, "onServiceDisconnected");
            }
        };

3. 服务端中

private IBinder.DeathRecipient mServiceRecipient = new IBinder.DeathRecipient() {
        @Override
        public void binderDied() {
            Log.i(tag,"client is died");
        }
    };


public IBinder onBind(Intent intent) {
        Log.i(tag, "onBind");
        return new MessageSender.Stub() {
            @Override
            public void sendMessage(MessageModel model) throws RemoteException {
                System.out.println("from:" + model.getFrom() + ", to: " + model.getTo()
                        + ", content:" + model.getContent());
            }
            @Override
            public void setBinder(IBinder client) throws RemoteException {
                client.linkToDeath(mServiceRecipient ,0);//在此处接收客户端的binder,将自己的监听设置过去
            }
        };
    }

综上所述,就可以实现 客户端服务端,两个进程相互监听对方的死亡回调了

参考
耗时两年，Android多进程从头讲到尾（万字总结，建议收藏）

Android多进程全总结