Android4.0中蓝牙适配器state machine（状态机）的分析
今天晓东和大家来一起看一下Android4.0中蓝牙适配器（Bluetooth Adapter）的状态机变化的过程。首先，我们需要了解一下，蓝牙适配器究竟有哪些状态，从代码可以清晰地看到（frameworks/base/core/java/android/server/bluetoothadapterstatemachine.java）：
BluetoothAdapterStateMachine(Context context, BluetoothService bluetoothService,
BluetoothAdapter bluetoothAdapter) {
……
//bluetooth adapter的六个状态
mBluetoothOn = new BluetoothOn();
mSwitching = new Switching();
mHotOff = new HotOff();
mWarmUp = new WarmUp();
mPowerOff = new PowerOff();
mPerProcessState = new PerProcessState();
……
}
bluetooth adapter有六个状态，分别为：
1）BluetoothOn：就是打开的状态。
2）Switching：可以认为是正在打开的状态。
3）HotOff：这个状态可以理解为一个预热状态，他是在上电之后进行了一系列硬件初始化成功之后的状态，但是这种状态并不表现到ui上。但是从耗电的状态来看，他和2.3中bluetooth on是一样的。
4）WarmUp：可以理解为正在预热的状态，就是处于从断电到HotOff的状态。
5）PowerOff：就是掉电的状态，也就是正在的关闭状态，这个时候bluetooth是没有耗电（准确说是耗电很少）。
6）PerProcessState：他也是位于HotOff到BluetoothOn之间的一个状态，和Switching的差别在于Swtiching是我们通过ui上去打开的“正在打开”的状态，而perprocess则是应用于一些临时使用蓝牙的application，这些application并不需要完整的蓝牙功能（比如说在蓝牙打开后的自动连接等），也不需要ui上去显示蓝牙的打开。所以，有这样一个过渡的状态，在change到BluetoothOn的时候并不会发出类似state_on的broadcaset。当然，这个状态的使用场合并不是很多，大家了解一下就可以了。
各个状态之间的变化如下图所示。
从图中可以看出，这六个状态中有3个状态是bluetooth有可能长期处于的状态，也就是非中间状态，他们是BluetoothOn，HotOff以及PowerOff。还有3个状态是中间状态，分别是Switching，WarmUp以及PerProcessState。
从代码来看，在最开始会处于PowerOff的状态，如下：
BluetoothAdapterStateMachine(Context context, BluetoothService bluetoothService,
BluetoothAdapter bluetoothAdapter) {
……
setInitialState(mPowerOff); //初始化为PowerOff的状态
mPublicState = BluetoothAdapter.STATE_OFF;
}
因此，我们首先从PowerOff状态出发来分析：
private class PowerOff extends State {
@Override
public void enter() {
if (DBG) log("Enter PowerOff: " + getCurrentMessage().what);
}
@Override
public boolean processMessage(Message message) {
log("PowerOff process message: " + message.what);
boolean retValue = HANDLED;
switch(message.what) {
//收到USER_TURN_ON的消息，一般而言，这个是用户在ui上点打开蓝牙会出现在这里。在bluetooth quick switch关闭的情况下，这个消息是蓝牙真正打开的第一步。当然，若是bluetooth quick switch打开了，是不会在这个状态收到这个消息的（除非出现了问题）
case USER_TURN_ON:
// starts turning on BT module, broadcast this out
//广播STATE_TURNING_ON的消息，可以做ui上显示等的处理
broadcastState(BluetoothAdapter.STATE_TURNING_ON);
//change到WarmUp的状态
transitionTo(mWarmUp);
//对蓝牙的初始化，我们暂时不管，后面我们有专门的文章来解释
if (prepareBluetooth()) {
// this is user request, save the setting
if ((Boolean) message.obj) {
persistSwitchSetting(true);
}
// We will continue turn the BT on all the way to the BluetoothOn state
//若是成功，我们会发TURN_ON_CONTINUE的msg，
//需要注意的是这个msg，是在warmup状态中进行处理的哦
deferMessage(obtainMessage(TURN_ON_CONTINUE));
} else {
//当然，若是失败，我们需要回到poweroff的状态
Log.e(TAG, "failed to prepare bluetooth, abort turning on");
transitionTo(mPowerOff);
broadcastState(BluetoothAdapter.STATE_OFF);
}
break;
//这个case，TURN_HOT就是在bluetooth quick switch打开的情况下，我们接收到这个msg，使得在开机之后，即使蓝牙没有打开，我们也会去做蓝牙controller初始化相关的操作，在上一篇文章中的《Android启动之bluetooth 》中我们在initAfterRegistration中就有这个msg的发出，同样是根据quick switch来判断的。
case TURN_HOT:
//这里我们会发现，我们还是去初始化蓝牙相关的操作，不同的是，我们没有任何的广播消息发出，所以别的recever包括ui都是不知道我们偷偷做这个操作的。
if (prepareBluetooth()) {
transitionTo(mWarmUp); //在初始化成功后，我们仍然会change到WarmUp
}
break;
//对于飞行模式，我们并不陌生，它主要控制电话，wifi，和蓝牙，所以，毫无疑问，我们需要对飞行模式做一些处理。其实用脚趾头想我们都知道做了些什么，若是打开飞行模式之前蓝牙是打开的，那么关闭飞行模式，我们仍然需要打开它。若是打开飞行模式之前蓝牙是关闭的，那么关闭飞行模式的时候，我们根据quick switch的值来判断是否重新打开
case AIRPLANE_MODE_OFF:
if (getBluetoothPersistedSetting()) {
//之前是打开的，和USER_TURN_ON的处理是相同的
// starts turning on BT module, broadcast this out
broadcastState(BluetoothAdapter.STATE_TURNING_ON);
transitionTo(mWarmUp);
if (prepareBluetooth()) {
// We will continue turn the BT on all the way to the BluetoothOn state
deferMessage(obtainMessage(TURN_ON_CONTINUE));
transitionTo(mWarmUp);
} else {
Log.e(TAG, "failed to prepare bluetooth, abort turning on");
transitionTo(mPowerOff);
broadcastState(BluetoothAdapter.STATE_OFF);
}
//之前是关闭的，需要根据quick switch的值来进行判断，看是否发送TURN_HOT的msg
} else if (mContext.getResources().getBoolean
(com.android.internal.R.bool.config_bluetooth_adapter_quick_switch)) {
sendMessage(TURN_HOT);
}
break;
//这个是上文所说的一些应用直接调用changeApplicationBluetoothState api之后会发出的msg，只会做蓝牙的打开操作，同样不会有任何的ui上的显示。
case PER_PROCESS_TURN_ON:
if (prepareBluetooth()) {
transitionTo(mWarmUp);
}
deferMessage(obtainMessage(PER_PROCESS_TURN_ON));
break;
//其它的msg都是无关紧要的，不加以分析了
……
return retValue;
}
到这里，我们可以看到Poweroff状态下的msg分析就已经都完成了，比较关键的几个msg是USER_TURN_ON—UI上打开蓝牙的msg；TURN_HOT—quick switch打开的时候，默认打开蓝牙的msg；AIRPLANE_MODE_OFF—飞行模式关闭的msg。ok，下面我们去看一下warmup这个状态的处理。
private class WarmUp extends State {
@Override
public void enter() {
if (DBG) log("Enter WarmUp: " + getCurrentMessage().what);
}
@Override
public boolean processMessage(Message message) {
log("WarmUp process message: " + message.what);
boolean retValue = HANDLED;
switch(message.what) {
//sdp ok，则把刚刚prepare bluetooth中启动的一个定时器（10s）remove掉，同时change到hotoff的状态
case SERVICE_RECORD_LOADED:
removeMessages(PREPARE_BLUETOOTH_TIMEOUT);
transitionTo(mHotOff);
break;
case PREPARE_BLUETOOTH_TIMEOUT:
Log.e(TAG, "Bluetooth adapter SDP failed to load");
//若是tiemout的话，我们就只能change到poweroff状态了。
shutoffBluetooth();
transitionTo(mPowerOff);
broadcastState(BluetoothAdapter.STATE_OFF);
break;
case USER_TURN_ON: // handle this at HotOff state
case TURN_ON_CONTINUE: // Once in HotOff state, continue turn bluetooth
// on to the BluetoothOn state
case AIRPLANE_MODE_ON:
case AIRPLANE_MODE_OFF:
case PER_PROCESS_TURN_ON:
case PER_PROCESS_TURN_OFF:
//收到以上这些消息都是直接defer就可以了，到下一个状态中去处理，再刚刚poweroff状态收到user_turn_on的时候，是发了TURN_ON_CONTINUE这个msg的，这个msg会在hotoff状态中继续起作用哦
deferMessage(message);
break;
case USER_TURN_OFF:
Log.w(TAG, "WarmUp received: " + message.what);
break;
default:
return NOT_HANDLED;
}
return retValue;
}
}
总的来看，warmup状态并没有做什么特别的事情，就是检测了sdp是否ok，去除了prepare了timeout，仅此而已。所以，继续看hotoff的状态。
hotoff状态比较神奇，他就是为quick swtich而生的。对蓝牙controller而言，他是一个打开的状态，对上层应用来说，他就是一个关闭的状态。
private class HotOff extends State {
@Override
public void enter() {
if (DBG) log("Enter HotOff: " + getCurrentMessage().what);
}
@Override
public boolean processMessage(Message message) {
log("HotOff process message: " + message.what);
boolean retValue = HANDLED;
switch(message.what) {
//这里其实就是ui上打开蓝牙了，需要注意的是，这里是不是没有change到别的状态哦？
//这是为什么呢？这个case之后没有break啊，没有break，懂了吧。。。
case USER_TURN_ON:
broadcastState(BluetoothAdapter.STATE_TURNING_ON);
if ((Boolean) message.obj) {
persistSwitchSetting(true);
}
//这是什么，这是上面传下来的哦，所以ui在hotoff的状态下发这个msg，这里会继续处理的哦
case TURN_ON_CONTINUE:
//这里就是蓝牙从hotoff到turnon之间要做的一个事情就是设置为connectable
mBluetoothService.switchConnectable(true);
//到switching的状态。
transitionTo(mSwitching);
break;
//这里有两个msg，一个是飞行模式开，一个turn cold，都会真正地去关闭蓝牙。
//所以无论quick switch是开还是关，之后飞行模式开了，都是会真正去关闭蓝牙的。
case AIRPLANE_MODE_ON:
case TURN_COLD:
shutoffBluetooth();
transitionTo(mPowerOff);
broadcastState(BluetoothAdapter.STATE_OFF);
break;
//同样的飞行模式的打开的处理
case AIRPLANE_MODE_OFF:
if (getBluetoothPersistedSetting()) {
broadcastState(BluetoothAdapter.STATE_TURNING_ON);
transitionTo(mSwitching);
mBluetoothService.switchConnectable(true);
}
break;
break;
//这里，不会走到swtiching的状态，会到mPerProcessState的状态，上面有详细的介绍
case PER_PROCESS_TURN_ON:
transitionTo(mPerProcessState);
// Resend the PER_PROCESS_TURN_ON message so that the callback
// can be sent through.
deferMessage(message);
mBluetoothService.switchConnectable(true);
break;
case PER_PROCESS_TURN_OFF:
perProcessCallback(false, (IBluetoothStateChangeCallback)message.obj);
break;
case USER_TURN_OFF: // ignore
break;
case POWER_STATE_CHANGED:
if ((Boolean) message.obj) {
recoverStateMachine(TURN_HOT, null);
}
break;
default:
return NOT_HANDLED;
}
return retValue;
}
}
从代码来看，hotoff的状态就是对上层ui上的一些操作进行了响应，以及兼容了no quick swtich下面的ui打开操作。它会change到swtiching的状态或者mPerProcessState的状态。我们来看看吧
private class Switching extends State {
@Override
public void enter() {
if (DBG) log("Enter Switching: " + getCurrentMessage().what);
}
@Override
public boolean processMessage(Message message) {
log("Switching process message: " + message.what);
boolean retValue = HANDLED;
switch(message.what) {
//从注释可以清晰地看到，这个msg是我们上面调用BluetoothService.switchConnectable(true);这个函数的正确回应
case SCAN_MODE_CHANGED:
// This event matches mBluetoothService.switchConnectable action
if (mPublicState == BluetoothAdapter.STATE_TURNING_ON) {
// set pairable if it's not
//设为可配对
mBluetoothService.setPairable();
//初始化bluetooth
mBluetoothService.initBluetoothAfterTurningOn();
//正式change到bluetoothon的状态
transitionTo(mBluetoothOn);
broadcastState(BluetoothAdapter.STATE_ON);
// run bluetooth now that it's turned on
// Note runBluetooth should be called only in adapter STATE_ON
//这个函数做的事情其实就是打开后的自动连接了。
mBluetoothService.runBluetooth();
}
break;
case POWER_STATE_CHANGED:
removeMessages(POWER_DOWN_TIMEOUT);
//power可以理解为电压的关闭
if (!((Boolean) message.obj)) {
if (mPublicState == BluetoothAdapter.STATE_TURNING_OFF) {
//就是关闭了，change到hotoff状态
transitionTo(mHotOff);
finishSwitchingOff();
//若是quick switch没有设置，则会change到power off的状态
if (!mContext.getResources().getBoolean
(com.android.internal.R.bool.config_bluetooth_adapter_quick_switch)) {
deferMessage(obtainMessage(TURN_COLD));
}
}
} else {
//在turning on就没有什么好做的，否则，就是看到poweroff还是hotoff了
if (mPublicState != BluetoothAdapter.STATE_TURNING_ON) {
if (mContext.getResources().getBoolean
(com.android.internal.R.bool.config_bluetooth_adapter_quick_switch)) {
recoverStateMachine(TURN_HOT, null);
} else {
recoverStateMachine(TURN_COLD, null);
}
}
}
break;
//所有的remote device都断开连接了，则我们会在5s后发送一个POWER_DOWN_TIMEOUT的msg，这个msg和下面几个msg都是从on->switching的过程中要处理的，可以见下面bluetooth_on的msg处理分析
case ALL_DEVICES_DISCONNECTED:
removeMessages(DEVICES_DISCONNECT_TIMEOUT);
mBluetoothService.switchConnectable(false);
sendMessageDelayed(POWER_DOWN_TIMEOUT, POWER_DOWN_TIMEOUT_TIME);
break;
//设备断开超时了，直接复位一下
case DEVICES_DISCONNECT_TIMEOUT:
sendMessage(ALL_DEVICES_DISCONNECTED);
// reset the hardware for error recovery
Log.e(TAG, "Devices failed to disconnect, reseting...");
deferMessage(obtainMessage(TURN_COLD));
if (mContext.getResources().getBoolean
(com.android.internal.R.bool.config_bluetooth_adapter_quick_switch)) {
deferMessage(obtainMessage(TURN_HOT));
}
break;
//power down timeout,也是直接复位
case POWER_DOWN_TIMEOUT:
transitionTo(mHotOff);
finishSwitchingOff();
// reset the hardware for error recovery
Log.e(TAG, "Devices failed to power down, reseting...");
deferMessage(obtainMessage(TURN_COLD));
if (mContext.getResources().getBoolean
(com.android.internal.R.bool.config_bluetooth_adapter_quick_switch)) {
deferMessage(obtainMessage(TURN_HOT));
}
break;
……
从上面可以看到switching主要是等待BluetoothService.switchConnectable(true)的结果，若是ok，就会到turn on的状态了，进入到打开的模式。至于PerProcessState的状体和swtiching的状态比较类似，只是少了一些通知而已，大家自己去分析哦。下面我们继续看bluetooth on的状态。
private class BluetoothOn extends State {
@Override
public void enter() {
if (DBG) log("Enter BluetoothOn: " + getCurrentMessage().what);
}
@Override
public boolean processMessage(Message message) {
log("BluetoothOn process message: " + message.what);
boolean retValue = HANDLED;
switch(message.what) {
//这个是off的操作，就是ui上的关闭了
case USER_TURN_OFF:
if ((Boolean) message.obj) {
persistSwitchSetting(false);
}
if (mBluetoothService.isDiscovering()) {
mBluetoothService.cancelDiscovery();
}
if (!mBluetoothService.isApplicationStateChangeTrackerEmpty()) {
transitionTo(mPerProcessState);
deferMessage(obtainMessage(TURN_HOT));
break;
}
//同样要注意，这里没有break哦
//$FALL-THROUGH$ to AIRPLANE_MODE_ON
//和飞行模式打开的操作
case AIRPLANE_MODE_ON:
broadcastState(BluetoothAdapter.STATE_TURNING_OFF);
transitionTo(mSwitching);
if (mBluetoothService.getAdapterConnectionState() !=
BluetoothAdapter.STATE_DISCONNECTED) {
//需要把所有已经连接的设备都disconnect掉
mBluetoothService.disconnectDevices();
sendMessageDelayed(DEVICES_DISCONNECT_TIMEOUT,
DEVICES_DISCONNECT_TIMEOUT_TIME);
} else {
//没有连接设备，直接power down
mBluetoothService.switchConnectable(false);
sendMessageDelayed(POWER_DOWN_TIMEOUT, POWER_DOWN_TIMEOUT_TIME);
}
// we turn all the way to PowerOff with AIRPLANE_MODE_ON
if (message.what == AIRPLANE_MODE_ON) {
// We inform all the per process callbacks
allProcessesCallback(false);
deferMessage(obtainMessage(AIRPLANE_MODE_ON));
}
break;
……
return retValue;
}
}
所以，看起来bluetooth_on的处理也比较单纯，就是一些关闭的尾巴处理。
至此，bluetoothadapter的state machine就已经全部分析完成了，回顾一下，有六个状态，BluetoothOn，Switching，HotOff，WarmUp，PowerOff，PerProcessState，他们之间可以相互转换，从而达到打开关闭蓝牙的目的。