Android进程通信之Messenger小试

趁热再打一块儿铁--Messenger。

Messenger作为Android中的一种跨进程传递消息的机制存在。这里记录一下简单的使用。总体思想是拿到哪个进程的Messenger，就可以向那个进程传递消息。

第一步：如果我们要向服务端传递消息，那么就要在服务端创建Messenger，然后将其Binder在onBind方法中返回，以便Client部分可以通过这个binder创建一个服务端的Messenger。如下：

public class MessengerService extends Service {
    private static final String TAG = "MessengerService";
    Messenger clientMessenger;

    private class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 10011:     //接收到Activity传递过来的消息
                    String str = msg.getData().getString("data");
                    Log.i(TAG,str);
                    //获取客户端传递过来的Messenger
                    clientMessenger = msg.replyTo;
                    Message message = Message.obtain();
                    message.what = 10010;
                    try {
                        clientMessenger.send(message);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    super.handleMessage(msg);
                    break;
            }
        }
    }

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


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

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

我们使用一个Handler对象作为Messenger的构造参数，这个Handler就是来处理消息的。

在onBind方法中，通过Messenger.getBinder的方式获取了一个Messenger的Binder返回

第二步：在Activity部分，绑定服务，获取binder，用这个binder创建服务端的Messenger对象，使用这个对象就可以向服务端发送Message了，服务端可以在Messenger关联的Handler中处理消息

//Messenger绑定
        connectionMsg = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                messenger = new Messenger(service); //获取服务端的Messenger，可以使用这个Messenger向服务端发送消息
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {
                messenger = null;
            }
        };
        Intent msgIntent = new Intent(this, MessengerService.class);
        bindService(msgIntent, connectionMsg, BIND_AUTO_CREATE);
        btn_msg.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Message message = Message.obtain(null, Constant.CLIENT_MSG);
                Bundle data = new Bundle();
                data.putString("data", "from client");
                message.setData(data);
                message.replyTo = clientMessenger;      //将自己的Messenger通过message传递到服务端
                try {
                    messenger.send(message);            //通过Messenger发送message
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        });

这样，我们就实现了客户端通过获取服务端Messenger向服务端传递消息。

同样的，如果我们希望服务端可以向客户端传递消息，可以在服务端创建一个Messenger，然后通过赋值给message.replyTo的方式把自己的Messenger带给服务端。服务端通过message.replayTo获取到客户端的Messenger，就可以向客户端传递消息了。如上面的代码所示。省略的部分是在客户端创建Messenger

private class ClientHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 10010:
                    Toast.makeText(MainActivity.this, "From Service", Toast.LENGTH_SHORT).show();
                    break;
                default:
                    break;
            }
        }
    }

    private Messenger clientMessenger = new Messenger(new ClientHandler());

这样，我们就简单完成了整个流程

参考《Android开发艺术探索》和https://blog.csdn.net/u011240877/article/details/72836178这篇大牛的博文，他们都提到Messenger是封装了AIDL的实现的。且博文里有所分析。我这里没有进行深入的分析了

至此，我们发现Binder机制的都是拿到另一个进程的Binder对象，从而再获取另一个进程的对象，实现跨进程通信的。