Messenger 进程间通信

Messenger

　　使用 Messenger 可以在进程间传递数据, 实现一对多的处理. 其内部实现, 也是基于 aidl 文件, 这个aidl位于: frameworks/base/core/java/android/os/IMessenger.aidl.
　　服务端与客户端通信, 主要是在传输的消息上做了处理, 让 Message.replyTo 指向的客户端的 Messenger, 而 Messenger 又持有客户端的一个 Binder 对象, 服务端正是利用这个 Binder 对象与客户端的通信.

1.服务端实现

　　实现一个 Service 类, 定义处理消息的 Messenger 对象, 在 OnBind 时使用 Messenger 对象的 getBinder() 方法返回 Binder 对象.
　　创建 Messenger 对象时, 使用一个 Handler 对象构造, 此 Handler 用于处理客户端发来的消息.
　　如果服务端需要向客户端返回数据, 在 Message 对象中取出客户端的 Messenger 对象(Message 对象的 replyTo 参数), 向其发送消息即可.

    public class MyService extends Service {

        protected static final String TAG = "debug";
        
        private Messenger mMessenger = new Messenger(new MessengerHandler());

        @Override
        public IBinder onBind(Intent intent) {
            return mMessenger.getBinder();
        }
        
        private static class MessengerHandler extends Handler {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                case MsgConstants.MESSGE_FROM_CLIENT:
                    Log.d(TAG, "service get message");
                    Bundle data = msg.getData();
                    String msgContent = data.getString("msg"); 
                    Log.d(TAG, "" + msgContent);
                    
                    // 回复客户端
                    Messenger client = msg.replyTo;
                    Bundle replyData = new Bundle();
                    replyData.putString("reply", "你的消息<" + msgContent +">,我已收到");
                    Message replyMsg = Message.obtain();
                    replyMsg.what = MsgConstants.MESSGE_FROM_SERVICE;
                    replyMsg.setData(replyData);
                    try {
                        client.send(replyMsg);
                    } catch (RemoteException e) {
                        Log.e(TAG, "", e);
                    }
                    break;
                default:
                    super.handleMessage(msg);
                    break;
                }
            }
        }
    }

    // AndoidManifest.xml 中注册服务
    <service
        android:name="com.example.MyService"
        android:exported="true"
        android:process=":remote" >
        <intent-filter>
            <action android:name="com.example.MyService" />
        </intent-filter>
    </service>

2.客户端实现

　　首先需要 bindService, 成功时在 ServiceConnection 的 onServiceConnected() 方法中, 将传入 IBinder 对象构造一个 Messenger 对象, 此 Messager 对象用于向服务端发送消息.
　　如果需要处理服务端返回的数据, 则还需要创建另外一个 Messenger 对象. 在向服务端发送数据时, 将 Message 对象的 replyTo 设置为该 Messenger 对象.

    // 连接 Service
    Intent service = new Intent("com.example.MyService");
    service.setComponent(new ComponentName("com.example", "com.example.MyService"));
    bindService(service, mConnection, Service.BIND_AUTO_CREATE);
        
    private Messenger mService;
    private Messenger mMessenger = new Messenger(new MessengerHandler());
    
    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            Log.d(TAG, "client get message");
            switch (msg.what) {
            case MsgConstants.MESSGE_FROM_SERVICE:
                Bundle data = msg.getData();
                Log.d(TAG, "" + data.getString("reply"));
                break;
            default:
                super.handleMessage(msg);
                break;
            }
        }
    }
    
    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceDisconnected(ComponentName name) {
        }
        
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mService = new Messenger(service);
        }
    };

    // 向服务端发送数据
    try {
        Message msg = Message.obtain();
        msg.what = MsgConstants.MESSGE_FROM_CLIENT;
        Bundle data = new Bundle();
        data.putString("msg", "kkkk");
        msg.setData(data);
        
        // 设置服务端回复的Messenger
        msg.replyTo = mMessenger;
        
        mService.send(msg);
    } catch (RemoteException e) {
        Log.e(TAG, "", e);
    }