异步通道机制

概述

    AsyncChannel用来连接两个Handler之间的异步消息处理的通道，它的实现核心是Messenger。
因此它不仅支持进程内的消息传递，还支持多进程间的消息传递。
    AsyncChannel是Framework内部使用的一种通信机制，并没有作为API给应用程序使用。

两种模式

• AsyncChannel的核心实现是基于跨进程的Handler-Message机制，可参见跨进程消息处理机制。
• AsyncChannel提供了两种模式的通信方法，称为半连接(Half Connection)和全连接(Full Connection)。

AsyncChannel命令标识

• 在AsyncChannel通信协议中，使用一组命令标识描述当前连接建立的过程。
• 所有命令都以BASE为基数：int BASE = Protocol.BASE_SYSTEM_ASYNC_CHANNEL;。

AsyncChannel状态标识

• AsyncChannel连接是否成功根据一组状态标识判断。

AsyncChannel如何工作

• AsyncChannel的工作方式主要分为以下几个阶段：发起连接请求、确认连接请求、发送消息、回复消息、断开连接等。对于以上每一个步骤，AsyncChannel类都提供了相应的方法，并考虑到不同的对象作为参数。

发起连接请求

确认连接请求

发送消息

回复消息

断开连接

示例代码

客户端发送请求

• 以WifiService为例，该类包含一个连接通道WifiStateMachineHandler，它在初始化时与WifiStateMachine建立连接。
• 当连接建立以后，WifiService可利用这个AsyncChannel与WifiStateMachine之间进行消息通信，并且在断开连接后还会自动重连。

  private class WifiStateMachineHandler extends Handler {
      private AsyncChannel mWsmChannel;
  
      WifiStateMachineHandler(android.os.Looper looper) {
          super(looper);
          // 创建AsyncChannel对象
          mWsmChannel = new AsyncChannel();
          // 与WifiStateMachine的Handler建立连接
          mWsmChannel.connect(mContext, this, mWifiStateMachine.getHandler());
      }
  
      @Override
      public void handleMessage(Message msg) {
          switch (msg.what) {
              // 建立半连接半状态
              case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED: {
                  if (msg.arg1 == AsyncChannel.STATUS_SUCCESSFUL) {
                      mWifiStateMachineChannel = mWsmChannel;
                  } else {
                      mWifiStateMachineChannel = null;
                  }
                  break;
              }
              // 连接断开状态
              case AsyncChannel.CMD_CHANNEL_DISCONNECTED: {
                  mWifiStateMachineChannel = null;
                  // 重新与Server建立连接
                  mWsmChannel.connect(mContext, this, mWifiStateMachine.getHandler());
                  break;
              }
              default: {
                  break;
              }
          }
      }
  }
  
  WifiStateMachineHandler mWifiStateMachineHandler;
  

服务端接收请求

• WifiService同样包含一个等待连接的服务端AsyncServiceHandler，当有客户端连接时，它会记录每个客户端对象，并在断开连接时移除。
• 当客户端连接建立以后，可通过AsyncChannel发送WifiManager.CMD*消息给该AsyncServiceHandler进行消息处理。

  private class AsyncServiceHandler extends Handler {
      AsyncServiceHandler(android.os.Looper looper) {
          super(looper);
      }
  
      @Override
      public void handleMessage(Message msg) {
          switch (msg.what) {
              case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED: {
                  if (msg.arg1 == AsyncChannel.STATUS_SUCCESSFUL) {
                      mClients.add((AsyncChannel) msg.obj);
                  } else {
                  }
                  break;
              }
              case AsyncChannel.CMD_CHANNEL_DISCONNECTED: {
                  if (msg.arg1 == AsyncChannel.STATUS_SEND_UNSUCCESSFUL) {
                  } else {
                  }
                  mClients.remove((AsyncChannel) msg.obj);
                  break;
              }
              case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION: {
                  AsyncChannel ac = new AsyncChannel();
                  ac.connect(mContext, this, msg.replyTo);
                  break;
              }
              case WifiManager.CMD_ENABLE_TRAFFIC_STATS_POLL: {
                  mEnableTrafficStatsPoll = (msg.arg1 == 1);
                  mTrafficStatsPollToken++;
                  if (mEnableTrafficStatsPoll) {
                      notifyOnDataActivity();
                      sendMessageDelayed(Message.obtain(this, WifiManager.CMD_TRAFFIC_STATS_POLL,
                              mTrafficStatsPollToken, 0), POLL_TRAFFIC_STATS_INTERVAL_MSECS);
                  }
                  break;
              }
              case WifiManager.CMD_TRAFFIC_STATS_POLL: {
                  if (msg.arg1 == mTrafficStatsPollToken) {
                      notifyOnDataActivity();
                      sendMessageDelayed(Message.obtain(this, WifiManager.CMD_TRAFFIC_STATS_POLL,
                              mTrafficStatsPollToken, 0), POLL_TRAFFIC_STATS_INTERVAL_MSECS);
                  }
                  break;
              }
              case WifiManager.CMD_CONNECT_NETWORK: {
                  if (msg.obj != null) {
                      mWifiStateMachine.connectNetwork((WifiConfiguration)msg.obj);
                  } else {
                      mWifiStateMachine.connectNetwork(msg.arg1);
                  }
                  break;
              }
              case WifiManager.CMD_SAVE_NETWORK: {
                  mWifiStateMachine.saveNetwork((WifiConfiguration)msg.obj);
                  break;
              }
              case WifiManager.CMD_FORGET_NETWORK: {
                  mWifiStateMachine.forgetNetwork(msg.arg1);
                  break;
              }
              case WifiManager.CMD_START_WPS: {
                  mWifiStateMachine.startWps(msg.replyTo, (WpsInfo)msg.obj);
                  break;
              }
              case WifiManager.CMD_DISABLE_NETWORK: {
                  mWifiStateMachine.disableNetwork(msg.replyTo, msg.arg1, msg.arg2);
                  break;
              }
              default: {
                  break;
              }
          }
      }
  }
  
  private AsyncServiceHandler mAsyncServiceHandler;