Android进程间通信——Messenger

Messenger，通过它可以在不同进程间传递Message对象，Messenger的底层实现也是AIDL，我们可以从它的构造方法中看出

public Messenger(Handler target){
    mTarget = target.getIMessenger();
}

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

Messenger的使用方法很简单，它对AIDL做了封装，使得我们可以更便捷的进行进程间通信。同时，由于它一次处理一个请求，因此在服务端我们不用考虑线程同步的问题，这是因为服务端中不存在并发执行的情形。实现一个Messenger有如下几个步骤：

服务端：

           1.服务端创建一个Service来处理客户端的连接请求

           2.创建一个Handler并通过它来创建一个Messenger对象

           3.在Service的onBinder中返回这个Messenger对象底层的Binder

客户端：

           1.绑定服务端的Service

           2.绑定成功后用服务端返回的IBinder对象创建一个Messenger

           3.通过Messenger向服务端发Message对象

           4.如果需要服务端能够回应客户端，客户端再创建一个Handler并创建一个新的Messenger，并把这个Messenger对象通过Message的replyTo参数传递给服务端，服务端通过这个replyTo参数就可以回应客户端

服务端代码实现

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

    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(@NonNull Message msg) {
            switch (msg.what) {
                case MessengerConst.MSG_FROM_CLIENT:
                    Log.e(TAG, "receive msg from client:" + msg.getData().getString("msg"));
                    //拿到客户端的Messenger，并通过客户端的Messenger給客户端发消息
                    Messenger client = msg.replyTo;
                    Message replyMessage = Message.obtain(null,MessengerConst.MSG_FROM_SERVICE);
                    Bundle bundle = new Bundle();
                    bundle.putString("reply","嗯，收到消息，稍后回复");
                    replyMessage.setData(bundle);
                    try {
                        client.send(replyMessage);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    super.handleMessage(msg);
                    break;
            }

        }
    }

    private final Messenger mMessenger = new Messenger(new MessengerHandler());


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


}

服务端的MessengerHandler是用来处理客户端发来的消息的，并从消息中取出客户端发来的文本信息。通过msg.replyTo拿到客户端的Messenger，再向客户端发消息。

客户端代码实现

首先绑定服务端MessengerService，绑定成功后，根据服务端返回的binder对象创建Messenger对象并使用Messenger对象向服务器发送消息。

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    private Messenger mService;
    private Messenger client = new Messenger(new MessengerHandler());

    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            mService = new Messenger(iBinder);
            Message msg = Message.obtain(null, MessengerConst.MSG_FROM_CLIENT);
            Bundle data = new Bundle();
            data.putString("msg", "Hello, this is client");
            msg.setData(data);
            msg.replyTo = client;
            try {
                mService.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {

        }
    };

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

        Intent intent = new Intent(this, MessengerService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

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

    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(@NonNull Message msg) {
            switch (msg.what) {
                case MessengerConst.MSG_FROM_SERVICE:
                    Log.e(TAG, "receive msg from service:" + msg.getData().getString("reply"));
                    break;
                default:
                    super.handleMessage(msg);
                    break;
            }
        }
    }
}

通过这个例子我们可以看到，其实，Messenger的主要功能就是，收到Message消息后，将消息传递给Handler处理。