Android之使用Messenger进行IPC

看下官网对Messenger（信使）的介绍：

主要告诉我们可以参考Handler对message的使用一样，通过Messenger对Message的使用，达到进程间通讯的效果。

为了方便我们在一个工程里通过将Service设置为不同的进程，来进行IPC。
服务端的代码如下：

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 MSG_FROM_CLIENT:
                    Log.i(TAG , "receive msg from client:" + msg.getData().getString("msg"));
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

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

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

然后在Manifest里声明该Service，并指定为另外一个进程：

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

接着是Actvity里的代码：

public class MessengerActivity extends AppCompatActivity {

    private static final String TAG = "MessengerActivity";
    private Messenger mService;

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

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_messenger);
        Intent intent = new Intent(this, MessengerService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

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

大概的流程是这样的：
1.首先我们创建了一个服务MessengerService，用于处理接收客户端发来的信息。在当我们新创建这个Service的时候，它只有一个onBind的方法，该方法需要我们返回一个IBinder，而在这里我们通过Messenger的getBinder方法可以将其返回，以供到时客户端去调用。
2.我们在MessengerService里创建了一个Handler与Messenger关联，是为了处理客户端到时传过来的Message。
3.在客户端里我们通过bindService与MessengerService建立联系，一旦联系建立了，就会调用ServiceConnection里的方法，我们可以看到onServiceConnected的参数里有一个IBinder，那么这个就是我们在MessengerService的onBind方法里返回的。
4.此时我们根据服务端的这个IBinder对象来创建一个Messenger对象，然后携带Message进行发送，这样服务端那边也就会接收到客户端发来的消息了。

---

那么上面是客户端发送消息给服务端，现在服务端接收到消息里，需要给客户端进行回复，
在原来服务端的handleMessage里的接收到客户端的消息后，添加回应。

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 MSG_FROM_CLIENT:
                    Log.i(TAG , "receive msg from client:" + msg.getData().getString("msg"));
                    //回复客户端
                    Messenger client = msg.replyTo;
                    Message replyMessage = Message.obtain(null , MSG_FROM_SERVICE);
                    Bundle bundle = new Bundle();
                    bundle.putString("reply" , "Well , I will reply you later");
                    replyMessage.setData(bundle);
                    try {
                        client.send(replyMessage);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }

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

        }
    }

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

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

从msg.replyTo里获取到客户端传来的Messenger。
那么客户端要做如下修改：

public class MessengerActivity extends AppCompatActivity {

    private static final String TAG = "MessengerActivity";
    private Messenger mService;

    private Messenger mGetReplyMessenger = new Messenger(new MessengerHandler());
    //与在服务端的写法一样，都是为了处理信息
    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case Constant.MSG_FROM_SERVICE:
                    Log.i(TAG, "receive msg from Service:" + msg.getData().getString("reply"));
                    break;
                default:
                    super.handleMessage(msg);
            }

        }
    }


    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mService = new Messenger(service);
            Message message = Message.obtain(null, Constant.MSG_FROM_CLIENT);
            Bundle data = new Bundle();
            data.putString("msg", "hello , this is client.");
            message.setData(data);
            //在原来的Message里添加Messenger，用于给服务端指定回复
            message.replyTo = mGetReplyMessenger;
            try {
                mService.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_messenger);
        Intent intent = new Intent(this, MessengerService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

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