Android IPC 系列(3):Messager

原文地址:http://blog.csdn.net/chenfeng0104/article/details/7010244

Android IPC通信有两种方式,上一篇文章深入分析AIDL原理讲解了AIDL方式,这篇文章讲解另一种IPC通信方式——Messager方式。

Messager实现IPC通信,底层也是使用了AIDL方式。和AIDL方式不同的是,Messager方式是利用Handler形式处理,因此,它是线程安全的,这也表示它不支持并发处理;而AIDL方式是非线程安全的,支持并发处理,因此,我们使用AIDL方式时需要保证代码的线程安全。

大部分情况下,我们应用中不需要并发处理。因此,我们通常只需要使用Messager方式。

思想:在进程A中创建一个Message,将这个Message对象通过IMessenger.send(message)方法传递到进程B(当然,Message对象本身是无法被传递到进程B的,send(message)方法会使用一个Parcel对象对Message对象编集,再将Parcel对象传递到进程B中,然后解编集,得到一个和进程A中Message对象内容一样的对象),再把Message对象加入到进程B的消息队列里,Handler会去处理它。

先看下面这个例子

进程B中代码

[java]   view plain copy print ?
  1. public class RemoteService extends Service {
  2. public static final int GET_RESULT = 1;
  3. private final Messenger> new Messenger(new Handler() {
  4. private int remoteInt = 1;//返回到进程A的值
  5. @Override
  6. public void handleMessage(Message msg) {
  7. if (msg.what == GET_RESULT) {
  8. try {
  9. msg.replyTo.send(Message.obtain(null, GET_RESULT, remoteInt++, 0));
  10. } catch (RemoteException e) {
  11. e.printStackTrace();
  12. }
  13. } else {
  14. super.handleMessage(msg);
  15. }
  16. }
  17. });

  18. @Override
  19. public IBinder onBind(Intent intent) {
  20. return mMessenger.getBinder();
  21. }
  22. }


进程A中代码

[java]   view plain copy print ?
  1. private Messenger mService;
  2. private boolean isBinding = false;
  3. private ServiceConnection> new ServiceConnection() {
  4. @Override
  5. public void onServiceConnected(ComponentName> new Messenger(service);
  6. isBinding = true;
  7. }

  8. @Override public void onServiceDisconnected(ComponentName name) {
  9. mService = null;
  10. isBinding = false;
  11. } };
[java]   view plain copy print ?
  1. //绑定进程B的服务
  2. bindService(new Intent(this, RemoteService.class), mConnection, BIND_AUTO_CREATE);
[java]   view plain copy print ?
  1. //处理来自进程B回复的消息
  2. private Messenger> new Messenger(new Handler() {
  3. @Override
  4. public void handleMessage(Message msg) {
  5. if (msg.what == RemoteServiceProxy.GET_RESULT) {
  6. Log.i("TAG", "Int form process B is "+msg.arg1);//msg.arg1就是remoteInt
  7. } else {
  8. super.handleMessage(msg);
  9. }
  10. }
  11. });
[java]   view plain copy print ?
  1. //向进程B发一条消息,并接收来自进程B回复过来的消息
  2. Message message = Message.obtain(null, RemoteServiceProxy.GET_RESULT);
  3. message.replyTo = mMessenger;
  4. try {
  5. mService.send(message);
  6. } catch (RemoteException e) {
  7. e.printStackTrace();
  8. }

上面这个例子很简单,目的就是从进程A向进程B的RemoteService发一个消息,进程B再把处理结果发给进程A。



下面来深入分析一下Messenger的实现过程

Messenger类的方法:

public Messenger(Handler target) {
mTarget = target.getIMessenger();
}

public IBinder getBinder() {
return mTarget.asBinder();
}

public void send(Message message) throws RemoteException {
mTarget.send(message);
}

Handler类的方法:

final IMessenger getIMessenger() {
synchronized (mQueue) {
if (mMessenger !=> return mMessenger;
}
}

private final class MessengerImpl extends IMessenger.Stub {
public void send(Message msg) {
Handler.this.sendMessage(msg);
}
}

从上面代码可知,当进程A的Activity绑定进程B的RemoteService时,onBind方法返回一个MessengerImpl对象,它是IBinder类的子类。这个对象会被传递到进程A中,在进程A与进程B建立链接时,传到ServiceConnection.onServiceConnected(ComponentName name, IBinder service)方法中,IBinder service就是进程B返回的MessengerImpl对象。然后用service构建一个Messager对象

mService = new Messenger(service);

public Messenger(IBinder target) {
mTarget = IMessenger.Stub.asInterface(target);
}

IMessenger.Stub.asInterface(target)方法会在进程A中创建一个IMessenger的代理类Proxy,看过AIDL的朋友会对这个很熟悉。

当使用mService发送一条消息时,实际调用的是代理类Proxy的send(Message msg)方法。

public void send(android.os.Message msg) throws android.os.RemoteException
{
android.os.Parcel _data => _data.writeInt(1);
msg.writeToParcel(_data, 0);
}
else {
_data.writeInt(0);
}
mRemote.transact(Stub.TRANSACTION_send, _data, null, android.os.IBinder.FLAG_ONEWAY);
}
finally {
_data.recycle();
}
}
}

上面方法是将Message msg的内容写到Parcel _data对象中,然后调用进程B返回的MessengerImpl对象的transact方法。这个方法把_data对象传递到进程B中,看下这个方法

public final boolean transact(int code, Parcel data, Parcel reply,
int> data.setDataPosition(0);
}
boolean> if (reply != null) {
reply.setDataPosition(0);
}
return r;
}

在进程B中调用onTransact方法

public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException

{
switch (code)
{

........

case TRANSACTION_send:
{
data.enforceInterface(DESCRIPTOR);
android.os.Message _arg0;
if ((0!=data.readInt())) {
_arg0 => }
this.send(_arg0);
return true;
}

.......

}
}

这个方法在进程B中恢复进程A传递过来的消息,然后调用this.send(_arg0);。再来看看send(_arg0)这个方法

private final class MessengerImpl extends IMessenger.Stub {
public void send(Message msg) {
Handler.this.sendMessage(msg);
}
}

把它加到进程B的消息队列中了,由Handler处理。Handler怎么处理这里就不再详解,不在本文范围内,这一块我之前研究过,下次有时间再写一篇Handler处理消息的文章

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值