Android IPC机制（二）Messenger实现IPC

Messenger

Messenger的底层是通过AIDL实现的，我们可以通过他的构造函数了解，如下

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

具体的代码实现 

服务端

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 Constants.MSG_FROM_CLIENT:
                    //接收客户端的消息
                    Log.e(TAG,"收到客户端消息："+msg.getData().get("msg"));

                    //获取客户端的messenger，并向客户端发送消息
                    Messenger client=msg.replyTo;
                    Message message=Message.obtain(null,Constants.MSG_FROM_SERVICE);
                    Bundle data=new Bundle();
                    data.putString("msg","我是服务端");
                    message.setData(data);
                    try {
                        client.send(message);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;

                default:
                    super.handleMessage(msg);

            }

        }
    }

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

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

    }
}

客户端

public class MessengerActivity extends AppCompatActivity {
    private static final String TAG="MessengerActivity";
    private EditText mEditText;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_messenger);
        mEditText=findViewById(R.id.edt_id);
        Intent intent=new Intent(this,MessengerService.class);
        bindService(intent, mServiceConnection,Context.BIND_AUTO_CREATE);

    }

    /**
     * 客户端Messenger
     */
    private final Messenger mGetResult =new Messenger(new Handler(){
        @Override
        public void handleMessage(Message msg) {

            switch (msg.what) {
                case Constants.MSG_FROM_SERVICE:

                    Log.e(TAG,"从服务端发来的消息："+msg.getData().get("msg"));

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

        }
    });
    private Messenger mService ;//服务端的Messenger
    private ServiceConnection mServiceConnection=new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mService=new Messenger(service);//通过代理的方式获取服务端的Messenger
            Message message=Message.obtain(null, Constants.MSG_FROM_CLIENT);
            Bundle bundle=new Bundle();
            bundle.putString("msg",mEditText.getText().toString().trim());
            message.setData(bundle);
            message.replyTo=mGetResult;
            try {
                mService.send(message);//向服务端发送消息
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };


    /**
     * 向服务端发送消息
     * @param view
     */
    public void sendMsg(View view) {
        Message message=Message.obtain(null, Constants.MSG_FROM_CLIENT);
        Bundle bundle=new Bundle();
        bundle.putString("msg",mEditText.getText().toString().trim());
        message.setData(bundle);
        message.replyTo=mGetResult;
        try {
            mService.send(message);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void onDestroy() {
        unbindService(mServiceConnection);//activity销毁解除绑定
        super.onDestroy();
    }
}

在Manifest中做配置，实现多进程的场景

不过需要注意的是在进程间通信时，Messenger是通过Message来传递的，而message能够使用的包括what，arg1, 
arg2,Bundle以及replyTo,而object也只有实现了Parcelable的系统对象可以进行传递。