Android进程间通信之Messenger

关于Messenger的官方描述是：允许实现基于消息的进程间通信的方式。

可以看到，

1.客户端发送一个msg给服务端

2.服务端的handler将接收到的msg处理

3.将处理结果封装成msg发送给客户端

4.客户端的handler处理接收到msg

Messenger的源码实现是基于AIDL的。

例子：一个apk是服务端，接收客户端发来的消息，求和后发送给客户端；一个apk是客户端，发送两个随机数给服务端。

服务端：

public class MessengerService extends Service {

    private Messenger mMessenger;
    private static final int MSG_SUM = 0;
    private Looper mThreadLooper;

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

    @Override
    public void onCreate() {
        super.onCreate();
        // 用HandlerThread可以处理耗时操作
        HandlerThread handlerThread = new HandlerThread("msg-server-thread");
        handlerThread.start();

        mThreadLooper = handlerThread.getLooper();
        Handler handler = new Handler(mThreadLooper) {
            @Override
            public void handleMessage(Message msgFromClient) {
                // 返回给客户端的消息
                Message msgFromServer = Message.obtain(msgFromClient);
                switch (msgFromClient.what) {
                case MSG_SUM:
                    // 模拟耗时操作
                    SystemClock.sleep(5 * 1000);
                    msgFromServer.what = MSG_SUM;
                    // 下面这句可以不写，因为msgFromServer是通过msgFromClient拷贝得到的
                    msgFromServer.arg1 = msgFromClient.arg1;
                    msgFromServer.arg2 = msgFromClient.arg1
                            + msgFromClient.arg2;
                    try {
                        // 用客户端的Messenger发送消息，这样客户端Messenger的Handler可以处理消息
                        msgFromClient.replyTo.send(msgFromServer);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                }
                super.handleMessage(msgFromClient);
            }
        };
        mMessenger = new Messenger(handler);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        mThreadLooper.quit();
    }

}

注册服务：

<service
    android:name=".MessengerService"
    android:exported="true" >
    <intent-filter>
        <action android:name="com.example.messengerdemoservice.MessengerService" />
    </intent-filter>
</service>

客户端代码：

public class MainActivity extends Activity {

    private LinearLayout mLinearLayout;
    private Messenger mService;
    private int mA;
    private static final int MSG_SUM = 0;

    private Messenger mMessenger = new Messenger(new Handler() {
        public void handleMessage(Message msgFromServer) {
            switch (msgFromServer.what) {
            case MSG_SUM:
                TextView tv = (TextView) mLinearLayout
                        .findViewById(msgFromServer.arg1);
                tv.setText(tv.getText() + " = " + msgFromServer.arg2);
                break;
            }
            super.handleMessage(msgFromServer);
        };
    });

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mLinearLayout = (LinearLayout) findViewById(R.id.linearLayout);
        Button button = (Button) findViewById(R.id.btn);

        bindRemoteService();

        button.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                int a = mA++;
                int b = (int) (Math.random() * 100);

                // 新建一个TextView并添加到LinearLayout中
                TextView tv = new TextView(MainActivity.this);
                tv.setText(a + " + " + b + " = ...");
                tv.setId(a);
                mLinearLayout.addView(tv);

                Message msgFromClient = Message.obtain(null, MSG_SUM, a, b);
                // 把客户端的Messenger赋值给msgFromClient.replyTo，以便服务端获取该Messenger
                msgFromClient.replyTo = mMessenger;
                if (mService != null) {
                    try {
                        // 用服务端的Messenger发送消息，这样服务端Messenger的Handler可以处理消息
                        mService.send(msgFromClient);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
    }

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

    private void bindRemoteService() {
        Intent service = new Intent(
                "com.example.messengerdemoservice.MessengerService");
        bindService(service, mConn, Context.BIND_AUTO_CREATE);
    }

    private ServiceConnection mConn = new ServiceConnection() {

        @Override
        public void onServiceDisconnected(ComponentName name) {
            mService = null;
        }

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mService = new Messenger(service);
        }
    };

}