移步Android跨进程通信IPC

简介

1. Binder运行在服务端进程，如果服务端由于某种原因异常终止，这时候服务端和客户端之间的Binder连接会断裂也就是Binder死亡。这个时候如果再做远程调用就会失败，进而会导致客户端的功能异常。我们可以给Binder设置一个死亡代理，当Binder死亡时我们会收到通知回调，在回调内我们可以做重连操作以便恢复连接。
2. 服务端直接调用客户端内方法获取数据，以便客户端和服务端双向交互。
3. 做一个观察者模式，可以在服务端数据发生数据变化时及时通知客户端。

1. 设置死亡代理

主要有两个操作步骤，一是声明死亡代理，并在Binder的死亡回调中做重连等相关操作；二是设置死亡代理。

1.1 声明死亡代理

    //实例化死亡代理接口，并实现死亡回调的接口
    IBinder.DeathRecipient mDeathRecipient = new IBinder.DeathRecipient() {
         //死亡回调的接口
        @Override
        public void binderDied() {
            if (mRemoteService == null){
                return;
            }
            //解绑死亡代理
            mRemoteService.asBinder().unlinkToDeath(mDeathRecipient,0);
            mRemoteService = null;
            // TODO: 做重新绑定service服务，或者其他的操作
            ...
        }
    };

TODO部分自行做操作，可以做和服务端的重连操作也可以做其他操作

1.2 设置死亡代理

    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder serverBinder) {
            mRemoteService = IService.Stub.asInterface(serverBinder);
            try {
                //给binder设置死亡代理
                serverBinder.linkToDeath(mDeathRecipient,0);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {

        }
    };

上面部分的主要代码前文中已经做过解读，此处不再赘述。里面有一个额外的方法调用就是serverBinder.linkToDeath()，这个方法就是给Binder设置死亡代理，当Binder异常死亡时就会调用mDeathRecipient内的binderDied方法做死亡通知。

2. 设置客户端和服务端双向交互

做双向交互要做的核心就是客户端也要创建一个Binder对象并将Binder对象交付给服务端。其中观察者模式使用的核心也是如此。

2.1 客户端内创建Binder对象

创建回调使用的aidl

package com.wuyazhou.learn.IPC.aidl;
import com.wuyazhou.learn.IPC.aidl.Book;
interface ICallback {
    void callback(in Book newBook);
}

客户端内创建Binder对象

    private ICallback mCallback = new ICallback.Stub() {
        @Override
        public void callback(Book newBook) throws RemoteException {
            Log.d("wuyazhouAIDL","回调："+newBook.bookName);
        }
    };

这里的Binder对象mCallback运行在客户端

2.2 将客户端内创建的Binder对象交付给服务端

    mRemoteService.useCallback(mCallback);

2.3 服务端调用客户端接口

    private final IService.Stub mBinder = new IService.Stub() {
        ...
        @Override
        public void useCallback(ICallback callback) throws RemoteException {
            callback.callback(new Book(456,"Android进阶"));
        }
    };

这里可能会疑惑为什么ICallback可以直接调用callback接口，并且能调用到客户端内实现的ICallback.aidl内的接口。
因为上一步我们通过Binder的传递机制将Binder对象ICallback传递给了服务端，所以服务端持有ICallback的Binder。

3. 观察者模式

观察者模式和上面的双向交互几乎一致，只是向多个客户端分发和解绑操作，所以这里要有一个存储向客户端回调的接口的容器。因为客户端将aidl的接口传递给Server时Server端会重新生成一个全新的对象，也就是说解绑时我们传递要解绑的aidl接口也会生成一个全新的对象，这两次生成的全新对象肯定是不一样的对象，所以普通的容器不能满足对aidl接口的对应增删。
RemoteCallbackList是系统专门提供的用于删除跨进程listener的接口。它的内部有一个Map用来专门存储AIDL回调。其中key是IBinder类型，value是Callback类型。

3.1 创建监听使用的aidl

package com.wuyazhou.learn.IPC.aidl;
import com.wuyazhou.learn.IPC.aidl.Book;
interface IOnNewBookArrivedListener {
    void onNewBookArrived(in Book newBook);
}

3.2 服务端接收和移除监听

    private final IService.Stub mBinder = new IService.Stub() {
        /** 添加监听*/
        @Override
        public void registerListener(IOnNewBookArrivedListener listener) {
            mRemoteCallbackList.register(listener);

            final int N = mRemoteCallbackList.beginBroadcast();
            mRemoteCallbackList.finishBroadcast();
        }

        /** 移除监听*/
        @Override
        public void unRegisterListener(IOnNewBookArrivedListener listener) {
            mRemoteCallbackList.unregister(listener);

            final int N = mRemoteCallbackList.beginBroadcast();
            mRemoteCallbackList.finishBroadcast();
        }
    };

3.3 客户端实现监听

    private IOnNewBookArrivedListener mOnNewBookArrivedListener = new IOnNewBookArrivedListener.Stub() {
        @Override
        public void onNewBookArrived(Book newBook) throws RemoteException {
            Log.d("wuyazhouAIDL","有新书到了");
        }
    };

3.4 客户端绑定监听

         mRemoteService.registerListener(mOnNewBookArrivedListener);

3.5 服务端分发监听

    private void onNewBookArrived(Book book) throws RemoteException {
        final int N = mRemoteCallbackList.beginBroadcast();
        for (int i = 0; i < N; i++) {
            IOnNewBookArrivedListener l = mRemoteCallbackList.getBroadcastItem(i);
            if (l != null) {
                try {
                    l.onNewBookArrived(book);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }
        mRemoteCallbackList.finishBroadcast();
    }

    onNewBookArrived(new Book(123,"艺术探索"));