【Android学习笔记】Android进程间通信方式Messenger

一、什么是Messenger

如果你的服务需要与其他进程进行IPC，那么除了AIDL的方式外，有一种更为简单的方式，那就是采用基于Message的Messenger方式。当你需要进行IPC时，使用 Messenger 要比用AIDL实现接口要容易些，因为 Messenger 会把所有调用服务的请求放入一个队列。而纯粹的AIDL接口会把这些请求同时发送给服务，这样服务就必须要能够多线程运行。

具体的处理过程如下：

1. 服务实现一个Handler ，用于客户端每次调用时接收回调。
2. 此Handler用于创建一个Messenger对象（它是一个对Handler的引用)。
3. 此Messenger对象创建一个IBinder，服务在onBind()中把它返回给客户端。
4. 客户端用IBinder将Messenger（引用服务的Handler）实例化，客户端用它向服务发送消息对象Message。
5. 服务接收Handler中的每个消息Message——确切的说，是在handleMessage()方法中接收。

整个通信的过程可以使双向的，但两边的逻辑并不一样，client端需要有两个messenger，其一用来sendMessage到server，另一个用来处理server返回的message。而server端则是利用message对象，并设置msgfromClient.replyTo.send(msgToClient);来实现，但是client端是利用msgFromClient.replyTo = mMessenger;来实现的对接。

Message可以看成是通信的载体。

二、案例分析

public class MessengerService extends Service {
    /** Command to the service to display a message */
    static final int MSG_SAY_HELLO = 1;

    /**
     * Handler of incoming messages from clients.
     */
    class IncomingHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_SAY_HELLO:
                    Toast.makeText(getApplicationContext(), "hello!", Toast.LENGTH_SHORT).show();
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

    /**
     * Target we publish for clients to send messages to IncomingHandler.
     */
    final Messenger mMessenger = new Messenger(new IncomingHandler());

    /**
     * When binding to the service, we return an interface to our messenger
     * for sending messages to the service.
     */
    @Override
    public IBinder onBind(Intent intent) {
        Toast.makeText(getApplicationContext(), "binding", Toast.LENGTH_SHORT).show();
        return mMessenger.getBinder();
    }
}

public class ActivityMessenger extends Activity {
    /** Messenger for communicating with the service. */
    Messenger mService = null;

    /** Flag indicating whether we have called bind on the service. */
    boolean mBound;

    /**
     * Class for interacting with the main interface of the service.
     */
    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {
            // This is called when the connection with the service has been
            // established, giving us the object we can use to
            // interact with the service.  We are communicating with the
            // service using a Messenger, so here we get a client-side
            // representation of that from the raw IBinder object.
            mService = new Messenger(service);
            mBound = true;
        }

        public void onServiceDisconnected(ComponentName className) {
            // This is called when the connection with the service has been
            // unexpectedly disconnected -- that is, its process crashed.
            mService = null;
            mBound = false;
        }
    };

    public void sayHello(View v) {
        if (!mBound) return;
        // Create and send a message to the service, using a supported 'what' value
        Message msg = Message.obtain(null, MessengerService.MSG_SAY_HELLO, 0, 0);
        try {
            mService.send(msg);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

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

    @Override
    protected void onStart() {
        super.onStart();
        // Bind to the service
        bindService(new Intent(this, MessengerService.class), mConnection,
            Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        // Unbind from the service
        if (mBound) {
            unbindService(mConnection);
            mBound = false;
        }
    }
}

更多可以点击鸿洋大神

三、其他

参考文献：官方文档