3.Android中的IPC方式---使用Messenger

Messenger可以翻译为信使，顾名思义，通过它可以在不同进程中传递Message对象，在Message中放入我们需要传递的数据，就可以轻松地实现数据的进程间传递了。Messenger是一种轻量级的IPC方案，它的底层是AIDL。下面是Messenger的两个构造方法，从构造方法的实现上我们可以明显看出AIDL的痕迹，不管是IMessenger还是Stub.asInterface，这种使用方法都表明它的底层是AIDL。

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

Messenger的使用方法很简单，它对AIDL做了封装，使得我们可以简便地进行进程间通信。同时，由于它一次处理一个请求，因此在服务端我们不用考虑线程同步的问题，这是因为服务端中不存在并发执行的情形。实现一个Messenger有如下几个步骤，分为服务端和客户端。
1.服务端进程
首先，我们需要在服务端创建一个Service来处理客户端的连接请求，同时创建一个Handler并通过它来创建一个Messenger对象，然后在Service的onBind中返回这个Messenger对象底层的Binder即可。
2.客户端进程
客户端进程中，首先要绑定服务端的Service，绑定成功后用服务端返回的IBinder对象创建一个Messenger，通过这个Messenger就可以向服务端发送消息了，发消息类型为Message对象。如果需要服务端能够回应客户端，就和服务端一样还需要创建一个Handler并创建一个新的Messenger，并把这个Messenger对象通过Message的replyTo参数传递给服务端，服务端通过这个replyTo参数就可以回应客户端。这看起来还是有点抽象，不过看了下面的两个例子，肯定就明白了。
例子1：服务端无法回应客户端
首先看服务端的代码，这是服务端的典型代码，可以看到MessengerHandler用来处理客户端发送的消息，并从中取出客户端发来的文本消息。而mMessenger是一个Messenger对象，它和MessengerHandler相关联，并在onBind方法中返回它里面的Binder对象，这里Messenger的作用是将客户端发送的消息传递黑MessengerHandler处理。

public class MessengerService extends Service{
    private static final String TAG = "MessengerService";
    private static class MessengerHandler extends Handler{
        @Override
        public void handleMessage(Message msg){
            switch(msg.what){
                case MyConstants.MSG_FROM_CLIENT:
                Log.i(TAG,"receive msg from Client :" + msg.getData().
                getString("msg"));
                break;
                default:
                super.handleMessage(msg);
            }
        }
    }
    private final Message mMessenger = new Message(new MessengerHandler());
    @Override
    public  IBinder onBind(Intent intent){
        return mMessenger.getBinder();
    }
}

然后注册service,让其运行在单独的进程中：

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

接下来看客户端的实现，客户端的实现也比较简单，首先需要绑定远程进程的MessengerService，绑定成功后，根据服务端返回的binder对象创建Messenger对象并使用此对象向服务端发送消息。下面的代码在Bundle中向服务端发送了一句话，在上面的服务端代码中会打印出这句话。

public class MessengerActivity extends Activity{
    private static final String TAG = "MessengerActivity";
    private Messenger mService;
    private ServiceConnection mConnection = new ServiceConnection(){
        public void onServiceConnected(ComponentName className,IBinder service){
            mService = new Messenger(service);
            Message msg = Message.obtain(null,MyConstants.MSG_FROM_CLIENT);
            Bundle data = new Bundle();
            data.putString("msg","hello , this is client");
            msg.setData(data);
            try{
                mService.send(msg);
            }catch(RemoteException e){
                e.printStackTrace();
            }
        }
        public void onServiceDisconnected(ComponentName className){
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState){
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_messenger);
        Intent intent = new Intent(this,MessengerService.class);
        bindeService(intent,mConnection,Context.BIND_AUTO_CREATE);
    }
    @Override
    protected void onDestroy(){
        unbindService(mConnection);
        super.onDestroy();
    }
}

运行程序，查看log，显然服务端成功收到了客户端发来的问候语：

通过上面的例子可以看出，在Messenger中进行数据传递必须将数据放入Message中，二Messenger和Message都实现了Parcelable接口，因此可以跨进程传输。简单来说，Message中所支持的数据类型就是Messenger所支持的传输类型。实际上，通过Messenger来传输Message，Message中能使用的载体只有what、arg1、arg2、Bundle以及replyTo、Bundle中可以支持大量的数据类型。
有时候我们还需要能回应客户端，稍微修改，每当客户端发来一条消息，服务端就会自动回复一条“嗯，你的消息我已经收到，稍后会回复你。”，这很类似邮箱的自动回复功能。
服务端只需要修改MessengerHandler，当收到消息后，会立即回复一条消息给客户端。

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

接着看客户端的修改，为了接受服务端的回复，客户端也需要准备一个接收消息的Messenger和Handler，如下所示：

private Messenger mGetReplyMessenger = new Messenger(new MessengerHandler());
private static class MessengerHandler extends Handler{
    @Override
    public void handleMesssage(Message msg){
        switch(msg.what){
            case MyConstants.MSG_FROM_SERVICE;
            Log.i(TAG,"recceive msg from Service:"+msg.getData()).
            getString("reply");
            break;
        default:
            super.handleMesssage(msg);
        }
    }
}

除了上述修改，当客户端发送消息的时候，需要把接收服务端回复的Messenger通过Message的replyTo参数传递给服务端，如下所示：

mService = new Messenger(service);
Messenger msg = Messenger.obtain(null,MyConstants.MSG_FROM_CLIENt)；
Bundle data = new Bundle();
data.putString("msg","hello,this is client");
msg.setData(data);
//注意下面这句
msg.replyTo = mGetReplyMessenger;
try{
    mService.send(msg);
}catch(RemoteException e){
    e.printStackTrace();
}

运行程序，看一下log：

到这里，我们已经把使用Messenger进行进程间通信的方法都介绍完了。下面给出一张Messenger的工作原理图以方便读者更好地理解Messenger：