Android中通過Messenger與Service實現進程間雙向通信

Android中的Service和其調用者既可以在同一個App中，也可以在不同的App。如果Service在App1中，而調用Service的客戶端在App2中，那麼我們就可以用Service實現進程間的相互通信。本文將介紹如何通過bindService和Messenger實現進程間通信（IPC），如果對bindService綁定服務和Binder不熟悉，可參見《Android中bindService的使用及Service生命周期》，理解該博文是本文的基礎。

讓Service實現與其他進程通信的關鍵是Messenger，以及與其相關的IBinder和Hanlder。如果對Handler不熟悉，可參見《Android中Handler的使用》。

---

Messenger使用步驟

以下是如何使用Messenger的步驟:
1. Service需要實現一個Hanlder，用以處理從客戶端收到的消息
2. 用該Handler創建一個Messenger對象，Messenger對象內部會引用該Handler對象
3. 用創建好的Messenger對象獲得一個IBinder實例，並且將該IBinder通過Service的onBind方法返回給各個客戶端
4. 客戶端通過收到的IBinder對象實例化一個Messenger對象，該Messenger內部指向指向Service中的Handler。客戶端通過該Messenger對象就可以向Service中的Hanlder發送消息。
5. Service中的Hanlder收到消息後，在Handler中的handleMessage方法中處理消息。
6. 通過上面的第4步與第5步，就完成了客戶端向Service發送消息並且Service接收到消息的單向通信過程，即客戶端 -> Service。如果要實現Service向客戶端回消息的通信過程，即Service -> 客戶端，那麼前提是在客戶端中也需要像Service一樣內部維護有一個指向Handler的Messenger。當在第四步中客戶端向Service發送信息時，將Message的replyTo屬性設置為客戶端自己的Messenger。這樣在第5步Service在Handler的handleMessage中處理收到的消息時，可以通過Message的Messenger再向客戶端發送Message，這樣客戶端內維護的Handler對象就會收到來自於Service的Message，從而完成Service向客戶端發送消息且客戶端接收到消息的通信過程。

綜上六步就能完成客戶端與Service的跨進程雙向通信過程:
客戶端 -> Service -> 客戶端

為了演示客戶端與Service的跨進程通信，我建立了兩個應用ClientApp和ServiceApp，兩個應用的名稱也是見名知意:
1. ClientApp, 該App是客戶端，用於調用服務
2. ServiceApp，該App是Service端，用於供客戶端ClientApp調用

---

Service代碼

ServiceApp中只有一個MyService類，沒有其他Activity，也就是說ServiceApp沒有任何UI界面。ServiceApp的manifest.xml文件如下所示:

我們在ServiceApp的manifest.xml文件中注冊了MyService，並通過exported=”true”將其聲明為可被其他App調用的。需要注意的是，我們將其action設置為自定義的action（com.ispring2.action.MYSERVICE），這是為了方便客戶端通過其action啟動MyService。並且我們將其設置了值為android.intent.category.DEFAULT的category。

ServiceApp中MyService的代碼如下所示:

package com.ispring2.serviceapp;

import android.app.Service;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;

public class MyService extends Service {

    private static final int RECEIVE_MESSAGE_CODE = 0x0001;

    private static final int SEND_MESSAGE_CODE = 0x0002;

    //clientMessenger表示的是客戶端的Messenger，可以通過來自於客戶端的Message的replyTo屬性獲得，
    //其內部指向了客戶端的ClientHandler實例，可以用clientMessenger向客戶端發送消息
    private Messenger clientMessenger = null;

    //serviceMessenger是Service自身的Messenger，其內部指向了ServiceHandler的實例
    //客戶端可以通過IBinder構建Service端的Messenger，從而向Service發送消息，
    //並由ServiceHandler接收並處理來自於客戶端的消息
    private Messenger serviceMessenger = new Messenger(new ServiceHandler());

