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

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)方法時就會報如下錯誤:
html不支援style嗎？設定了style不管用，有知道的請告知一下