IPC機制之Messenger

寫在前面：

本文摘自《Android開發藝術探索》

什麼是Messenger?

Messenger譯爲“信使”，通過它可以在不同進程中傳遞Message對象。Messenger是一種輕量級的IPC方案，底層是實現AIDL，因其對AIDL進行了封裝，所以其使用方法簡單，我們可以更簡便地進行進程間通信。同時，由於Messenger一次處理一個請求，因此在服務器端我們不用考慮線程同步的問題，因爲服務器中不存在併發執行的情形。

Messenger的兩個構造方法：

/**
* Create a new Messenger pointing to the given Handler.  Any Message
* objects sent through this Messenger will appear in the Handler as if
* {@link Handler#sendMessage(Message) Handler.sendMessage(Message)} had
* been called directly.
* 
* @param target The Handler that will receive sent messages.
*/
public Messenger(Handler target) {
    mTarget = target.getIMessenger();
}

筆者查看的是Android API Platform 23源碼文檔，在該版本文檔中未找到此第二種構造方法。

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

如何實現Messenger?

Messenger的實現分爲服務器和客戶端兩個步驟；

1. 服務端進程

首先，我們需要在服務端創建一個Service來處理客戶端的連接請求，同時創建一個Handler並通過它來創建一個Messenger對象，然後在Service的onBind中返回這個Messenger對象底層的Binder即可。

2. 客戶端進程

首先要綁定服務端的Service，綁定成功後用服務端返回的IBinder對象創建一個Messenger，通過這個Messenger就可以向服務端發送消息了，發消息類型爲Message對象。如果需要服務端能夠迴應客戶端，就和服務端一樣，我們還要創建一個Handler並創建一個新的Messenger，並把這個Messenger對象通過Message的replyTo參數傳遞給服務端，服務端通過這個replyTo參數就可以迴應客戶端。

實例：服務端接收客戶端中發送的消息

服務端代碼：

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 MyConstants.MSG_FROM_CLIENT:
                    Log.i(TAG, "receive msg from Client:" + msg.getData().getString("msg"));
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }
    
    private final Messenger mMessenger = new Messenger(new MessengerHandler());

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

Messenger的作用是將客戶端發送的消息傳遞給MessengerHandler。

註冊service，讓其運行在獨立的進程中：

<service
    android:name="com.example.messenger.MessengerServce"
    android:process=":remote" >

客戶端代碼：

public class MessengerActivity extends Activity {
    
    private static final String TAG = "MessengerActivity";
    
    private Messenger mService;
    
    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mService = new Messenger(service);
            Message msg = Message.obtain(null, MyConstants.MSG_FROM_CLIENT);
            Bundle data = new Bundle();
            data.putString("msg", "hello, this is client");
            msg.setData(data);
            try {
                mService.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

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

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

        Intent intent = new Intent(this, MessengerService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

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

通過上面的實例可以看出，在Messenger中進行數據傳遞必須將數據放入Message中，而Messenger和Message都實現了Parcelable接口，因此可以跨進程傳輸。簡單來說，Message中所支持的數據類型就是Messenger所支持的傳輸類型。

關於Message

Message中所使用的載體有：what、arg1、arg2、Bundle以及replyTo。

Android 2.2以前object字段不支持掛進程傳輸傳輸；

Android 2.2以後，僅僅是系統提供的實現了Parcelable接口的對象才能通過它來傳輸。

這意味着我們自定義的Parcelable對象是無法通過object字段來傳輸的。

不過我們可以將我們自定義的序列化對象先放入Bundle中，然後將Bundle放入Message中進行傳遞。

在上述實例的基礎上，我們添加服務端的回覆功能，類似於我們給朋友發送電子郵件，發送成功後，對方的郵件會自動回覆“您的郵件已經發送成功！”。

首先我們在原來服務端代碼中做簡單修改：

    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MyConstants.MSG_FROM_CLIENT:
                    Log.i(TAG, "receive msg from Client:" + msg.getData().getString("msg"));
                    Messenger client = msg.replyTo;
                    Message replyMessage = Message.obtain(null, MyConstants.MSG_FROM_SERVICE);
                    Bundle bundle = new Bundle();
                    bundle.putString("reply", "嗯，你的消息我已經收到，稍候會回覆你。");
                    replyMessage.setData(bundle);
                    try {
                        client.send(replyMessage);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

接着再看客戶端的修改，爲了接收服務端的回覆，客戶端也需要準備一個接收消息的Messenger和Handler，如下所示：

    private Messenger mGetReplyMessenger = new Messenger(new MessengerHandler());

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

除了上述修改，還有很關鍵的一點，當客戶端發送消息的時候，需要把接收服務端回覆的Messenger通過Message的replyTo參數傳遞給服務端，如下所示：

mService = new Messenger(service);
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 = mGetReplyMessenger;
try {
    mService.send(msg);
} catch (RemoteException e) {
    e.printStackTrace();
}

Messenger的工作原理圖：