Messenger使用介绍

背景

Messenger 是安卓实现跨进程通信方式之一，它是基于 message 消息机制的。本质上来讲，它是基于 aidl 机制，只是 Messenger 已经将它封装好，我们使用的时候不必再去写 aidl 文件。然而，Messenger 跨进程通信方式不支持多线程，它一次只处理一个请求，因此在服务端不用考虑线程同步问题，在服务端不存在并发执行的情况。

如何使用这种方式呢？在服务端 service 中定义一个 Handler，用于处理客户端发过来的消息。Messenger 共享 Binder 对象给 Client，Client 通过 Binder 对象向 Service 发送 Message, Service 定义的 Handler 用于处理这个消息。

下面是实现客户端与服务端相互通信的架构图：

它的使用方法很简单，只需要两个步骤，分为服务端和客户端。

服务端进程

创建一个 Service 用于处理客户端的请求，创建一个 Messenger 对象并绑定一个 Handler, 用于处理客户端发过来的消息。在 Service 的 onBind 方法返回这个 Messenger 的 Binder 对象。

package com.seaicelin.myapplication;

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.util.Log;

public class MyService extends Service {

    private static final String TAG = "MyService";

    private static class MessengerHandler extends Handler{

        @Override
        public void handleMessage(Message msg){
            switch (msg.what){
                case MyConstants.MSG_FROM_CLIENT:  //接受来自客户端的消息
                    Log.d(TAG, "receive msg from client:" + msg.getData().getString("msg"));
                    Messenger client = msg.replyTo;
                    Message replyMsg = Message.obtain(null, MyConstants.MSG_FROM_SERVER);
                    Bundle bundle = new Bundle();
                    bundle.putString("reply", "I server have receive your msg");
                    replyMsg.setData(bundle);
                    try {
                        client.send(replyMsg);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    super.handleMessage(msg);
            }

        }

    }

    //创建 Messenger，并绑定对应 Handler, 用于处理 Client 发过来的消息
    private final Messenger mMessenger = new Messenger(new MessengerHandler());

    public MyService() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        return mMessenger.getBinder(); //返回 Binder 对象给 Client
    }
}

客户端进程

绑定服务端的 Service，绑定成功后用服务端返回的 IBinder 创建一个 Messenger, 通过它向服务端发送消息。假如，客户端也需要能够处理服务端返回来的消息，那么，客户端同样需要创建一个 Handler 和创建一个 Messenger, 并把它传给服务端。这样，服务端才能够把消息发回给客户端。

package com.seaicelin.myapplication;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
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.util.Log;

public class MainActivity extends Activity {

    private static final String TAG = "MainActivity";

    private Messenger mService;

    //创建 Messenger 对象，并绑定 Handler
    private Messenger mGetReplyMessenger = new Messenger(new MessengerHandler());

    private static class MessengerHandler extends Handler{

        @Override
        public void handleMessage(Message msg){

            switch (msg.what){
                case MyConstants.MSG_FROM_SERVER: //接受来自 客户端 的消息
                    Log.d(TAG, "receive msg from server: " + msg.getData().get("reply"));
                    break;

                default:
                    super.handleMessage(msg);
            }
        }
    }

    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder binder) {
            mService = new Messenger(binder); // 创建 Messenger, 通过它向服务端发送消息
            Message msg = Message.obtain(null, MyConstants.MSG_FROM_CLIENT);
            Bundle data = new Bundle();
            data.putString("msg", "hello, this is client");
            msg.setData(data);
            msg.replyTo = mGetReplyMessenger; //将客户端的 Messenger 传给 服务端
            try {
                mService.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };


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

        //绑定服务端的 Service, 成功后用返回的 IBinder 对象创建 Messenger
        Intent intent = new Intent(this, MyService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

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

}

通过设置属性 android:process，把MainActivity 和 MyService 放在不同的进程上。

<activity
    android:name=".MainActivity"
    android:process=":client">
    <intent-filter>
        <action android:name="android.intent.action.MAIN"/>
        <category android:name="android.intent.category.LAUNCHER"/>
    </intent-filter>
</activity>

<service
    android:name=".MyService"
    android:process=":server">
</service>

这样，就可以模拟跨进程通信了，如下 log 所示：

05-09 12:54:56.147 27588-27588/com.seaicelin.myapplication:server D/MyService: receive msg from client:hello, this is client

05-09 12:54:56.260 27566-27566/com.seaicelin.myapplication:client D/MainActivity: receive msg from server: I server have receive your msg

参考：
《Android开发艺术探索》

本文原创首发于微信公众号 [ 林里少年 ]，欢迎关注第一时间获取更新。