本文学习目标：
- 学会如何使用Messenger进行跨进程通讯；
- 延伸阅读：
Android 消息处理机制：https://www.jianshu.com/p/02962454adf7
在上一章中介绍了服务使用，服务启动的两种方式，startService()和bindService()，startService启动的服务，跟启动它的应用组件是没有联系的，因此不管是否跨进程，startService都是可以成功的。而在跨进程服务，bindService()会异常，在onServiceConnected方法中报类型转换异常，说明这时候不能使用这个Binder对象进行转换了。这时候，就需要使用Messenger了。
其实Messenger底层也是使用aidl的方式来实现的，只不过其使用handler来处理消息，因为handler是线程安全的，所以Messenger也是线程安全的，自然Messenger只能处理单线程的问题，如果要使用多线程就该使用aidl的方式实现。
其实，Messenger也是通过bindService的方式，只是需要定义不用的IBinder对象。
主要步骤：
- 服务实现Handler，来处理客户端发送的消息Message;
- 根据Handler创建一个Messenger对象；
- 通过onBinder返回Messenger的Binder对象；
- 客户端使用IBinder将Messenger实例化，然后通过Messenger将Message发送给服务；
public class MessengerService extends Service {
public final static String TAG = MessengerService.class.getSimpleName();
public final static int MSG_SAY_HELLO = 1;
public MessengerService() {
}
@Override
public void onCreate() {
Log.d(TAG, "onCreate");
super.onCreate();
}
@Override
public void onDestroy() {
Log.d(TAG, "onDestroy");
super.onDestroy();
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.d(TAG, "onStartCommand");
return super.onStartCommand(intent, flags, startId);
}
/**
* 1. 定义一个Handler,用于处理客户端发来的请求
*/
class ProcessHandler extends Handler{
@Override
public void handleMessage(Message msg) {
switch (msg.what){
case MSG_SAY_HELLO:
Log.d(TAG, "service receiver from client: say hello");
break;
default:
super.handleMessage(msg);
}
}
}
/**
* 2. 创建一个Messenger并传入Handler实例对象
*/
final Messenger mMessager = new Messenger(new ProcessHandler());
@Override
public IBinder onBind(Intent intent) {
Log.d(TAG, "onBind");
// 3.通过onBinder返回Messenger的Binder对象
return mMessager.getBinder();
}
@Override
public boolean onUnbind(Intent intent) {
Log.d(TAG, "onUnbind");
return super.onUnbind(intent);
}
}
清单定义：
<service
android:name=".MessengerService"
android:enabled="true"
android:exported="true"
android:process=":messengerSer"/>
/**
* 与服务端交互的Messender
*/
Messenger mService = null;
boolean mBound = false;
/**
* ServiceConnection代表与服务的连接，
*/
ServiceConnection cnn2 = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
Log.d("###", "onServiceConnected");
/**
* 3. 通过服务端传递的IBinder对象，创建相应的Messenger
* 然后通过Messenger对象与服务端进行交互
*/
mService = new Messenger(iBinder);
mBound = true;
}
@Override
public void onServiceDisconnected(ComponentName componentName) {
Log.d("###", "onServiceDisconnected");
mService = null;
mBound = false;
}
};
// 绑定服务
Intent intent = new Intent(this, MessengerService.class);
bindService(intent, cnn2, BIND_AUTO_CREATE);
// 解绑服务
unbindService(cnn2);
mBound = false;
// 发送消息
Message msg = Message.obtain(null, MessengerService.MSG_SAY_HELLO);
try {
// 4. 通过Messenger发送消息
mService.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
流程图：
流程图
效果：
image.png
此时，解决了客户端往服务发送消息。如果客户端需要接收服务的消息呢？
我们需要在客户端定义一个Messenger和Handler，然后发送消息的时候传递这个Messenger。
/**
* 定义客户端的Messenger和Handler
*/
Messenger repo = new Messenger(new ClientHandler());
class ClientHandler extends Handler{
@Override
public void handleMessage(Message msg) {
switch (msg.what){
case MessengerService.MSG_REPO_SAY_HELLO:
Log.d("####", "client receive from server say hello");
break;
default:
super.handleMessage(msg);
}
}
}
发送消息的时候，设置replyTo
Message msg = Message.obtain(null, MessengerService.MSG_SAY_HELLO);
msg.replyTo = repo; // 传递Messenger
try {
mService.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
服务在处理Message时候，取出客户端的Messenger,然后发送消息
class ProcessHandler extends Handler{
@Override
public void handleMessage(Message msg) {
switch (msg.what){
case MSG_SAY_HELLO:
Log.d(TAG, "service receiver from client: say hello");
Messenger repo = msg.replyTo; // 获取客户端Messenger
Message rmsg = Message.obtain(null, MSG_REPO_SAY_HELLO);
try {
// 发送消息
repo.send(rmsg);
} catch (RemoteException e) {
e.printStackTrace();
}
break;
default:
super.handleMessage(msg);
}
}
}
效果：
服务：
服务收到消息
客户端：
客户端收到消息
