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文件如下所示:

<?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不管用，有知道的请告知一下