Android中跨进程通信方式之使用Messenger

服务端MessengerService的process属性指定它的进程跟MainActivity不在一个进程

        <service
            android:name="com.example.activity.MessengerService"
            android:process="com.example.activity.remote" >
        </service>

在MessengerService创建一个Messenger，以它底层的binder作为绑定服务返回的IBinder对象。

    private final Messenger messenger = new Messenger(new messengerHandler());
    @Override
    public IBinder onBind(Intent intent) {
        return messenger.getBinder();
    }

messengerHandler用于处理客户端向服务端通过Messenger发的Message。

private class messengerHandler extends Handler{

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            System.out.println(msg.getData().getString("msg"));
        }

    }

客户端MainActivity中绑定服务。

                Intent intent = new Intent();
                intent.setClass(MainActivity.this, MessengerService.class);
                bindService(intent, conn, Context.BIND_AUTO_CREATE);

绑定服务需要ServiceConnection，以绑定Service返回的IBinder对象创建Messenger ，将客户端要发送的信息发个服务端。

private ServiceConnection conn = new ServiceConnection() {

        @Override
        public void onServiceDisconnected(ComponentName name) {
        }

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            Messenger messenger = new Messenger(service);
            Message msg = Message.obtain();
            Bundle data = new Bundle();
            data.putString("msg", "hello!!!");
            msg.setData(data);
            try {
                messenger.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    };

此时，服务端便可通过messengerHandler接受到客户端发送的消息，至此完成进程间的通信。
当然，服务端也可以回复消息给客户端。
可在客户端也创建一个Messenger，通过hanlder来处理服务端发送的消息。

private Messenger mainMessenger = new Messenger(new MessengerHandler());
private class MessengerHandler extends Handler{

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            System.out.println(msg.getData().getString("reply"));
        }

    }

当然需要把客户端的mainMessenger 传递给服务端，服务端通过mainMessenger 发送消息给客户端。这里使用Message的replyTo属性传递。

msg.replyTo = mainMessenger;

那么服务端便可通过客户端传递过来的Messenger给客户端返回消息了。

            Messenger client = msg.replyTo;
            Bundle bundle = new Bundle();
            Message reply = Message.obtain();
            bundle.putString("reply", "hello yeah!");
            reply.setData(bundle);
            try {
                client.send(reply);
            } catch (RemoteException e) {
                e.printStackTrace();
            }

这时客户端便可通过mainMessenger获取服务端发回的消息。

使用Messenger通信不能很好的处理高并发，因为它的消息是一条一条处理的。它通过Message传输消息，所以只支持Bundle数据类型。在低并发的即时通信中，可以使用这种方式。