AsyncChannel的使用和原理（原）
本文主要介绍AsyncChannel的使用和内部原理。
一、AsyncChannel概述
AsyncChannel在Wifi的处理机制中被大量使用，但是可惜的是该工具是一个internal的方法，没有开放给第三方应用使用，但是该工具提供的思路很有用，可以被扩展到任意两个Handle间传输数据的通道。
那么AsyncChannel究竟是什么工具呢？他的内部机制又是怎么样呢？我们先来看一下AsyncChannel的官方描述：
* <p>An asynchronous channel between two handlers.</p>
* <p>The handlers maybe in the same process or in another process. There
* are two protocol styles that can be used with an AysncChannel. The
* first is a simple request/reply protocol where the server does
* not need to know which client is issuing the request.</p>
* <p>In a simple request/reply protocol the client/source sends requests to the
* server/destination. And the server uses the replyToMessage methods.
* In this usage model there is no need for the destination to
* use the connect methods. The typical sequence of operations is:</p>
* <p>A second usage model is where the server/destination needs to know
* which client it's connected too. For example the server needs to
* send unsolicited messages back to the client. Or the server keeps
* different state for each client. In this model the server will also
* use the connect methods. The typical sequence of operation is:</p> 以上是AsyncChannel文件头的描述，从这三段描述中我们可以大致知道AsyncChannel的作用、特点以及用法。
1.1、作用
AsyncChannel在两个Handler间搭建了通道，可以用于消息传输。
1.2、特点
从上面第一段英文描述可以知道AsyncChannel的两个特点：
1、AsyncChannel可以作为Handler之间的通道。2、这两个Handler可以处于同一个进程，也可以不再同一个进程。
1.3、两种工作模式
第二段和第三段英文分别描述了AsyncChannel的两种工作模式：
1、单项通道模式，在该模式下，客户端只能向服务端发起请求，服务端给出回应。2、双向通道模式，在该模式下，客户端和服务端同时连接上AsyncChannel，客户端可以向服务端发送请求，服务端也可以向客户端发送请求。
下面我们分别来介绍这两种模式的使用方法。
二、AsyncChannel通道使用方法
为了进行测试，我搭建了一个Demo程序用于测试相关功能，源码可以这里下载。由于AsyncChannel是internal的工具，因此该Demo必须要在ROM源码环境下编译并具备系统签名。
在这个Demo中，只有三个文件：MainActivity、AsyncChannelClient、AsyncChannelService、AsyncChannelServiceFull四个文件，其作用分别是：MainActivity
----负责界面搭建，里面包含：“初始化客户端和服务端并依次建立单向通道和双向通道”、“初始化客户端和服务端并直接建立双向通道”、“发送异步信息”、“发送同步信息”等四个按钮。
AsyncChannelClient
----作为客户端，向服务端发送请求。
AsyncChannelService
----作为服务端，接受客户端请求。
AsyncChannelServiceFull
----作为服务端，用于接受快速双向通道的请求。
下面来看AsyncChannel的具体使用。
2.1、单向通道建立方法
在这个Demo中，当点击“初始化客户端和服务端并依次建立单向通道和双向通道”后，就会先后启动服务端和客户端，当客户端的Server启动(onStartCommand)时，就会与服务端建立单项通道。
我们先来看点击动作的处理： @MainActivity.java
public void onClick(View view) {
switch (view.getId()) {
case R.id.start_service_btn: {
// 启动客户端和服务端
Intent intent = new Intent();
intent.setComponent(new ComponentName(this, AsyncChannelService.class));
startService(intent);
Intent inte = new Intent();
inte.setComponent(new ComponentName(this, AsyncChannelClient.class));
//Action是"Normal"
inte.setAction("Normal");
startService(inte);
break;
}
}
} 然后我们来看客户端的 初始化流程：
@AsyncChannelClient.java
public static AsyncChannel sClientAsyncChannel;
public int onStartCommand(Intent intent, int flags, int startId) {
//创建本地的Handler对象
HandlerThread handlerThread = new HandlerThread("ClientThread");
handlerThread.start();
Handler clientHandler = new ClientHandler(handlerThread.getLooper());
//创建客户端的AsyncChannel
sClientAsyncChannel = new AsyncChannel();
String act = intent.getAction();
//我们发送的Action就是"Normal"
if ("Normal".equals(act)) {
// 建立单向通道，获取服务端的Messenger对象
Messenger serviceMessenger = AsyncChannelService.getServiceMessenger();
//发起连接请求
sClientAsyncChannel.connect(this, clientHandler, serviceMessenger);
} else if ("Fast".equals(act)) {
}
return super.onStartCommand(intent, flags, startId);
} 上面的过程中，通过客户端的getServiceMessenger()方法
拿到服务端的Messenger对象，其过程是：
@AsyncChannelService.java
public static Messenger getServiceMessenger() {
//服务端需要用自己的Handler构建Messenger然后发送给客户端
return new Messenger(mServiceHandler);
} 以上就是客户端所做的全部准备，以及发起创建通道的请求过程。从这个过程中我们看到，作为客户端，如果想要创建与服务端之间的AsyncChannel，需要做以下几个准备：
1、获取服务端的Messenger对象，该对象其实就是利用服务端的Handler构建的Messenger；
2、创建客户端自己的Handler对象；
3、创建AsyncChannel对象；
4、通过AsyncChannel对象，连接当前的Handler和服务端的Messenger，从而申请连接。
当客户端发送完connect()请求之后，客户端需要做的就是在Handler对象中等待Message消息：
@AsyncChannelClient.java
public void handleMessage(Message message) {
switch (message.what) {
case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED: {
if (msg.arg1 == AsyncChannel.STATUS_SUCCESSFUL) {
Log.d(tag, "Service half connected");
}
break;
}
}
}
当客户端接收到AsyncChannel.CMD_CHANNEL_HALF_CONNECTED消息后，说明当前的单项通道建立成功。此时的客户端可以通过sAsyncChannel的sendMessage()方法向服务端发送消息了。
以上就是单项通道的建立过程，整个过程不需要服务端做任何操作。
2.2、双向通道建立方法
那么如果客户端想要创建双向通道，该如何操作呢？
首先，服务端本身需要初始化Handler，并且如果服务端准备提供双向通道，那么就需要创建自己的AsyncChannel对象。这些工作需要在客户端初始化时完成： @AsyncChannelService.java
public int onStartCommand(Intent intent, int flags, int startId) {
//初始化Handler
HandlerThread handlerThread = new HandlerThread("ServiceThread");
handlerThread.start();
mServiceHandler = new ServiceHandler(handlerThread.getLooper());
//创建AsyncChannel对象
sServiceAsyncChannel = new AsyncChannel();
return super.onStartCommand(intent, flags, startId);
} 其实
双向通道是在单项通道基础上完成的，当客户端与服务端的单项通道创建完成后，也就是
当客户端收到AsyncChannel.CMD_CHANNEL_HALF_CONNECTED之后，可以向AsyncChannel对象发送CMD_CHANNEL_FULL_CONNECTION消息申请建立双向通道。
也就是在刚才接收到的消息基础上，发送CMD_CHANNEL_FULL_CONNECTION请求即可：
@AsyncChannelClient.java
public void handleMessage(Message message) {
switch (message.what) {
case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED:
if (message.arg1 == AsyncChannel.STATUS_SUCCESSFUL) {
//客户端单项通道建立完成，继续申请双向通道
sClientAsyncChannel.sendMessage(AsyncChannel.CMD_CHANNEL_FULL_CONNECTION);
}
break;
}
} 此时的服务端将会在Handler中接收到如下消息：
@AsyncChannelService.java
public void handleMessage(Message msg) {
switch ((msg.what)) {
case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION: {
//服务端接收到双向通道的建立请求
//如果同意客户端建立，则需要服务端向AsyncChannel申请连接请求
sServiceAsyncChannel.connect(AsyncChannelService.this, mServiceHandler, msg.replyTo);
break;
}
}
} 从上面代码看到，当客户端发起双向通道建立请求时，服务端将会收到AysncChannel.CMD_CHANNEL_FULL_CONNECTION的请求，此时的服务端如果同意建立双向通道，则使用自己的AsyncChannel对象将自己的Handler与客户端的Handler连接起来。
至此，双向通道建立完成，此时不仅客户端可以通过自己的AsyncChannel对象向服务端发送请求，服务端也可以通过自己的AsyncChannel对象向客户端发送请求。
以上就是双向通道的建立过程。
2.3、更有效的双向通道建立方法
上一节中介绍了双向通道的建立方法，其实这是一种“笨方法”，为什么这么说呢？我们来看一下要创建双向通道需要经过哪些步骤：
1、客户端发起connect()请求，申请建立单向通道；2、客户端接收到CMD_CHANNEL_HALF_CONNECTED，然后继续向AsyncChannel申请双向通道；
3、服务端接收到CMD_CHANNEL_FULL_CONNECTION申请，向AsyncChannel发送连接请求；
这就需要三个步骤才可以完成双向通道建立，并且最重要的是， 客户端始终不知道服务端是否真正连接上了AsyncChannel(如果客户端想知道结果，还需要服务端再次发送一次确认消息)。
那么有没有一种方法，在客户端创建通道时就指定要创建双向通道呢？
这就用上 fullyConnectSync()方法。通过该方法，客户端只需要一次就可以申请到双向通道，并且可以知道通道是否建立成功。
下面来看代码实现，当点击界面上“初始化客户端与服务端并快速建立双向通道”按钮后，将会触发客户端双向通道的申请：
@MainActivity.java
public void onClick(View view) {
switch (view.getId()) {
case R.id.start_service_fast_connect_btn: {
Intent intent = new Intent();
intent.setComponent(new ComponentName(this, AsyncChannelServiceFull.class));
startService(intent);
Intent inte = new Intent();
inte.setComponent(new ComponentName(this, AsyncChannelClient.class));
inte.setAction("Fast");
startService(inte);
break;
}
}
} 此时将会先后启动AsyncChannelServiceFull和AsyncChannelClient服务，并且发送的Action为“Fast”。
我们先来看AsyncChannelServiceFull服务的初始化流程：
@AsyncChannelServiceFull.java
public int onStartCommand(Intent intent, int flags, int startId) {
//初始化Handler对象
HandlerThread handlerThread = new HandlerThread("ServiceThread");
handlerThread.start();
mServiceHandler = new ServiceHandler(handlerThread.getLooper());
//创建AsyncChannel对象
sServiceAsyncChannel = new AsyncChannel();
return super.onStartCommand(intent, flags, startId);
} 然后来看AsyncChannelClient的操作：
@AsyncChannelClient.java
public int onStartCommand(Intent intent, int flags, int startId) {
//初始化Handler对象
HandlerThread handlerThread = new HandlerThread("ClientThread");
handlerThread.start();
Handler clientHandler = new ClientHandler(handlerThread.getLooper());
//创建AsyncChannel对象
sClientAsyncChannel = new AsyncChannel();
String act = intent.getAction();
if ("Normal".equals(act)) {
} else if ("Fast".equals(act)) {//此时的Action是"Fast"
// 要求直接双向通道
Handler serviceHandler = AsyncChannelServiceFull.getServiceHandler();
int result = sClientAsyncChannel.fullyConnectSync(this, clientHandler, serviceHandler);
if (AsyncChannel.STATUS_SUCCESSFUL == result) {
Log.d(tag, "client full connected");
}
}
return super.onStartCommand(intent, flags, startId);
} 这与单项通道的建立操作几乎完全一样，唯一不同的地方有三个：
1、客户端不再使用connect()方法连接AsyncChannel，而是使用fullyConnectSync()方法建立双向通道；
2、调用fullyConnectSync()建立通道时，使用的是服务端的Handler对象(serviceHandler)而不是Messenger对象；
3、调用fullyConnectSync()建立通道时，此方法有个返回值，可以明确知道通道是否建立成功；
接下来我们看此时的服务端的流程。
当客户端通过fullyConnectSync()申请双向通道时，服务端就可以收到CMD_CHANNEL_FULL_CONNECTION的消息，然后服务端需要连接上AsyncChannel后回复成功的命令即可完成通道的建立：
@AsyncChannelServiceFull.java
public void handleMessage(Message msg) {
switch (msg.what) {
case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION: {
//收到双向通道建立请求，如果服务端同意，则需要连接上AsyncChannel，然后恢复STATUS_SUCCESSFUL即可
sServiceAsyncChannel.connect(AsyncChannelServiceFull.this, mServiceHandler, msg.replyTo);
//将建立结果传递给客户端
sServiceAsyncChannel.replyToMessage(msg, AsyncChannel.CMD_CHANNEL_FULLY_CONNECTED, AsyncChannel.STATUS_SUCCESSFUL);
break;
}
}
} 经过上面服务端的操作，客户端就在fullyConnectSync()返回值中获取到通道建立成功的消息，至此双向通道建立完毕。
从这个过程中我们看到该方式更加方便和有效， 他省掉了客户端CMD_CHANNEL_HALF_CONNECTED的请求过程，而且客户端可以知道通道的建立结果。这也是官方推荐的做法。
以上就是快速双向通道的建立过程。
三、消息的使用
我们建立通道的最终目的是为了在两个Handler间传输信息，而消息又分为两类：异步消息和同步消息，接下来分别介绍这两种消息的使用方法。
3.1、异步消息使用方法
所谓异步消息，就是客户端(或服务端)发送消息之后在Handler中等待回应，而不是立刻拿到消息结果。无论是客户端或者是双向通道中的服务端，都可以通过自己的AsyncChannel对象向对方发送异步消息。
在该Demo中，当点击界面上的“发送异步信息”按钮时，就会在客户端中向服务端发送一个MainActivity.MSG_ASYNC_REQ的请求，接下来在Server端的handleMessage中就能收到该请求，我们在Server收到该请求后，创建一个MSG_SYNC_REPLY的消息，并在其中放入一个字串“ServiceAsyncReply”返回给客户端，接下来客户端就可以在自己的handleMessage中检测到该回应，最终我们在客户端的handleMessage中把该字串打印出来。接下来看具体的代码：
当点击“客户端发送异步消息”的按钮时，进入客户端的sendMsgToService()方法中：
@AsyncChannelClient.java
public static void sendMsgToService() {
// 客户端用AsyncChannel给服务端发送MSG_ASYNC_REQ的请求
sClientAsyncChannel.sendMessage(MainActivity.MSG_ASYNC_REQ);
} 接下来就会在服务端的handleMessage中接收到该请求：
@AsyncChannelService.java
public void handleMessage(Message msg) {
switch (msg.what) {
case MainActivity.MSG_ASYNC_REQ: {
//接收到客户端请求
Message reply = msg.obtain();
reply.what = MainActivity.MSG_ASYNC_REPLY;
reply.obj = "ServiceAsyncReply";
try {
//给客户端发送回应，回应的内容中what=MSG_ASYNC_REPLY，obj="ServiceAsyncReply"
msg.replyTo.send(reply);
} catch (RemoteException e) {
}
break;
}
} 然后客户端就会收到MSG_ASYNC_REPLY的回应：
@AsyncChannelClient.java
public void handleMessage(Message message) {
switch (message.what) {
case MainActivity.MSG_ASYNC_REPLY: {
//收到服务端回应，并将服务端放入的字串打印出来，异步消息结束
String msg = (String) message.obj;
Log.d(tag, "get service async reply msg = " + msg);
break;
}
}
}
至此就完成了整个异步消息的调用。
3.2、同步消息使用方法
从上面的异步消息看到，无论是客户端发送消息还是服务端返回消息，都是异步的，都需要在发送完毕后被动等待消息结果，而同步消息就是客户端(或服务端)发送消息之后可以直接拿到返回值。
接下来我们通过Demo来演示同步消息的使用方法。在该Demo中，当点击“发送同步信息”按钮后，客户端将会给服务端发送一个“MSG_SYNC_REQ”的同步消息，然后等待返回值，此时的Server端将会收到该消息，等服务端处理完毕后通过replyToMessage()返回后，客户端就收到了返回值，整个过程对于客户端来说，是同步的，也就是说调用后立刻拿到了消息回应。
我们先来看客户端发送同步信息的方式：
@AsyncChannelClient.java
public static void sendSyncMsgToService() {
Message replyMsg = sClientAsyncChannel.sendMessageSynchronously(MainActivity.MSG_SYNC_REQ);
String msg = (String) replyMsg.obj;
Log.d(tag, "get service sync reply msg = " + msg);
} 从这里的发送过程就可以看出，对于发送端来说，“好像”发送完请求后，立刻得到了消息。当调用AsyncChannel的sendMessageSynchronously()方法后，服务端将会接收到该消息，并进行消息处理：
@AsyncChannelService.java
public void handleMessage(Message msg) {
switch (msg.what) {
case MainActivity.MSG_SYNC_REQ: {
//服务端接收到同步消息请求
Message reply = msg.obtain();
reply.what = MainActivity.MSG_SYNC_REPLY;
reply.obj = "ServiceSyncReply";
//将返回值发送给客户端
sServiceAsyncChannel.replyToMessage(msg, reply);
break;
}
}
} 从服务端消息处理可以看到，服务端接收到MSG_SYNC_REQ请求后，包装了一个reply的Message对象，然后通过服务端的AsyncChannel对象将该消息返回给消息的发送者。然后客户端就收到了服务端的回应。
这就是同步消息的使用方法。
四、AsyncChannel通道的内部机制
以上通过Demo介绍了AsyncChannel的使用方法，接下来我们介绍AsyncChannel的内部原理。
4.1、单向通道的建立过程
从前面介绍的通道使用方法来看，第一种双向通道是在单向通道基础上搭建的，我们先来看单项通道的建立过程。
从通道的建立方法可以知道，创建通道需要三个步骤：1、准备服务端的Messenger对象；
2、创建本地的Handler对象；
3、创建AsyncChannel对象，然后调用connect()方法。
其中前两个条件容易满足，下面我们主要分析AsyncChannel的创建过程和connect()方法。
我们先来看一下AsyncChannel的属性：
public class AsyncChannel {} 发现他没有父类，然后看他的构造方法：
@AsyncChannel.java
public AsyncChannel() {
} 构造方法里面也没有任何操作。然后来看connect()方法：
public void connect(Context srcContext, Handler srcHandler, Messenger dstMessenger) {
connected(srcContext, srcHandler, dstMessenger);
replyHalfConnected(STATUS_SUCCESSFUL);
} 这里面有两个调用，我们先来看第一个connected()方法：
public void connected(Context srcContext, Handler srcHandler, Messenger dstMessenger) {
//初始化一些变量
mSrcContext = srcContext;
mSrcHandler = srcHandler;
mSrcMessenger = new Messenger(mSrcHandler);
mDstMessenger = dstMessenger;
} 在这里只是初始化一些变量，我们记得在使用AsyncChannel时，传递了本地的Handler对象和目标的Messenger对象，在这里用本地的Handler对象创建Messenger对象，也就是说，
在AsyncChannel中，拥有了本地和远端的Messenger对象，分别标记mSrcMessenger和mDeathMonitor。
然后我们接着看connect()中的第二个方法：
private void replyHalfConnected(int status) {
//准备CMD_CHANNEL_HALF_CONNECTED消息
Message msg = mSrcHandler.obtainMessage(CMD_CHANNEL_HALF_CONNECTED);
msg.arg1 = status;
msg.obj = this;
msg.replyTo = mDstMessenger;
if (mConnection == null) {
mDeathMonitor = new DeathMonitor();
try {
//监听远端的服务是否死掉
mDstMessenger.getBinder().linkToDeath(mDeathMonitor, 0);
} catch (RemoteException e) {
mDeathMonitor = null;
msg.arg1 = STATUS_BINDING_UNSUCCESSFUL;
}
}
//将CMD_CHANNEL_HALF_CONNECTED发送给本地，也就是客户端
mSrcHandler.sendMessage(msg);
} 在这里主要完成了一件事情，也就是
向客户端发送CMD_CHANNEL_HALF_CONNECTED的消息。
然后AsyncChannel的connect()就调用结束，他的调用过程可以分为两步：
1、初始化AsyncChannel中的本地和远程的Messenger对象；
2、向本地(也就是客户端)发送CMD_CHANNEL_HALF_CONNECTED的消息；
至此，单项通道建立完毕。
该流程可以用如下图来描述：
4.2、双向通道的建立过程
下面介绍双向通道的建立过程。前面的使用方法中我们知道，双向通道的建立需要在客户端收到CMD_CHANNEL_HALF_CONNECTED消息后向AsyncChannel对象发送CMD_CHANNEL_FULL_CONNECTION消息完成的，也就是如下的入口：
public void handleMessage(Message message) {
switch (message.what) {
case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED: {
//向AsyncChannel申请双向通道
sClientAsyncChannel.sendMessage(AsyncChannel.CMD_CHANNEL_FULL_CONNECTION);
break;
}
}
} 接下来看AsyncChannel的sendMessage()过程：
@AsyncChannel.java
public void sendMessage(int what) {
Message msg = Message.obtain();
msg.what = what;
sendMessage(msg);
}
public void sendMessage(Message msg) {
msg.replyTo = mSrcMessenger;
try {
//向mDstMessenger发送消息
mDstMessenger.send(msg);
} catch (RemoteException e) {
replyDisconnected(STATUS_SEND_UNSUCCESSFUL);
}
} 从这里看到，AsyncChannel其实只做了一件事情，就是将CMD_CHANNEL_FULL_CONNECTION的消息转发给mDstMessenger，这里的mDstMessenger就是AsyncChannel被创建时初始化的AsyncChannelService中的Handler，然后服务端就收到了CMD_CHANNEL_FULL_CONNECTION的消息。
从前面的使用方法中介绍过，当服务端收到该消息后，将会通过connect()方法将自己连接上AsyncChannel：
@AsyncChannelService.java
public void handleMessage(Message msg) {
switch ((msg.what)) {
case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION: {
//服务端接收到双向通道的建立请求
//如果同意客户端建立，则需要服务端向AsyncChannel申请连接请求
sServiceAsyncChannel.connect(AsyncChannelService.this, mServiceHandler, msg.replyTo);
break;
}
}
} 然后服务端的AsyncChannel将会进入connect()中处理：
@AsyncChannel.java
public void connect(Context srcContext, Handler srcHandler, Messenger dstMessenger) {
//做同样的初始化动作
connected(srcContext, srcHandler, dstMessenger);
//然后告诉服务端CMD_CHANNEL_HALF_CONNECTED
replyHalfConnected(STATUS_SUCCESSFUL);
} 这个过程与建立单向通道时客户端所做的动作完全一致，就是初始化服务端AsyncChannel中的mSrcMessenger、mSrcHandler、mDstMessenger等对象，然后向服务端自己发送CMD_CHANNEL_HALF_CONNECTED的消息。
从这个过程来看，其实双向通道的建立过程就是在客户端和服务端分别连接(connect)上自己的AsyncChannel对象的过程。
下面就是双向通道的建立流程图：
4.3、更有效的双向通道的建立过程
下面我们来看快速双向通道的建立过程。
该过程是通过客户端使用fullyConnectSync()方法来触发的： @AsyncChannel.java
public int fullyConnectSync(Context srcContext, Handler srcHandler, Handler dstHandler) {
int status = connectSync(srcContext, srcHandler, dstHandler);
if (status == STATUS_SUCCESSFUL) {
Message response = sendMessageSynchronously(CMD_CHANNEL_FULL_CONNECTION);
status = response.arg1;
}
return status;
} 这个方法内部有两个调用，一个connectSync、一个是sendMessageSynchronously，我们先来追踪第一个：
public int connectSync(Context srcContext, Handler srcHandler, Handler dstHandler) {
return connectSync(srcContext, srcHandler, new Messenger(dstHandler));
}
public int connectSync(Context srcContext, Handler srcHandler, Messenger dstMessenger) {
connected(srcContext, srcHandler, dstMessenger);
return STATUS_SUCCESSFUL;
}
public void connected(Context srcContext, Handler srcHandler, Messenger dstMessenger) {
//初始化变量
mSrcContext = srcContext;
mSrcHandler = srcHandler;
mSrcMessenger = new Messenger(mSrcHandler);
mDstMessenger = dstMessenger;
} 整个过程的结果就是调用connected()方法，这与connect()唯一不同的就是
没有发送CMD_CHANNEL_HALF_CONNECTED消息。
然后来看sendMessageSynchronously()方法，记得此时传递的消息是CMD_CHANNEL_FULL_CONNECTION：
public Message sendMessageSynchronously(int what) {
Message msg = Message.obtain();
msg.what = what;
Message resultMsg = sendMessageSynchronously(msg);
return resultMsg;
} 继续：
public Message sendMessageSynchronously(Message msg) {
Message resultMsg = SyncMessenger.sendMessageSynchronously(mDstMessenger, msg);
return resultMsg;
} 继续：
private static Message sendMessageSynchronously(Messenger dstMessenger, Message msg) {
//创建SyncMessenger对象
SyncMessenger sm = SyncMessenger.obtain();
try {
if (dstMessenger != null && msg != null) {
//将SyncMessenger的Messenger放入消息包中
msg.replyTo = sm.mMessenger;
synchronized (sm.mHandler.mLockObject) {
//将CMD_CHANNEL_FULL_CONNECTION发送给远端的服务
dstMessenger.send(msg);
//阻塞监听唤醒
sm.mHandler.mLockObject.wait();
}
} else {
sm.mHandler.mResultMsg = null;
}
} catch (InterruptedException e) {
sm.mHandler.mResultMsg = null;
} catch (RemoteException e) {
sm.mHandler.mResultMsg = null;
}
Message resultMsg = sm.mHandler.mResultMsg;
sm.recycle();
//将结果返回给客户端
return resultMsg;
} 整个过程的核心在sendMessageSynchronously中处理，该方法中创建了一个SyncMessenger的对象，这是AsyncChannel的内部静态类，
作用就是负责同步传输消息。
那么SyncMessenger是如何同步传输消息的呢？
其原理就是当向远端的服务发送消息之后，SyncMessenger就进入阻塞状态(也就是停留在wait这里)，等待远程服务端的回应，当拿到返回消息之后，将会唤醒SyncMessenger，然后再将结果返回给客户端。
结合代码来看就是，在将消息发送给服务端之前，将当前SyncMessenger的Messenger对象作为replyTo存放在消息包中：
msg.replyTo = sm.mMessenger;然后将消息发送给服务端：
dstMessenger.send(msg);然后进入阻塞状态：
sm.mHandler.mLockObject.wait();经过这个操作，服务端就收到CMD_CHANNEL_FULL_CONNECTION的消息，并且该消息的replyTo对象是SyncMessenger，然后我们来看该SyncMessenger的唤醒过程。
在前面我们介绍过，当服务端接收到该请求后，如果同意建立双向通道，则需要connect()之后给出OK的回应，也就是：
@AsyncChannelServiceFull.java
public void handleMessage(Message msg) {
switch (msg.what) {
case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION: {
//先连接上AsyncChannel
sServiceAsyncChannel.connect(AsyncChannelServiceFull.this, mServiceHandler, msg.replyTo);
//然后给出OK的回应
sServiceAsyncChannel.replyToMessage(msg, AsyncChannel.CMD_CHANNEL_FULLY_CONNECTED, AsyncChannel.STATUS_SUCCESSFUL);
break;
}
}
} 我们通过上面回应的流程来看如何唤醒SyncMessenger，记得这里最后一个参数是STATUS_SUCCESSFUL：
@AsyncChannel.java
public void replyToMessage(Message srcMsg, int what, int arg1) {
Message msg = Message.obtain();
msg.what = what;
msg.arg1 = arg1;
replyToMessage(srcMsg, msg);
} 继续往下走：
public void replyToMessage(Message srcMsg, Message dstMsg) {
try {
dstMsg.replyTo = mSrcMessenger;
//这里的replyTo记录的就是当初的SyncMessenger的Handler对象
srcMsg.replyTo.send(dstMsg);
} catch (RemoteException e) {
log("TODO: handle replyToMessage RemoteException" + e);
e.printStackTrace();
}
} 到这里我们看到，通过replyToMessage方法，把服务端的消息发送给了Message的replyTo对象，这个对象其实就是我们当初给服务端发送CMD_CHANNEL_FULL_CONNECTION消息时放入的SyncMessenger的Handler对象，因此，此时的SyncMessenger将会收到服务端的消息：
@AsyncChannel.java
private class SyncHandler extends Handler {
public void handleMessage(Message msg) {
mResultMsg = Message.obtain();
mResultMsg.copyFrom(msg);
synchronized(mLockObject) {
//唤醒SyncMessenger
mLockObject.notify();
}
}
} 在这里，我们终于看到将SyncMessenger唤醒的操作，当该Handler被唤醒时，
sendMessageSynchronously()方法就通过wait()方法继续往下执行，然后就将服务端的消息从SyncMessenger的Handler中取出来，最终return给客户端的fullyConnectSync()调用者。
至此，双向通道的流程结束，服务端不仅连接上了通道，而且客户端拿到了服务端STATUS_SUCCESSFUL的消息。
下面用一张图来描述这个过程：
五、消息派发的机制
消息派发的机制其实在上一节的通道建立机制中简单介绍过了，因此接下来的解释就比较容易理解了。
5.1、异步消息派发过程
我们知道，异步消息的派发是通过AsyncChannel的sendMessage()来完成的：
@AsyncChannelClient.java
public static void sendMsgToService() {
sClientAsyncChannel.sendMessage(MainActivity.MSG_ASYNC_REQ);
} 然后来看AsyncChannel的sendMessage方法：
@AsyncChannel.java
public void sendMessage(int what) {
Message msg = Message.obtain();
msg.what = what;
sendMessage(msg);
}
public void sendMessage(Message msg) {
msg.replyTo = mSrcMessenger;
try {
//向mDstMessenger发送消息
mDstMessenger.send(msg);
} catch (RemoteException e) {
replyDisconnected(STATUS_SEND_UNSUCCESSFUL);
}
}
这个过程与前面4.2节中双向通道建立过程是相同的，其实就是将消息通过AsyncChannel发送给mDstMessenger，也就是远程服务端。
5.2、同步消息派发过程
同步消息的处理其实在前面4.3节中快速双向通道建立流程中介绍过，我们来看一下其流程。
发送同步消息是通过sendMessageSynchronously()方法实现的： @AsyncChannelClient.java
public static void sendSyncMsgToService() {
Message replyMsg = sClientAsyncChannel.sendMessageSynchronously(MainActivity.MSG_SYNC_REQ);
String msg = (String) replyMsg.obj;
Log.d(tag, "get service sync reply msg = " + msg);
}
@AsyncChannel.java
public Message sendMessageSynchronously(int what) {
Message msg = Message.obtain();
msg.what = what;
Message resultMsg = sendMessageSynchronously(msg);
return resultMsg;
}
public Message sendMessageSynchronously(Message msg) {
Message resultMsg = SyncMessenger.sendMessageSynchronously(mDstMessenger, msg);
return resultMsg;
}
private static Message sendMessageSynchronously(Messenger dstMessenger, Message msg) {
//创建SyncMessenger对象
SyncMessenger sm = SyncMessenger.obtain();
try {
if (dstMessenger != null && msg != null) {
//将SyncMessenger的Messenger放入消息包中
msg.replyTo = sm.mMessenger;
synchronized (sm.mHandler.mLockObject) {
//将CMD_CHANNEL_FULL_CONNECTION发送给远端的服务
dstMessenger.send(msg);
//阻塞监听唤醒
sm.mHandler.mLockObject.wait();
}
} else {
sm.mHandler.mResultMsg = null;
}
} catch (InterruptedException e) {
sm.mHandler.mResultMsg = null;
} catch (RemoteException e) {
sm.mHandler.mResultMsg = null;
}
Message resultMsg = sm.mHandler.mResultMsg;
sm.recycle();
//将结果返回给客户端
return resultMsg;
} 以上过程是不是很熟悉？没错，这就是建立快速双向通道中最关键的部分，其原理就是在客户端发送消息后，AsyncChannel内部创建一个SyncMessenger对象，等消息发送给服务端之后，SyncMessenger就进入阻塞状态，当服务端回应消息时，SyncMessenger就解除阻塞，然后将结果返回给客户端。
这就是同步消息的传输机制。