写在前面
Messenger翻译为信使,通过它在进程间传递message对象,然后把我们需要传递的数据封装进message,就可以实现数据在不同进程间的传递。Messenger是一种轻量级的IPC方案,它的底层实现是AIDL。
构造方法
/**
* Create a new Messenger pointing to the given Handler. Any Message
* objects sent through this Messenger will appear in the Handler as if
* {@link Handler#sendMessage(Message) Handler.sendMessage(Message)} had
* been called directly.
*
* @param target The Handler that will receive sent messages.
*/
public Messenger(Handler target) {
mTarget = target.getIMessenger();
}
/**
* Create a Messenger from a raw IBinder, which had previously been
* retrieved with {@link #getBinder}.
*
* @param target The IBinder this Messenger should communicate with.
*/
public Messenger(IBinder target) {
mTarget = IMessenger.Stub.asInterface(target);
}
从构造方法的实现上可以明显的看出AIDL的痕迹,不管是IMessenger还是Stub.asInterface,这种使用方法都表明它的底层是AIDL。
通过构造你会发现mTarget(IMessenger)和IBinder存在转化关系,即IMessenger.Stub已经帮我们实现了这种转化方法 asInterface(),IBinder-》mTarget;asBinder(),mTarget-》IBinder。
所以结论是:IBinder可以关联到一个Handler,通过一个Messenger的getBinder()获取的IBinder可以创建一个关联相同Handler的Messenger。
使用
Messenger的使用方法很简单,因为它对AIDL做了封装,同时,由于它一次处理一个请求,因此在服务端我们不用考虑线程同步问题,因为服务端不存在并发执行的情形。
服务端进程
首先,我们需要在服务端创建一个Service来处理客户端的连接请求,同时创建一个Handler并通过它创建一个Messenger对象,然后在onBind中将Messenger底层的Binder返回。而在接收到客户端的消息后,从Message对象中取出replyTo参数对应的Messenger对象(客户端发消息的时候,将客户端的Messenger对象通过Message对象中replyTo参数传递过来),通过这个Messenger就可以给客户端发送消息了。
客户端进程
首先,我们要在客户端进程中绑定服务端的Service,绑定成功后用服务端返回的IBinder对象创建一个Messenger,通过这个Messenger就可以给服务端发送消息了,而且消息类型为Message对象。然后,客户端创建一个Handler并通过它创建一个Messenger对象,并且把这个Messenger对象通过Message对象的replyTo参数传递给服务端,服务端取出replyTo对象的Messenger对象就可以给客户端发送消息了。具体看代码:
首先是服务端代码,messenger对象是和MessengerHandler相关联的,并且在onBind方法中返回了messenger中的Binder对象,所以messenger的作用是将客户端发送的消息传递给MessengerHandler去处理。
public class MessengerService extends Service {
private static class MessengerHandler extends Handler {
private String TAG = "MessengerService";
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case Constants.MSG_FROM_CLIENT:
Log.i(TAG, "receive message from client:" + msg.getData().getString("msg"));
Messenger client = msg.replyTo;
Message replyMessage = Message.obtain(null, Constants.MSG_FROM_SERVICE);
Bundle bundle = new Bundle();
bundle.putString("reply", "嗯,你的消息我已经收到,稍后会回复你。");
replyMessage.setData(bundle);
try {
client.send(replyMessage);
} catch (RemoteException e) {
e.printStackTrace();
}
break;
default:
super.handleMessage(msg);
}
}
}
private final Messenger messenger = new Messenger(new MessengerHandler());
@Nullable
@Override
public IBinder onBind(Intent intent) {
return messenger.getBinder();
}
}
然后注册Service,使其运行在单独进程中。
<service android:name=".messenger.MessengerService"
android:process=":remote"/>
客户端实现:
public class MessengerActivity extends AppCompatActivity {
private static String TAG = "MessengerActivity";
private Messenger mService;
private ServiceConnection mConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mService = new Messenger(service);
Message message = Message.obtain(null, Constants.MSG_FROM_CLIENT);
Bundle bundle = new Bundle();
bundle.putString("msg", "hello,this is client");
message.setData(bundle);
message.replyTo = mGetMessenger;
try {
mService.send(message);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
};
private Messenger mGetMessenger = new Messenger(new MessengerHandler());
private static class MessengerHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case Constants.MSG_FROM_SERVICE:
Log.i(TAG, "receive message from service:" + msg.getData().getString("reply"));
break;
default:
super.handleMessage(msg);
}
}
}
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_messenger);
Intent intent = new Intent(MessengerActivity.this, MessengerService.class);
bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
}
@Override
protected void onDestroy() {
unbindService(mConnection);
super.onDestroy();
}
}
原理图
通过这张原理图能够帮助更好的理解,首先Client绑定Service,服务端在onBind方法中返回Messenger(通过构造方法关联了Handler)中的Binder对象,然后客户端在onServiceConnected函数中能够得到服务端返回的Binder对象,通过这个Binder对象可以创建一个关联与服务端进程中相同的Handler的Messenger对象(在客户端进程中发送消息其实最终是调用了服务端的Handler的sendMessage方法)。然后通过Message的replyTo参数将客户端的Messenger对象传递给服务端,当服务端收到消息后(客户端通过关联了服务端的Handler的Messenger对象发送的消息),取出Message中的replyTo对应的Messenger对象(客户端的Messenger对象)。最后通过这个Messenger对象发送消息给客户端。
总结
通过亲自动手实现以后,感觉理解起来还是蛮清晰的,除了客户端通过
public Messenger(IBinder target) {
mTarget = IMessenger.Stub.asInterface(target);
}
这个构造得到关联服务端的Handler对象不好理解,其他应该是比较好理解的。举个例子可能会更好理解一点:首先是进程A拿到进程B中的Messenger对象,然后调用它的send方法,而这个方法会调用进程B中的Messenger对象关联的Handler的sendMessage方法,最后进程B中的Handler收到消息并处理。
到这里通过Messenger在进程间通信就介绍完了,本人也是通过查看Android开发艺术探索一书学习,自己实现一下,加深一点理解,非常感谢任玉刚老师出的此书。