深入理解AsyncChannel、Messenger

这篇文章主要介绍Android AsyncChannel、Messenger原理及其应用实例
注&＃xff1a;文章参考的是Andrdoid 8.0源码

AsyncChannel 简介
　　
　　AsyncChannel的源码位于 frameworks/base/core/java/com/android/internal/util/AsyncChannel.java&＃xff0c;是对Handler和Messenger的一个扩展&＃xff0c;用于单个进程内&＃xff08;包含不同线程间&＃xff09;或两个进程间的通信。在不同的进程间&＃xff0c;AsyncChanne实质上使用的是IMessenger通过Binder的形式对消息进行发送和接收&＃xff0c;当然&＃xff0c;这种方式对单个进程内非remove service同样适用。
　　在Android系统中&＃xff0c;有很多地方都使用了这个工具类&＃xff0c;如ConnectivityService与NetworkAgent的通信&＃xff0c;WifiServiceImpl与WifiStateMachine之间的通信等。由于AsyncChannel属于系统内部源码&＃xff0c;三方应用无法直接进行使用&＃xff0c;但我们可以学习思想&＃xff0c;甚至可以自己简单实现并作用于我们的APP代码中。

AsyncChannel的主要特点&＃xff1a;

• 可以在单进程或不同进程间实现消息传递
• 支持建立单向通信或双向通信
• 是对Handler&＃xff0c;Messenger的一种包装&＃xff0c;并没有实现额外的通信方式

Messenger

　　由于AsyncChannel实际上使用的是Handler和Messenger的机制&＃xff0c;考虑到很多开发者对Messenger还不够了解&＃xff0c;所以我们这里有必要先对这个工具做一个详细的解析。
　　Messenger的源码位于 frameworks/base/core/java/android/os/Messenger.java&＃xff0c;是对Handler的一个再包装&＃xff0c;并结合了Binder机制&＃xff0c;使得跨进程间Message的传递和处理成为了可能。

成员变量及构造函数&＃xff1a;

　　主要成员变量是IMessenger类型的mTarget&＃xff0c;该变量可以通过Handler或者IBinder进行初始化&＃xff0c;分别应用于同进程消息或者跨Service&＃xff08;remote或者非remote&＃xff09;消息发送&＃xff1a;

// IMessenger类型&＃xff0c;mTarget代表message的目的端
private final IMessenger mTarget;// 初始化mTarget并指向Handler中的IMessenger
public Messenger(Handler target) {mTarget &＃61; target.getIMessenger();
}// 初始化mTarget并指向IBinder的实际类型
public Messenger(IBinder target) {mTarget &＃61; IMessenger.Stub.asInterface(target);
}

Messenger的发送函数&＃xff1a;

　　无论是否跨进程&＃xff0c;Messenger实际上都是利用IMessenger进行消息发送的&＃xff1a;

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

IMessenger&＃xff1a;

　　源码位于 frameworks/base/core/java/android/os/IMessenger.aidl&＃xff0c;其目的是通过AIDL使用Binder机制对Message进行发送&＃xff1a;

/** &＃64;hide */
oneway interface IMessenger {void send(in Message msg);
}

通过Handler对mTarget进行初始化&＃xff1a;

　　Handler中MessengerImpl对IMessenger进行了实现&＃xff0c;在 send 函数中最终还是使用Handler自身对Message进行了处理&＃xff0c;因此&＃xff0c;这里的IMessenger仅仅是一个中介&＃xff1a;

