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

孫群發表於2015-09-10
AndroidMessenger

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檔案如下所示:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.ispring2.serviceapp" >

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="ServiceApp">

        <service
            android:name=".MyService"
            android:enabled="true"
            android:exported="true" >
            <intent-filter>
                <action android:name="com.ispring2.action.MYSERVICE" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
        </service>
    </application>

</manifest>

我們在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();
    }
}
  1. MyService中有一個內部類ServiceHandler，繼承自Hanlder並重寫了handleMessage方法，MyService用ServiceHandler接收並處理來自於客戶端的訊息。
  2. 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);
            }
        }
    }
}
  1. ClientHandler繼承自Hanlder，並重寫了handleMessage方法，客戶端用ClientHandler接收並處理來自於Service的訊息。
  2. 我們用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不管用，有知道的請告知一下

相關文章