Android---Messenger跨进程通信

Messenger可以翻译为信使，即可以通过它在不同进程中传递Message对象。Messenger是轻量级IPC方案，底层实现是AIDL。

服务端

在服务端创建一个Service来处理客户端的链接请求，同时创建一个Handler并通过它来创建一个Messenger对象。然后再Service的onBind中返回这个Messenger对象底层的Binder即可。

public class MyServiceTest 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 MyConstants.MSG__FROM_CLIENT:
                    //通过消息的标识（key）得到信息，然后打印日志
                    Log.e(TAG,"receive msge from Client:"+msg.getData().getString("msg"));


                    //回应客户端。
                    //得到回应对方的messenger
                    Messenger client = msg.replyTo;
                    Message replyMessage = Message.obtain(null, MyConstants.MSG_FROM_SERVICE);

                    Bundle data = new Bundle();
                    data.putString("msg_two","hello,this is service");
                    replyMessage.setData(data);

                    try {
                        client.send(replyMessage);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    super.handleMessage(msg);

            }
        }
    }

    //将客户端发来的消息传递给MessengerHandler处理
    private final Messenger mMessenger=new Messenger(new MessengerHandler());


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

使Service运行再单独的进程中

       <service
            android:name=".MyServiceTest"
            android:enabled="true"
            android:exported="true"
            android:process=":remote"></service>

客户端

首先要绑定服务端的Service，绑定成功后用服务端返回的IBinder对象创建一个Messenger，通过这个Messenger就可以向服务端发送消息了，发消息类型为Message对象。如果需要服务端能够回应客户端，就和服务端一样，我们还需要创建一个Handler并创建一个新的Messenger，并把这个Messenger对象通过Message的replyTo参数传递给服务端，服务端通过这个replyTo参数就可以回应客户端。

public class MainActivity extends AppCompatActivity {

    private static final String TAG="MessengerActivity";

    private Messenger mService;

    private Intent intent;

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


    }

    public void one(View view){
        intent=new Intent(this,MyServiceTest.class);
        bindService(intent,mConnection, Context.BIND_AUTO_CREATE);
    }


    public void two(View view){
        unbindService(mConnection);
    }

    private ServiceConnection mConnection=new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            mService=new Messenger(iBinder);
            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 = mMessenger;

            try {
                mService.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName componenName) {
            Log.e(TAG,"onServiceDisconnected");
        }
    };

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

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

MyConstants

public class MyConstants {

    public final static int MSG__FROM_CLIENT=0x123;
    public final static int MSG_FROM_SERVICE=0x456;
}