本文转自：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. publicclassRemoteServiceextendsService{
2. publicstaticfinalintGET_RESULT=1;
3. privatefinalMessengermMessenger=newMessenger(newHandler(){
4. privateintremoteInt=1;//返回到进程A的值
5. @Override
6. publicvoidhandleMessage(Messagemsg){
7. if(msg.what==GET_RESULT){
8. try{
9. msg.replyTo.send(Message.obtain(null,GET_RESULT,remoteInt++,0));
10. }catch(RemoteExceptione){
11. e.printStackTrace();
12. }
13. }else{
14. super.handleMessage(msg);
15. }
16. }
17. });
19. @Override
20. publicIBinderonBind(Intentintent){
21. returnmMessenger.getBinder();
22. }
23. }

public class RemoteService extends Service { public static final int GET_RESULT = 1; private final Messenger mMessenger = new Messenger(new Handler() { private int remoteInt = 1;//返回到进程A的值 @Override public void handleMessage(Message msg) { if (msg.what == GET_RESULT) { try { msg.replyTo.send(Message.obtain(null, GET_RESULT, remoteInt++, 0)); } catch (RemoteException e) { e.printStackTrace(); } } else { super.handleMessage(msg); } } }); @Override public IBinder onBind(Intent intent) { return mMessenger.getBinder(); }}

进程A中代码
[java] view plain copy print ?

1. privateMessengermService;
2. privatebooleanisBinding=false;
3. privateServiceConnectionmConnection=newServiceConnection(){
4. @Override
5. publicvoidonServiceConnected(ComponentNamename,IBinderservice){
6. mService=newMessenger(service);
7. isBinding=true;
8. }
10. @OverridepublicvoidonServiceDisconnected(ComponentNamename){
11. mService=null;
12. isBinding=false;
13. }};

private Messenger mService;private boolean isBinding = false;private ServiceConnection mConnection = new ServiceConnection() { @Override public void onServiceConnected(ComponentName name, IBinder service) { mService = new Messenger(service); isBinding = true; } @Override public void onServiceDisconnected(ComponentName name) { mService = null; isBinding = false; } }; [java] view plain copy print ?

1. //绑定进程B的服务
2. bindService(newIntent(this,RemoteService.class),mConnection,BIND_AUTO_CREATE);

//绑定进程B的服务bindService(new Intent(this, RemoteService.class), mConnection, BIND_AUTO_CREATE); [java] view plain copy print ?

1. //处理来自进程B回复的消息
2. privateMessengermMessenger=newMessenger(newHandler(){
3. @Override
4. publicvoidhandleMessage(Messagemsg){
5. if(msg.what==RemoteServiceProxy.GET_RESULT){
6. Log.i("TAG","IntformprocessBis"+msg.arg1);//msg.arg1就是remoteInt
7. }else{
8. super.handleMessage(msg);
9. }
10. }
11. });

//处理来自进程B回复的消息private Messenger mMessenger = new Messenger(new Handler() { @Override public void handleMessage(Message msg) { if (msg.what == RemoteServiceProxy.GET_RESULT) { Log.i("TAG", "Int form process B is "+msg.arg1);//msg.arg1就是remoteInt } else { super.handleMessage(msg); } }}); [java] view plain copy print ?

1. //向进程B发一条消息，并接收来自进程B回复过来的消息
2. Messagemessage=Message.obtain(null,RemoteServiceProxy.GET_RESULT);
3. message.replyTo=mMessenger;
4. try{
5. mService.send(message);
6. }catch(RemoteExceptione){
7. e.printStackTrace();
8. }

//向进程B发一条消息，并接收来自进程B回复过来的消息Message message = Message.obtain(null, RemoteServiceProxy.GET_RESULT);message.replyTo = mMessenger;try { mService.send(message);} catch (RemoteException e) { e.printStackTrace();}

上面这个例子很简单，目的就是从进程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 != null) {
return mMessenger;
}
mMessenger = new MessengerImpl();
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 = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
if ((msg!=null)) {
_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 flags) throws RemoteException {
if (Config.LOGV) Log.v("Binder", "Transact: " + code + " to " + this);
if (data != null) {
data.setDataPosition(0);
}
boolean r = onTransact(code, data, reply, flags);
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 = android.os.Message.CREATOR.createFromParcel(data);
}
else {
_arg0 = null;
}
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处理消息的文章

更多相关文章

1. H5页面调用android方法传json格式
2. Android保证首次获取到的location对象不为空的解决方案
3. Android提交数据到服务的四种方法！！！
4. [转载]android—OpenGL—GL10方法解析(转载)
5. Android实现在xml文件中引用自定义View的方法分析
6. Android 子线程更新UI的几种方法
7. android加载字体内存泄漏的处理方法
8. Android Studio运行main方法报错 SourceSet with name ‘main‘

随机推荐

1. Fatal error: Call to undefined functio
2. Linux环境下通过pdb调试Python程序
3. linux 下的时间获取函数
4. 像wget-like bittorrent客户端还是库?
5. Android(安卓)照相机实现方式
6. 疯狂了，Archlinux+Openbox+Rox+fbpanel我
7. Linux 常用命令使用英文全称
8. 【Azure】两台Linux虚拟机挂载共享文件
9. Linux QT5.2下编译MySQL5.6.7驱动
10. Linux使用wget下载整站