    //MyService用ServiceHandler接收並處理來自於客戶端的消息
    private class ServiceHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            Log.i(DemoLog, ServiceHandler -> handleMessage);
            if(msg.what == RECEIVE_MESSAGE_CODE){
                Bundle data = msg.getData();
                if(data != null){
                    String str = data.getString(msg);
                    Log.i(DemoLog, MyService收到客戶端如下信息:  + str);
                }
                //通過Message的replyTo獲取到客戶端自身的Messenger，
                //Service可以通過它向客戶端發送消息
                clientMessenger = msg.replyTo;
                if(clientMessenger != null){
                    Log.i(DemoLog, MyService向客戶端回信);
                    Message msgToClient = Message.obtain();
                    msgToClient.what = SEND_MESSAGE_CODE;
                    //可以通過Bundle發送跨進程的信息
                    Bundle bundle = new Bundle();
                    bundle.putString(msg, 你好，客戶端，我是MyService);
                    msgToClient.setData(bundle);
                    try{
                        clientMessenger.send(msgToClient);
                    }catch (RemoteException e){
                        e.printStackTrace();
                        Log.e(DemoLog, MyService向客戶端發送信息失敗:  + e.getMessage());
                    }
                }
            }
        }
    }

    @Override
    public void onCreate() {
        Log.i(DemoLog, MyService -> onCreate);
        super.onCreate();
    }

    @Override
    public IBinder onBind(Intent intent) {
        Log.i(DemoLog, MyServivce -> onBind);
        //獲取Service自身Messenger所對應的IBinder，並將其發送共享給所有客戶端
        return serviceMessenger.getBinder();
    }

    @Override
    public void onDestroy() {
        Log.i(DemoLog, MyService -> onDestroy);
        clientMessenger = null;
        super.onDestroy();
    }
}

MyService中有一個內部類ServiceHandler，繼承自Hanlder並重寫了handleMessage方法，MyService用ServiceHandler接收並處理來自於客戶端的消息。 MyService中，我們用ServiceHandler的實例初始化了serviceMessenger。serviceMessenger是Service自身的Messenger，其內部指向了ServiceHandler的實例，客戶端可以通過IBinder構建Service端的Messenger，從而向Service發送消息，並由ServiceHandler接收並處理來自於客戶端的消息。

---

客戶端代碼

客戶端應用ClientApp就一個MainActivity，其界面上就只有兩個按鈕:bindService和unbindService, 界面如下:

代碼如下所示：

package com.ispring.clientapp;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;
import android.view.View;
import android.widget.Button;


public class MainActivity extends Activity implements Button.OnClickListener {

    private static final int SEND_MESSAGE_CODE = 0x0001;

    private static final int RECEIVE_MESSAGE_CODE = 0x0002;

    private boolean isBound = false;

    //用於啟動MyService的Intent對應的action
    private final String SERVICE_ACTION = com.ispring2.action.MYSERVICE;

    //serviceMessenger表示的是Service端的Messenger，其內部指向了MyService的ServiceHandler實例
    //可以用serviceMessenger向MyService發送消息
    private Messenger serviceMessenger = null;

    //clientMessenger是客戶端自身的Messenger，內部指向了ClientHandler的實例
    //MyService可以通過Message的replyTo得到clientMessenger，從而MyService可以向客戶端發送消息，
    //並由ClientHandler接收並處理來自於Service的消息
    private Messenger clientMessenger = new Messenger(new ClientHandler());

