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 的代码如下所示:

客户端代码
客户端应用 ClientApp 就一个 MainActivity，其界面上就只有两个按钮:bindService 和 unbindService, 界面如下:


代码如下所示：
分析结果
我们在上述代码的各个关键节点都添加了代码输出语句，我们通过 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