final IMessenger getIMessenger() {synchronized (mQueue) {if (mMessenger !&＃61; null) {return mMessenger;}mMessenger &＃61; new MessengerImpl();return mMessenger;}
}private final class MessengerImpl extends IMessenger.Stub {public void send(Message msg) {// 由于存在Binder调用&＃xff0c;初始化sendingUid为发送端uidmsg.sendingUid &＃61; Binder.getCallingUid();// 通过Handler自身发送消息并进行处理Handler.this.sendMessage(msg);}
}

通过Service IBinder对mTarget进行初始化&＃xff1a;
　　
　　这里以Android源码中针对Messenger的测试case作为例子对其过程进行解析&＃xff0c;源码路径&＃xff1a;
- frameworks/base/core/tests/coretests/src/android/os/MessengerService.java
- frameworks/base/core/tests/coretests/src/android/os/MessengerTest.java

Service端实现&＃xff08;MessengerService.java&＃xff09;&＃xff1a;

public class MessengerService extends Service {private final Handler mHandler &＃61; new Handler() {&＃64;Overridepublic void handleMessage(Message msg) {// 在这里处理client端发送的消息}};// 定义一个Messenger&＃xff0c;Messenger中的mTarget即为mHandler中的mMessengerprivate final Messenger mMessenger &＃61; new Messenger(mHandler);&＃64;Overridepublic IBinder onBind(Intent intent) {// 返回mHandler中的mMessengerreturn mMessenger.getBinder();}
}

Client端实现&＃xff08;MessengerTest.java&＃xff09;&＃xff1a;

　　通过 bindService 与MessengerService建立连接&＃xff0c;连接完成后&＃xff0c;对Messenger进行初始化&＃xff1a;

private ServiceConnection mConnection &＃61; new ServiceConnection() {public void onServiceConnected(ComponentName name, IBinder service) {synchronized (MessengerTest.this) {// 通过IBinder类型的service对Messenger中的mTarget进行初始化mServiceMessenger &＃61; new Messenger(service);MessengerTest.this.notifyAll();}}public void onServiceDisconnected(ComponentName name) {// service断开后&＃xff0c;对应的messenger也不会再有作用mServiceMessenger &＃61; null;}
};

　　因此&＃xff0c;这样初始化后&＃xff0c;下面的几个变量就可以看做是同一个对象的引用&＃xff0c;即&＃xff1a;
　　MessengerTest.mServiceMessenger.mTarget
　　　　&＃61; MessengerService.mMessenger.mTarget
　　　　&＃61; MessengerService.mHandler.mMessenger

Messenger小结&＃xff1a;

　　实质上是通过IMessenger利用Binder机制进行消息的发送。Handler中实现了IMessenger中的 send 函数&＃xff0c;并在其中调用Handler自身的 sendMessage 函数进行消息处理&＃xff1b;Service中可以定义自己的Handler和对应的Messenger&＃xff0c;并在onBind时返回Handler中MessengerImpl的实例&＃xff0c;Client端在 onServiceConnected 函数中通过IBinder对象对Client中Messenger进行初始化&＃xff0c;之后&＃xff0c;Client端就可以通过该Messenger将消息发送到Service中的Handler进行处理了。Client和Service间通过Messenger进行消息传递的大致流程如下图&＃xff1a;

AsyncChannel成员常量和变量

注明&＃xff1a;从分析AsyncChannel开始&＃xff0c;我们称连接的首次发起端为"source端"&＃xff0c;被连接端为"destination端"

连接指令相关静态常量&＃xff1a;

/** AsyncChannel消息码在系统中的唯一开始标志 */
private static final int BASE &＃61; Protocol.BASE_SYSTEM_ASYNC_CHANNEL;/** 单向连接建立后&＃xff0c;AsyncChannel通知source端半连接已建立&＃xff0c;可以进行单向通信&＃xff0c;但此时destination端是完全没有感知的 */
public static final int CMD_CHANNEL_HALF_CONNECTED &＃61; BASE &＃43; 0;/** source端在半连接建立后&＃xff0c;发送该消息码给destination端&＃xff0c;请求建立双向连接 */
public static final int CMD_CHANNEL_FULL_CONNECTION &＃61; BASE &＃43; 1;/** destination端在建立双向连接后&＃xff0c;发送该消息码给source端&＃xff0c;告知双向连接建立完成 */
public static final int CMD_CHANNEL_FULLY_CONNECTED &＃61; BASE &＃43; 2;/** source或者destination主动请求断开 */
public static final int CMD_CHANNEL_DISCONNECT &＃61; BASE &＃43; 3;/** 在一端主动断开后&＃xff0c;对端会收到该消息码 */
public static final int CMD_CHANNEL_DISCONNECTED &＃61; BASE &＃43; 4;

连接和消息状态相关静态常量&＃xff1a;

/** 连接状态相关&＃xff1a;成功半连接&＃xff0c;成功连接&＃xff0c;成功断开 */
public static final int STATUS_SUCCESSFUL &＃61; 0;/** 跨service连接&＃xff0c;bindService成功或者失败 */
public static final int STATUS_BINDING_UNSUCCESSFUL &＃61; 1;/** 消息发送失败 */
public static final int STATUS_SEND_UNSUCCESSFUL &＃61; 2;/** 已建立双向连接&＃xff0c;拒绝再次连接 */
public static final int STATUS_FULL_CONNECTION_REFUSED_ALREADY_CONNECTED &＃61; 3;/** 跨service连接&＃xff0c;对端service死亡&＃xff0c;binderDied返回后发送该状态码 */
public static final int STATUS_REMOTE_DISCONNECTION &＃61; 4;

主要成员变量&＃xff1a;

/** ServiceConnection&＃xff0c;用于和service或remote service建立连接 */
private AsyncChannelConnection mConnection;/** 连接建立端Context&＃xff0c;仅用于bind/unbind service时使用 */
private Context mSrcContext;/** binderDied回调监听&＃xff0c;仅用于与service连接后使用 */
private DeathMonitor mDeathMonitor;/** 连接建立端Handler */
private Handler mSrcHandler;/** 连接建立端Messenger */
private Messenger mSrcMessenger;/** 连接对端Messenger */
private Messenger mDstMessenger;

AsyncChannel连接过程 - 半连接&＃xff08;Half Connect&＃xff09;

Source端发起连接请求&＃xff1a;

/** 发起连接 */
public void connect(Context srcContext, Handler srcHandler, Messenger dstMessenger) {// source端AsyncChannel变量初始化connected(srcContext, srcHandler, dstMessenger);// 发送"CMD_CHANNEL_HALF_CONNECTED"告知source端半连接已建立replyHalfConnected(STATUS_SUCCESSFUL);
}

/** 初始化source端的成员变量&＃xff0c;创建source端Messenger */
public void connected(Context srcContext, Handler srcHandler, Messenger dstMessenger) {// Initialize source fieldsmSrcContext &＃61; srcContext;mSrcHandler &＃61; srcHandler;mSrcMessenger &＃61; new Messenger(mSrcHandler);// Initialize destination fieldsmDstMessenger &＃61; dstMessenger; linkToDeathMonitor();
}

/** 发送"CMD_CHANNEL_HALF_CONNECTED"告知source端半连接已建立 */
private void replyHalfConnected(int status) {Message msg &＃61; mSrcHandler.obtainMessage(CMD_CHANNEL_HALF_CONNECTED);msg.arg1 &＃61; status;msg.obj &＃61; this;msg.replyTo &＃61; mDstMessenger;if (!linkToDeathMonitor()) {// Override status to indicate failuremsg.arg1 &＃61; STATUS_BINDING_UNSUCCESSFUL;}mSrcHandler.sendMessage(msg);
}

半连接小结&＃xff1a;

　　整个半连接过程由连接发起端&＃xff08;source端&＃xff09;完成&＃xff0c;destination端没有任何消息告知。source端调用AsyncChannel的 connect 函数后&＃xff0c;开始对AsyncChannel中变量的初始化&＃xff0c;主要是对mDstMessenger的初始化。完成后source端Handler会收到 “CMD_CHANNEL_HALF_CONNECTED” 的消息告知半连接已经完成&＃xff0c;之后&＃xff0c;source端就可以通过该AsyncChannel与destination进行通信。这种通信方式是单向的&＃xff0c;只能由source端主动向destination推送消息并获取其回复&＃xff0c;destination无法主动向source推送消息。这个连接过程可以由下面的时序图来表示&＃xff1a;

AsyncChannel连接过程 - 全连接&＃xff08;Full Connect&＃xff09;

AsyncChannel的全连接建立主要有以下两种方式&＃xff1a;

• 在半连接的基础上由source端发送 “CMD_CHANNEL_FULL_CONNECTION” 请求全连接
• source端直接调用AsyncChannel的 fullyConnectSync 进行全连接

下面对这两种全连接建立方式分别作解析。

方式一&＃xff08;在半连接的基础上由source端发送 “CMD_CHANNEL_FULL_CONNECTION” 请求全连接&＃xff09;&＃xff1a;

　　这个过程主要是由AsyncChannel使用者自己完成&＃xff0c;我们以ConnectivityService与NetworkAgent之间的通信进行举例&＃xff0c;例子的关键源码路径如下&＃xff1a;
- frameworks/base/services/core/java/com/android/server/ConnectivityService.java
- frameworks/base/services/core/java/com/android/server/connectivity/NetworkAgentInfo.java
- frameworks/base/core/java/android/net/NetworkAgent.java

　　首先&＃xff0c;ConnectivityService作为连接主动端主动请求半连接&＃xff1a;

/** ConnectivityService#handleRegisterNetworkAgent */
private void handleRegisterNetworkAgent(NetworkAgentInfo na) {// ...// 通过NetworkAgentInfo中新创建的AsyncChannel主动请求连接// mTrackerHandler是ConnectivityService中的Handler&＃xff0c;作为source handler// na.messenger是连接的对端&＃xff0c;这里就是指 NetworkAgentna.asyncChannel.connect(mContext, mTrackerHandler, na.messenger);// ..
}

　　通过对半连接的了解&＃xff0c;在 connect 之后&＃xff0c;source handler就会收到 “CMD_CHANNEL_HALF_CONNECTED”。由于需要建立全连接&＃xff0c;ConnectivityService在收到该消息后&＃xff0c;立刻向半连接对端请求全连接&＃xff1a;

/** ConnectivityService#NetworkStateTrackerHandler */
private class NetworkStateTrackerHandler extends Handler {// ...private boolean maybeHandleAsyncChannelMessage(Message msg) {switch (msg.what) {case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED: {// 收到 "CMD_CHANNEL_HALF_CONNECTED"&＃xff0c;在下面的函数中处理handleAsyncChannelHalfConnect(msg);break;}// ...
}/** ConnectivityService#handleAsyncChannelHalfConnect */
private void handleAsyncChannelHalfConnect(Message msg) {// ...else if (mNetworkAgentInfos.containsKey(msg.replyTo)) {if (msg.arg1 &＃61;&＃61; AsyncChannel.STATUS_SUCCESSFUL) {if (VDBG) log("NetworkAgent connected");// 发送全连接请求 "CMD_CHANNEL_FULL_CONNECTION"mNetworkAgentInfos.get(msg.replyTo).asyncChannel.sendMessage(AsyncChannel.CMD_CHANNEL_FULL_CONNECTION);}
}

　　NetworkAgent在收到 “CMD_CHANNEL_FULL_CONNECTION” 请求后&＃xff0c;便开始创建自己的AsyncChannel&＃xff0c;并完成其初始化&＃xff0c;连接的对端是ConnectivityService&＃xff1a;

/** NetworkAgent#handleMessage */
public void handleMessage(Message msg) {switch (msg.what) {// 收到由ConnectivityService发来的全连接请求case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION: {if (mAsyncChannel !&＃61; null) {log("Received new connection while already connected!");} else {if (VDBG) log("NetworkAgent fully connected");// 创建自己的AsyncChannelAsyncChannel ac &＃61; new AsyncChannel();// msg.replayTo 就是NetworkAgentInfo.asyncChannel中的mSrcMessenger,// 消息的处理者就是ConnectivityService.mTrackerHandlerac.connected(null, this, msg.replyTo);// 全连接已经建立&＃xff0c;发送 "CMD_CHANNEL_FULLY_CONNECTED" 给ConnectivityServiceac.replyToMessage(msg, AsyncChannel.CMD_CHANNEL_FULLY_CONNECTED,AsyncChannel.STATUS_SUCCESSFUL);// ...}break;// ...
}

　　从上述的过程可以看出&＃xff0c;建立全连接的方式就是连接的两端都需要创建自己的AsyncChannel&＃xff0c;并且每个AsyncChannel中都保存着对端的Messenger。这种全连接的方式可以通过下面流程图进行表示&＃xff1a;

方式二&＃xff1a;source端直接调用AsyncChannel的 fullyConnectSync 进行全连接

　　从 fullyConnectSync 这个函数名&＃xff0c;可以知道这是一个同步的操作&＃xff0c;AsyncChannel中使用了SyncMessenger这个静态内部类来实现这个同步连接的操作。直接从 fullyConnectSync 这个函数开始分析。

　　fullyConnectSync 中对source端AsyncChannel进行了初始化&＃xff0c;并发送 “CMD_CHANNEL_FULL_CONNECTION” 同步消息请求全连接&＃xff1a;

/** AsyncChannel#fullyConnectSync*/
public int fullyConnectSync(Context srcContext, Handler srcHandler, Handler dstHandler) {// 只是调用了connected函数&＃xff0c;对source端AsyncChannel成员变量进行初始化int status &＃61; connectSync(srcContext, srcHandler, dstHandler);if (status &＃61;&＃61; STATUS_SUCCESSFUL) {// 发送"CMD_CHANNEL_FULL_CONNECTION"同步消息给destination// 同步消息&＃xff0c;需要等待回应后才继续Message response &＃61; sendMessageSynchronously(CMD_CHANNEL_FULL_CONNECTION);status &＃61; response.arg1;}return status;
}

　　sendMessageSynchronously 实际使用的是 “SyncMessenger.sendMessageSynchronously”&＃xff1a;

/** AsyncChannel.SyncMessenger#sendMessageSynchronously*/
private static Message sendMessageSynchronously(Messenger dstMessenger, Message msg) {// 获取一个SyncMessenger对象&＃xff0c;启动消息接收者SyncHandlerSyncMessenger sm &＃61; SyncMessenger.obtain();try {if (dstMessenger !&＃61; null && msg !&＃61; null) {msg.replyTo &＃61; sm.mMessenger;// 获取对象锁&＃xff1a;"sm.mHandler.mLockObject"synchronized (sm.mHandler.mLockObject) {// 发送 "CMD_CHANNEL_FULL_CONNECTION"dstMessenger.send(msg);// 释放该锁并中断等待notifysm.mHandler.mLockObject.wait();}} else {sm.mHandler.mResultMsg &＃61; null;}} catch (InterruptedException e) {sm.mHandler.mResultMsg &＃61; null;} catch (RemoteException e) {sm.mHandler.mResultMsg &＃61; null;}// 被CPU唤醒&＃xff0c;消息回复已经收到&＃xff0c;返回该回复Message resultMsg &＃61; sm.mHandler.mResultMsg;sm.recycle();return resultMsg;
}

　　通过SyncMessenger向对端发送完消息后&＃xff0c;对端如果已经完成了 connect 的操作或者拒绝连接&＃xff0c;都应该回复消息。由于发送消息前设定了msg.replyTo &＃61; sm.mMessenger&＃xff0c;因此回复的消息会被SyncManager中的SyncHandler处理&＃xff1a;

/** AsyncChannel.SyncManager#SyncHandler#handleMessage*/
public void handleMessage(Message msg) {mResultMsg &＃61; Message.obtain();mResultMsg.copyFrom(msg);// 获取mLockObject对象锁synchronized(mLockObject) {// 唤醒在mLockObject这个锁上等待的线程mLockObject.notify();}
}

　　从上面的流程可以看出&＃xff0c;通过 fullyConnectSync 建立全连接省略了中间 “CMD_CHANNEL_HALF_CONNECTED” 消息回复过程&＃xff0c;并且通过SyncMessenger&＃xff0c;实现了在对端完成connect操作后才返回。因此&＃xff0c;这个过程不需要AsyncChannel的主动连接者进行其他操作就可以完成全连接。然而&＃xff0c;AsyncChannel的对端依然需要处理 “CMD_CHANNEL_FULL_CONNECTION”。整个过程的大致流程图如下&＃xff1a;

AsyncChannel的跨进程消息传递

　　由于AsyncChannel内部使用的是Messenger&＃xff0c;且Handler和Messenger都已经支持了Binder通信方式&＃xff0c;因此&＃xff0c;AsyncChannel同样可以利用在跨进程通信上。
　　前文在介绍Messenger时&＃xff0c;通过例子”MessengerService”对Messenger做了解析&＃xff0c;AsyncChannel在跨进程通信上与前文例子相似&＃xff1a;在连接前&＃xff0c;需要先bindService&＃xff0c;在 onServiceConnected 时&＃xff0c;拿到Service的Messenger并完成了对mDstMessenger的初始化&＃xff0c;从而实现了半连接。之后&＃xff0c;全连接的方式就与前文介绍的相同。

/** AsyncChannel#connect*/
public void connect(Context srcContext, Handler srcHandler, String dstPackageName,String dstClassName) {// 由于有bindService操作&＃xff0c;并且需要等待onServiceConnected回调&＃xff0c;// 因此实现了一个Runnable并且新开一个线程去完成这个操作final class ConnectAsync implements Runnable {// ...&＃64;Overridepublic void run() {// 完成对AsyncChannel中除mDstMessenger的成员变量的初始化// 并执行bindService操作int result &＃61; connectSrcHandlerToPackageSync(mSrcCtx, mSrcHdlr, mDstPackageName,mDstClassName);replyHalfConnected(result);}}ConnectAsync ca &＃61; new ConnectAsync(srcContext, srcHandler, dstPackageName, dstClassName);// 新开一个线程执行异步连接操作new Thread(ca).start();
}

　　connectSrcHandlerToPackageSync 完成了对AsyncChannel中基本成员变量的初始化&＃xff0c;与destination相关的mDstMessenger变量需要等待 onServiceConnected 回调后再进行初始化&＃xff1a;

/** AsyncChannel#connectSrcHandlerToPackageSync */
public int connectSrcHandlerToPackageSync(Context srcContext, Handler srcHandler, String dstPackageName, String dstClassName) {mConnection &＃61; new AsyncChannelConnection();/* 初始化AsyncChannel source相关的变量 */mSrcContext &＃61; srcContext;mSrcHandler &＃61; srcHandler;mSrcMessenger &＃61; new Messenger(srcHandler);// 对端Messenger等待onServiceConnected后再进行初始化mDstMessenger &＃61; null;// bindServiceIntent intent &＃61; new Intent(Intent.ACTION_MAIN);intent.setClassName(dstPackageName, dstClassName);boolean result &＃61; srcContext.bindService(intent, mConnection, Context.BIND_AUTO_CREATE);return result ? STATUS_SUCCESSFUL : STATUS_BINDING_UNSUCCESSFUL;
}

　　AsyncChannelConnection#onServiceConnected 会在Service bind成功后被回调&＃xff0c;在这个函数中&＃xff0c;完成了对 mDstMessenger 的初始化&＃xff0c;到此&＃xff0c;半连接完成&＃xff1a;

/** AsyncChannel#AsyncChannelConnection */
class AsyncChannelConnection implements ServiceConnection {AsyncChannelConnection() {}&＃64;Overridepublic void onServiceConnected(ComponentName className, IBinder service) {// service bind成功&＃xff0c;初始化mDstMessengermDstMessenger &＃61; new Messenger(service);replyHalfConnected(STATUS_SUCCESSFUL);}// ...
}

　　跨进程或同进程Service的AsyncChannel连接与普通的相同&＃xff0c;只不过多了一步bindService的操作&＃xff0c;并且mDstMessenger 需要等待 onServiceConnected 回调后才能完成初始化。

总结

　　AsyncChannel 结合Messenger&＃xff0c;实现了两个进程或线程间Handler消息的传递。这篇文章主要介绍了Messenger的原理、AsyncChannel的两种连接方式&＃xff1a;半连接和全连接、AsyncChannel跨进程连接等&＃xff0c;虽然这个工具类无法直接使用&＃xff0c;但如果应用中有需要&＃xff0c;仍然可以借鉴其原理作适合的简单实现。