    //客戶端用ClientHandler接收並處理來自於Service的消息
    private class ClientHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            Log.i(DemoLog, ClientHandler -> handleMessage);
            if(msg.what == RECEIVE_MESSAGE_CODE){
                Bundle data = msg.getData();
                if(data != null){
                    String str = data.getString(msg);
                    Log.i(DemoLog, 客戶端收到Service的消息:  + str);
                }
            }
        }
    }

    private ServiceConnection conn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder binder) {
            //客戶端與Service建立連接
            Log.i(DemoLog, 客戶端 onServiceConnected);

            //我們可以通過從Service的onBind方法中返回的IBinder初始化一個指向Service端的Messenger
            serviceMessenger = new Messenger(binder);
            isBound = true;

            Message msg = Message.obtain();
            msg.what = SEND_MESSAGE_CODE;

            //此處跨進程Message通信不能將msg.obj設置為non-Parcelable的對象，應該使用Bundle
            //msg.obj = 你好，MyService，我是客戶端;
            Bundle data = new Bundle();
            data.putString(msg, 你好，MyService，我是客戶端);
            msg.setData(data);

            //需要將Message的replyTo設置為客戶端的clientMessenger，
            //以便Service可以通過它向客戶端發送消息
            msg.replyTo = clientMessenger;
            try {
                Log.i(DemoLog, 客戶端向service發送信息);
                serviceMessenger.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
                Log.i(DemoLog, 客戶端向service發送消息失敗:  + e.getMessage());
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            //客戶端與Service失去連接
            serviceMessenger = null;
            isBound = false;
            Log.i(DemoLog, 客戶端 onServiceDisconnected);
        }
    };

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

    @Override
    public void onClick(View v) {
        if(v.getId() == R.id.btnBindService){
            //單擊了bindService按鈕
            if(!isBound){
                Intent intent = new Intent();
                intent.setAction(SERVICE_ACTION);
                intent.addCategory(Intent.CATEGORY_DEFAULT);

                PackageManager pm = getPackageManager();
                //我們先通過一個隱式的Intent獲取可能會被啟動的Service的信息
                ResolveInfo info = pm.resolveService(intent, 0);

                if(info != null){
                    //如果ResolveInfo不為空，說明我們能通過上面隱式的Intent找到對應的Service
                    //我們可以獲取將要啟動的Service的package信息以及類型
                    String packageName = info.serviceInfo.packageName;
                    String serviceNmae = info.serviceInfo.name;
                    //然後我們需要將根據得到的Service的包名和類名，構建一個ComponentName
                    //從而設置intent要啟動的具體的組件信息，這樣intent就從隱式變成了一個顯式的intent
                    //之所以大費周折將其從隱式轉換為顯式intent，是因為從Android 5.0 Lollipop開始，
                    //Android不再支持通過通過隱式的intent啟動Service，只能通過顯式intent的方式啟動Service
                    //在Android 5.0 Lollipop之前的版本倒是可以通過隱式intent啟動Service
                    ComponentName componentName = new ComponentName(packageName, serviceNmae);
                    intent.setComponent(componentName);
                    try{
                        Log.i(DemoLog, 客戶端調用bindService方法);
                        bindService(intent, conn, BIND_AUTO_CREATE);
                    }catch(Exception e){
                        e.printStackTrace();
                        Log.e(DemoLog, e.getMessage());
                    }
                }
            }
        }else if(v.getId() == R.id.btnUnbindService){
            //單擊了unbindService按鈕
            if(isBound){
                Log.i(DemoLog, 客戶端調用unbindService方法);
                unbindService(conn);
            }
        }
    }
}

ClientHandler繼承自Hanlder，並重寫了handleMessage方法，客戶端用ClientHandler接收並處理來自於Service的消息。 我們用ClientHandler的實例初始化了clientMessenger。clientMessenger是客戶端自身的Messenger，內部指向了ClientHandler的實例，MyService可以通過Message的replyTo得到clientMessenger，從而MyService可以向客戶端發送消息，並由ClientHandler接收並處理來自於Service的消息。

---

分析結果

我們在上述代碼的各個關鍵節點都添加了代碼輸出語句，我們通過DDMS觀察輸出結果。

首先打開ClientApp，單擊上面的bindService按鈕，我們看到DDMS裡面的輸出結果如下所示:

我們通過上面的圖片可以看出，客戶端ClientApp和服務ServiceApp的所屬進程PID分別為2524和2542，二者運行在不同的進程中。

我們通過輸出結果分析一下代碼的執行過程:
1. 首先我們要明白一點，Messenger是和Handler以及IBinder綁定在一起的。因此Messenger的構造函數有兩種：
a. 一種是傳入一個Hanlder，根據傳入的Handler創建Messenger，且該Messenger指向該Handler，當我們向Messenger發送信息的時候，Handler會受到信息並處理消息，該構造函數往往是在某個類中構建該類自身的Messenger，比如在MyService中用ServiceHandler的實例初始化了自身的serviceMessenger以及在客戶端中用ClientHandler的實例初始化了其自身的clientMessenger。這種Messenger可以看做是本地的Messenger。創建完的Messenger可以通過getBinder()方法得到對應的IBinder類型的實例。
b. 另一種是傳入一個IBinder，根據傳入的IBinder實例創建一個遠程的Messenger。這種構造函數往往是在客戶端中，通過得到Service的onBind方法返回的IBinder，然後基於此IBinder初始化一個遠程的Messenger。該Messenger指向的是Service，而不是客戶端，所以該Messenger就是一種遠程的Messenger。比如客戶端中的serviceMessenger就是一種遠程的Messenger，指向的是MyService。

2.當單擊了客戶端中的bindService按鈕後，我們通過intent啟動了MyService，MyService開始執行其生命周期，先執行onCreate回調方法，然後執行onBind回調方法，在執行onBind方法的時候，該方法返回了MyService中本地serviceMessenger所對應的binder，將其返回給客戶端。

