进程间通信（三）----messenger

参考：https://developer.android.google.cn/guide/components/bound-services.html

Messenger是基于AIDL实现的进程间通信机制，它会维护一个队列来对消息进行处理，适用于一次处理一个请求的情形

使用 Messenger

与 AIDL 比较

当您需要执行 IPC 时，为您的接口使用 Messenger 要比使用 AIDL 实现它更加简单，因为 Messenger 会将所有服务调用排入队列，而纯粹的 AIDL 接口会同时向服务发送多个请求，服务随后必须应对多线程处理。

对于大多数应用，服务不需要执行多线程处理，因此使用 Messenger 可让服务一次处理一个调用。如果您的服务必须执行多线程处理，则应使用 AIDL 来定义接口。

如需让服务与远程进程通信，则可使用 Messenger 为您的服务提供接口。利用此方法，您无需使用 AIDL 便可执行进程间通信 (IPC)。

以下是 Messenger 的使用方法摘要：

服务实现一个 Handler，由其接收来自客户端的每个调用的回调

Handler 用于创建 Messenger 对象（对 Handler 的引用）

Messenger 创建一个 IBinder，服务通过 onBind() 使其返回客户端

客户端使用 IBinder 将 Messenger（引用服务的 Handler）实例化，然后使用后者将 Message 对象发送给服务

服务在其 Handler 中（具体地讲，是在 handleMessage() 方法中）接收每个 Message。

这样，客户端并没有调用服务的“方法”。而客户端传递的“消息”（Message 对象）是服务在其 Handler 中接收的。

看下面的列子，利用messenger实现了服务端与客户端通信互相传递数据的过程

服务端创建service，并实现Handler——>创建一个Messenger——>获取IBinder实例通过onBind返回给客户端代码：

package com.xx.serverapplication;

import android.app.Service;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.support.annotation.Nullable;
import android.util.Log;

public class MessengerService extends Service {
    private static final int MSG_SAY_HELLO = 1;
    Messenger mMessenger;

    @Override
    public void onCreate() {
        super.onCreate();
        mMessenger = new Messenger(new ServiceHandler());
    }

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

    private static class ServiceHandler extends Handler{
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case MSG_SAY_HELLO:
                    sayHello(msg);
                    break;
                default:
                    super.handleMessage(msg);
                    break;
            }

        }
    }

    private static void sayHello(Message msg){
        Bundle bundle = msg.getData();
        if(null != bundle) {
            Log.e("sayHello", "收到来自客户端的消息： " + bundle.getString("msg"));
        }
        //获取客户端的messenger
        Messenger clientMessenger = msg.replyTo;
        Bundle toClientBundle = new Bundle();
        toClientBundle.putString("msg", "客户端你好，我是服务端！");
        Message toClient = Message.obtain();
        toClient.setData(toClientBundle);
        try {
            clientMessenger.send(toClient);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
}

接下来在客户端实现一个ServiceConnection，在OnServerConnected（）中通过服务端传来的 IBinder service 得到serverMessenger，通过这个serverMessenger就可以给服务端发送消息了。  客户端实现了clientMessenger，并通过Message的replyTo返回给服务端，服务端通过这个clientMessenger来和客户端通信，他们之间的值传递是通过Message的Bundle来传递的。

private static final int MSG_TO_SERVER = 1;
    private static final int MSG_FROM_SERVER = 2;
    //服务端messenger
    Messenger serverMessenger;
    //客户端 messenger
    Messenger clientMessenger;
    private static class ClientHandler extends Handler{
        @Override
        public void handleMessage(Message msg) {
            switch(msg.what){
                case MSG_FROM_SERVER:
                    Bundle bundle = msg.getData();
                    if(null != bundle){
                        Log.e("messenger client", "收到服务端的信息：" + bundle.getString("msg"));
                    }
                    break;
                default:
                    break;
            }
            super.handleMessage(msg);
        }
    }

    private void testMessenger(){

       serviceConnection = new ServiceConnection() {
           @Override
           public void onServiceConnected(ComponentName name, IBinder service) {
               //通过服务端传过来的IBinder创建服务端messenger
               serverMessenger = new Messenger(service);
               //利用客户端Handler实例化客户端messenger
               clientMessenger = new Messenger(new ClientHandler());
               isBind = true;
               helloMessenger();
           }

           @Override
           public void onServiceDisconnected(ComponentName name) {
               isBind = false;
           }
       };
       Intent intent = new Intent();
       intent.setAction("com.aidl.service.messenger");
       intent.setPackage("com.xx.serverapplication");
       bindService(intent,serviceConnection, BIND_AUTO_CREATE);

    }

    private void helloMessenger(){
        Message message = Message.obtain(null, MSG_TO_SERVER);
        //通过Bundle传数据给服务端，并将clientMessenger传递给服务端
        Bundle bundle = new Bundle();
        bundle.putString("msg", "服务端你好，我是客户端！");
        message.setData(bundle);
        message.replyTo = clientMessenger;
        try {
            serverMessenger.send(message);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

结果为：