Android中的跨进程通信可以是一个App中的两个进程,也可以是两个App之间进行通信。
Messenger是一种轻量的IPC通信机制。
Messenger的使用步骤
1,在Service中需要实现一个Handler,用来处理从客户端接收到的消息。比如说下面:
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());
}
}
}
}
2,使用该Handler来创建一个Messenger对象,Messenger对象内部会引用该Handler对象。如下:
private Messenger serviceMessenger = new Messenger(new ServiceHandler());
3,用创建好的Messenger对象获得一个IBinder对象实例,该Messenger对象内部指向了Service中的Handler,客户端可以通过该Messenger对象向Service 中的Handler发送消息。
(这是因为Messenger对象创建时,便是用的Handler创建的,已经跟Service中的Handler绑定了,于是客户端获得了IBinder对象之后,从IBinder对象中获取到Messenger对象,而使用该Messenger对象便可以向Service中的Handler发送消息)。在Service的onBind()方法中返回一个绑定了当前service的Messenger的Binder对象。在每个client对Service进行bindService()时便可以获取到。
如下:
@Override
public IBinder onBind(Intent intent) {
Log.i("DemoLog", "MyServivce -> onBind");
//获取Service自身Messenger所对应的IBinder,并将其发送共享给所有客户端
return serviceMessenger.getBinder();
}
4,客户端通过收到的IBinder对象实例化一个Messenger对象,该Messenger对象内部指向了Service中的Handler,客户端通过该Messenger可以向Service中的Handler发送消息。(因为客户端获取到的IBinder对象是Service的onBind返回的,而返回的那个IBinder便是绑定了Service的Messenger以及Handler)
如下:
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());
}
}
5,Service中的Handler收到了来自客户端的消息之后,在Handler中的handleMessage中处理消息。
6,通过上面的第4步与第5步,就完成了客户端向Service发送消息并且Service接收到消息的单向通信过程,即客户端 -> Service。
7,如果要实现Service向客户端回消息的通信过程,即Service -> 客户端。
便在客户端中维护一个由一个指向客户端中的Handler的Messenger,当在第4步向Service发送消息时,将Message的replyTo属性设置为客户端自己的Messenger。
//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);
}
}
}
}
8,同理,Service收到了客户端的消息之后,可以通过收到的Message消息对象获取到客户端的Messenger,并向客户端发送Message,这样客户端内维护的Handler对象就会收到来自于Service的Message,从而完成Service向客户端发送消息且客户端接收到消息的通信过程。
便可以完成双向通信:客户端 -> Service -> 客户端
需要知道的
1,Messenger是和Handler、IBinder绑定在一起的,因此Messenger的构造函数有两种:
1,传入Handler,根据传入的Handler创建Messenger,且该Messenger指向该Handler,
当我们向Messenger发送信息的时候,Handler会受到信息并处理消息,
比如在MyService中用ServiceHandler的实例初始化了自身的serviceMessenger以及在客户端中用ClientHandler的实例初始化了其自身的clientMessenger。这种Messenger可以看做是本地的Messenger。创建完的Messenger可以通过getBinder()方法得到对应的IBinder类型的实例。
2,另一种是传入一个IBinder。根据传入的IBinder实例创建一个远程的Messenger,这种往往是在客户端中,通过Service的onBind方法返回的IBinder,基于此IBinder初始化一个远程的Messenger,该Messenger指向的是Service,而不是Client
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,Service读取信息,即客户端 -> Service
Service给客户端回信,客户端读取信息,即Service -> 客户端
注意事项
1,在Android 5.0及以上的版本中,必须使用显式的intent去执行启动服务。
我们先构建一个隐式的Intent,然后通过PackageManager的resolveService获取可能会被启动的Service的信息。如果ResolveInfo不为空,说明我们能通过上面隐式的Intent找到对应的Service,并且我们还可以获取将要启动的Service的package信息以及类型。然后我们需要将根据得到的Service的包名和类名,构建一个ComponentName,从而设置intent要启动的具体的组件信息,然后我们可以将该显式的intent传递给bindService方法去启动服务。
2,当用Messenger在两个进程之间传递Message时,Message的obj不能设置为设置为non-Parcelable的对象
比如说String就是non-Parcelable的类型。
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();
}
}
- 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的消息。