3.MyService的onBind方法返回之後，會將IBinder傳入客戶端的ServiceConnection對象的onServiceConnected回調方法中，該方法的執行表明客戶端與MyService建立了連接。此時，我們會根據來自於MyService的IBinder初始化一個指向MyService的serviceMessenger，serviceMessenger是一個遠程Messenger。

4.在得到指向MyService的serviceMessenger之後，我們就可以通過它向MyService發送下消息了。我們構建了一個Message，並通過Bundle為其設置了數據，而且需要注意的是，我們還將Message的replyTo設置為客戶端的clientMessenger，以便Service可以通過它向客戶端發送消息。然後通過代碼serviceMessenger.send(msg)將Message發送給MyService。

5.客戶端通過serviceMessenger向MyService發送消息後，MyService的ServiceHandler收到消息，並在handleMessage中處理該消息。我們首先讀取了該Message的Bundle數據，並打印出來。然後我們通過通過Message的replyTo獲取到指向客戶端自身的Messenger，並且我們將其保存在了MyService的clientMessenger中，clientMessenger相對於MyService來說是一個遠程的Messenger。然後我們又構造了一條Message，並且也通過Bundle設置數據，通過執行代碼clientMessenger.send(msgToClient)向客戶端回信發送消息。由於我們保存了clientMessenger，所以我們可以在後續的過程中隨時向客戶端主動發送消息。

6.MyService通過clientMessenger向客戶端發信信息後，客戶端的ClientHandler收到信息，並在其handleMessage方法中處理消息: 讀取來自於MyService的Message的Bundle數據，並將其打印出來。

通過以上的幾步我們就能實現客戶單與Service的跨進程的雙向通信:
1. 客戶端發信息到Service，Service讀取信息，即客戶端 -> Service
2. Service給客戶端回信，客戶端讀取信息，即Service -> 客戶端

以上就是當我們單擊客戶端上的bindService按鈕所發生的代碼執行過程，當我們單擊unbindService按鈕時，DDMS輸出結果如下所示:

當執行unbindService的時候，客戶端與MyService就斷開了連接，此時沒有其他的客戶端連接到MyService上，所以MyService就執行了onUnbind回調方法，然後執行onDestroy回調方法，MyService銷毀。

---

注意事項

在客戶端代碼中，有兩點需要注意:
1.當通過執行bindService(intent, conn, BIND_AUTO_CREATE)代碼的時候，如果intent只設置了action和category，沒有明確指明要啟動的組件，那麼該intent就是是隱式的。在Android 5.0及以上的版本中，必須使用顯式的intent去執行啟動服務，如果使用隱式的intent，則會報如下錯誤:

3072-3072/com.ispring.clientapp E/DemoLog﹕ Service Intent must be explicit: Intent { act=com.ispring2.action.MYSERVICE cat=[android.intent.category.DEFAULT] }

解決辦法是我們先構建一個隱式的Intent，然後通過PackageManager的resolveService獲取可能會被啟動的Service的信息。如果ResolveInfo不為空，說明我們能通過上面隱式的Intent找到對應的Service，並且我們還可以獲取將要啟動的Service的package信息以及類型。然後我們需要將根據得到的Service的包名和類名，構建一個ComponentName，從而設置intent要啟動的具體的組件信息，這樣intent就從隱式變成了一個顯式的intent。然後我們可以將該顯式的intent傳遞給bindService方法去啟動服務。
具體可參見連接：http://stackoverflow.com/questions/24480069/google-in-app-billing-illegalargumentexception-service-intent-must-be-explicit/26318757#26318757。

2.當用Messenger在兩個進程之間傳遞Message時，Message的obj不能設置為設置為non-Parcelable的對象，比如在跨進程的情形下，Message的obj設置為了一個String對象，那麼在Messenger執行send(Message)方法時就會報如下錯誤:

java.lang.RuntimeException: Can’t marshal non-Parcelable objects across processes.

解決該問題最簡單的辦法是，在跨進程的時候不使用Message的obj，用Bundle傳遞數據，setData設置Bundle數據，getData獲取Bundle數據。

希望本文對大家使用Messenger以及與Service的跨進程雙向通信有所幫助。

PS：CSDN的Markdown編輯器內嵌的html不支持style嗎？設置了style不管用，有知道的請告知一下