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 数据。
原文：http://blog.csdn.net/iispring/article/details/48329925
欢迎来到这里！
我们正在构建一个小众社区，大家在这里相互信任，以平等 • 自由 • 奔放的价值观进行分享交流。最终，希望大家能够找到与自己志同道合的伙伴，共同成长。
注册 关于