Android开发IPC之Messenger

写在前面

Messenger翻译为信使，通过它在进程间传递message对象，然后把我们需要传递的数据封装进message，就可以实现数据在不同进程间的传递。Messenger是一种轻量级的IPC方案，它的底层实现是AIDL。

构造方法

 /**
    * Create a new Messenger pointing to the given Handler.  Any Message
    * objects sent through this Messenger will appear in the Handler as if
    * {@link Handler#sendMessage(Message) Handler.sendMessage(Message)} had
    * been called directly.
    * 
    * @param target The Handler that will receive sent messages.
    */
   public Messenger(Handler target) {
       mTarget = target.getIMessenger();
   }

/**
    * Create a Messenger from a raw IBinder, which had previously been
    * retrieved with {@link #getBinder}.
    * 
    * @param target The IBinder this Messenger should communicate with.
    */
   public Messenger(IBinder target) {
       mTarget = IMessenger.Stub.asInterface(target);
   }

从构造方法的实现上可以明显的看出AIDL的痕迹，不管是IMessenger还是Stub.asInterface，这种使用方法都表明它的底层是AIDL。

通过构造你会发现mTarget（IMessenger）和IBinder存在转化关系，即IMessenger.Stub已经帮我们实现了这种转化方法 asInterface（），IBinder－》mTarget；asBinder（），mTarget－》IBinder。
所以结论是：IBinder可以关联到一个Handler，通过一个Messenger的getBinder()获取的IBinder可以创建一个关联相同Handler的Messenger。

使用

Messenger的使用方法很简单，因为它对AIDL做了封装，同时，由于它一次处理一个请求，因此在服务端我们不用考虑线程同步问题，因为服务端不存在并发执行的情形。

服务端进程

首先，我们需要在服务端创建一个Service来处理客户端的连接请求，同时创建一个Handler并通过它创建一个Messenger对象，然后在onBind中将Messenger底层的Binder返回。而在接收到客户端的消息后，从Message对象中取出replyTo参数对应的Messenger对象（客户端发消息的时候，将客户端的Messenger对象通过Message对象中replyTo参数传递过来），通过这个Messenger就可以给客户端发送消息了。

客户端进程

首先，我们要在客户端进程中绑定服务端的Service，绑定成功后用服务端返回的IBinder对象创建一个Messenger，通过这个Messenger就可以给服务端发送消息了，而且消息类型为Message对象。然后，客户端创建一个Handler并通过它创建一个Messenger对象，并且把这个Messenger对象通过Message对象的replyTo参数传递给服务端，服务端取出replyTo对象的Messenger对象就可以给客户端发送消息了。具体看代码：

首先是服务端代码，messenger对象是和MessengerHandler相关联的，并且在onBind方法中返回了messenger中的Binder对象，所以messenger的作用是将客户端发送的消息传递给MessengerHandler去处理。

public class MessengerService extends Service {
    private static class MessengerHandler extends Handler {
        private String TAG = "MessengerService";

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case Constants.MSG_FROM_CLIENT:
                    Log.i(TAG, "receive message from client:" + msg.getData().getString("msg"));
                    Messenger client = msg.replyTo;
                    Message replyMessage = Message.obtain(null, Constants.MSG_FROM_SERVICE);
                    Bundle bundle = new Bundle();
                    bundle.putString("reply", "嗯，你的消息我已经收到，稍后会回复你。");
                    replyMessage.setData(bundle);
                    try {
                        client.send(replyMessage);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

    private final Messenger messenger = new Messenger(new MessengerHandler());

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return messenger.getBinder();
    }
}

然后注册Service，使其运行在单独进程中。

<service android:name=".messenger.MessengerService"
            android:process=":remote"/>

客户端实现：

public class MessengerActivity extends AppCompatActivity {
    private static String TAG = "MessengerActivity";

    private Messenger mService;
    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mService = new Messenger(service);
            Message message = Message.obtain(null, Constants.MSG_FROM_CLIENT);
            Bundle bundle = new Bundle();
            bundle.putString("msg", "hello，this is client");
            message.setData(bundle);
            message.replyTo = mGetMessenger;
            try {
                mService.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    private Messenger mGetMessenger = new Messenger(new MessengerHandler());

    private static class MessengerHandler extends Handler {

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case Constants.MSG_FROM_SERVICE:
                    Log.i(TAG, "receive message from service:" + msg.getData().getString("reply"));
                    break;
                default:
                    super.handleMessage(msg);
            }
        }

    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_messenger);

        Intent intent = new Intent(MessengerActivity.this, MessengerService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onDestroy() {
        unbindService(mConnection);
        super.onDestroy();
    }
}

原理图

通过这张原理图能够帮助更好的理解，首先Client绑定Service，服务端在onBind方法中返回Messenger（通过构造方法关联了Handler）中的Binder对象，然后客户端在onServiceConnected函数中能够得到服务端返回的Binder对象，通过这个Binder对象可以创建一个关联与服务端进程中相同的Handler的Messenger对象（在客户端进程中发送消息其实最终是调用了服务端的Handler的sendMessage方法）。然后通过Message的replyTo参数将客户端的Messenger对象传递给服务端，当服务端收到消息后（客户端通过关联了服务端的Handler的Messenger对象发送的消息），取出Message中的replyTo对应的Messenger对象（客户端的Messenger对象）。最后通过这个Messenger对象发送消息给客户端。

总结

通过亲自动手实现以后，感觉理解起来还是蛮清晰的，除了客户端通过

 public Messenger(IBinder target) {
        mTarget = IMessenger.Stub.asInterface(target);
    }

这个构造得到关联服务端的Handler对象不好理解，其他应该是比较好理解的。举个例子可能会更好理解一点：首先是进程A拿到进程B中的Messenger对象，然后调用它的send方法，而这个方法会调用进程B中的Messenger对象关联的Handler的sendMessage方法，最后进程B中的Handler收到消息并处理。

到这里通过Messenger在进程间通信就介绍完了，本人也是通过查看Android开发艺术探索一书学习，自己实现一下，加深一点理解，非常感谢任玉刚老师出的此书。