【android bluetooth 框架分析 04】【bt-framework 层详解 4】【AdapterState介绍】

1. 问题

在蓝牙的启动过程中，我们会看到如下log:

01-02 04:40:07.206918  2259  2658 I AdapterState0: OFF : entered 
01-02 04:40:07.348232  2259  2658 I AdapterState0: BLE_TURNING_ON : entered 
01-02 04:40:09.013738  2259  2658 I AdapterState0: BLE_ON : entered 
01-02 04:40:09.042387  2259  2658 I AdapterState0: TURNING_ON : entered 
01-02 04:40:09.238341  2259  2658 I AdapterState0: ON : entered 

这些 log 其实代表蓝牙启动过程中 各个状态。这篇文档我们大体介绍一下 在蓝牙服务启动的各个阶段，都做了那些事情。

如果你已经很清楚蓝牙启动过程中，各个阶段的处理。请忽略该篇内容。

2. AdapterState 介绍

在 AOSP（Android Open Source Project）中，AdapterState 是蓝牙系统服务的一部分，主要用于管理 蓝牙适配器（Bluetooth Adapter）的状态机，控制蓝牙从关闭到打开、BLE模式等不同状态的转换，并协调各子模块的初始化或清理流程。

---

1. AdapterState 类的作用

AdapterState 是 AOSP 中 Bluetooth 服务模块的一部分，位于：

/packages/modules/Bluetooth/android/app/src/com/android/bluetooth/btservice/AdapterState.java

主要职责：

功能	说明
状态机管理	管理 Bluetooth Adapter 的生命周期状态（如 OFF、BLE_ON、ON 等）
事件驱动	接收上层请求（如 enable/disable），并分发到底层组件（如 JNI/HAL）
模块协调	协调 AdapterService、ProfileService、GattService 等模块初始化或停止
蓝牙状态广播	根据状态变化发送系统广播（如 ACTION_STATE_CHANGED）通知其他系统组件或应用

---

2.蓝牙 Adapter 的状态阶段说明

// android/app/src/com/android/bluetooth/btservice/AdapterState.java
    static final int USER_TURN_ON = 1;
    static final int USER_TURN_OFF = 2;
    static final int BLE_TURN_ON = 3;
    static final int BLE_TURN_OFF = 4;
    static final int BREDR_STARTED = 5;
    static final int BREDR_STOPPED = 6;
    static final int BLE_STARTED = 7;
    static final int BLE_STOPPED = 8;
    static final int BREDR_START_TIMEOUT = 9;
    static final int BREDR_STOP_TIMEOUT = 10;
    static final int BLE_STOP_TIMEOUT = 11;
    static final int BLE_START_TIMEOUT = 12;
    static final int NEW_ADAPTER_STATE_CHANGED = 13;
    static final int NEW_ADAPTER_ENABLE_TIMEOUT = 14;
    static final int NEW_ADAPTER_DISABLE_TIMEOUT = 15;

蓝牙状态是一个状态机，核心状态有以下几种（在 AdapterState.java 和 AdapterService.java 中定义）：

状态	说明	主要工作	触发事件
OFF	蓝牙完全关闭	清理所有蓝牙模块和资源	无
BLE_TURNING_ON	开启 BLE 模式	初始化 GattService、Native Stack，但不开启 Classic Profiles（如 A2DP、HFP）	启动 AdapterService, 调用 JNI 的 enable()
BLE_ON	BLE 模式开启	蓝牙处于仅 BLE 可用状态（如用于 BLE 位置服务）	可被系统用于 BLE Scanning、Gatt连接
TURNING_ON	正在开启完整蓝牙（Classic + BLE）	初始化 ProfileService（如 A2DP、HFP）、设置蓝牙名称、地址	HAL 通知状态变化
ON	完整蓝牙已开启	所有模块初始化完毕，可连接经典蓝牙设备、进行配对、传输音频等	广播 BluetoothAdapter.STATE_ON
TURNING_OFF	正在关闭蓝牙	依次关闭各服务，断开连接，释放资源	HAL 通知状态变化
BLE_TURNING_OFF	BLE 正在关闭	停止 GattService，关闭 native 蓝牙堆栈	最终进入 OFF 状态

---

3.蓝牙启动各阶段的详细流程与事件触发

以下是一个完整的蓝牙启动过程（由 BluetoothAdapter.enable() 触发）：

1. 初始状态：OFF

• 蓝牙未启动，所有模块未激活。
• 用户调用 BluetoothAdapter.enable()。

app 侧

1. 当前蓝牙没有开启，蓝牙服务 进程 没有启动。此时用户需要打开蓝牙，调用如下。

BluetoothAdapter.enable()

// framework/java/android/bluetooth/BluetoothAdapter.java
    public boolean enable() {
		...
        try {
            return mManagerService.enable(mAttributionSource); // 这里调用 BluetoothManagerService.enable
        } catch (RemoteException e) {
            Log.e(TAG, "", e);
        }
        return false;
    }

• 此时会 通过 IBluetoothManager.aidl 接口 调用到 framework 侧，也就是 system_server进程中。

system_server 侧

// service/java/com/android/server/bluetooth/BluetoothManagerService.java

public class BluetoothManagerService extends IBluetoothManager.Stub {



    public boolean enable(AttributionSource attributionSource) throws RemoteException {
        ...

        synchronized (mReceiver) {
			...
			// 这里最终会触发  发送 MESSAGE_ENABLE 事件
            sendEnableMsg(false,
                    BluetoothProtoEnums.ENABLE_DISABLE_REASON_APPLICATION_REQUEST, packageName);
        }
		...
        return true;
    }


    private void sendEnableMsg(boolean quietMode, int reason, String packageName, boolean isBle) {
        // 发送 MESSAGE_ENABLE 事件
        mHandler.sendMessage(mHandler.obtainMessage(MESSAGE_ENABLE, quietMode ? 1 : 0,
                  isBle ? 1 : 0));
        addActiveLog(reason, packageName, true);
        mLastEnabledTime = SystemClock.elapsedRealtime();
    }


    private class BluetoothHandler extends Handler {


        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MESSAGE_ENABLE:
	                ...
                    handleEnable(mQuietEnable); // 打开蓝牙
                    ...
	                break;
            }
            
            
        }

    }



    private void handleEnable(boolean quietMode) {
		...
                bindToAdapter();
        ...
    }


	private BluetoothServiceConnection mConnection = new BluetoothServiceConnection();


    private void bindToAdapter() {

		// com.android.bluetooth/.btservice.AdapterService
        Intent intent = new Intent(getBluetoothClassName());
        Log.d(TAG, "Start binding to the Bluetooth service with intent=" + intent);
		mContext.bindServiceAsUser(intent, mConnection, flags, user); // 此时系统会自动将我们的蓝牙服务拉起来
    }


}

system_server 最终会通过 bindServiceAsUser 将我们的蓝牙服务进程com.android.bluetooth/.btservice.Adapterservice拉起来。

• 在 使用 bindServiceAsUser 拉起 蓝牙服务时， 会将服务对应的 Ibind 接口通过 mConnection = new BluetoothServiceConnection() 返回给 system_server 侧。

bt.server 侧

此时我们的蓝牙服务 被拉起来了。

• packages/modules/Bluetooth/android/app/src/com/android/bluetooth/btservice/AdapterService.java

public class AdapterService extends Service {

	// 根据服务的生命周期 此时就会触发调用 onCreate 方法
    public void onCreate() {
	    ...
	    mAdapterStateMachine = AdapterState.make(this); // 这里会创建 AdapterState 对象
	    ...
    }

}

// android/app/src/com/android/bluetooth/btservice/AdapterState.java
    private AdapterState(AdapterService service) {
        super(TAG);
        addState(mOnState);
        addState(mBleOnState);
        addState(mOffState);
        addState(mTurningOnState);
        addState(mTurningOffState);
        addState(mTurningBleOnState);
        addState(mTurningBleOffState);
        if (isDualAdapterMode()) {
            addState(mNewAdapterState);
        }
        mAdapterService = service;
        mAdapterIndex = AdapterUtil.getAdapterIndex();
        setInitialState(mOffState); // 这里默认的状态就是  OFF 状态
    }


    private class OffState extends BaseAdapterState {

        @Override
        int getStateValue() {
            return BluetoothAdapter.STATE_OFF;
        }

        @Override
        public boolean processMessage(Message msg) {
            switch (msg.what) {
                case BLE_TURN_ON:
                    transitionTo(mTurningBleOnState);
                    break;

                default:
                    infoLog("Unhandled message - " + messageString(msg.what));
                    return false;
            }
            return true;
        }
    }

• 当 OffState 收到 BLE_TURN_ON 消息，将进入 TurningBleOn 状态

2. 进入 BLE_TURNING_ON

在该状态下 主要去 bringUpBle

• 启动 AdapterService 和 JNI 层：

  • 启动 native 蓝牙堆栈
  • 初始化 GattService，用于 BLE 操作

• 在收到 BLE_STARTED 事件后：AdapterState.BLE_TURNING_ON → AdapterState.BLE_ON

system_server 侧

// 蓝牙服务 onBind 调用 将返回 Ibinder 接口
01-02 04:40:07.311987  2259  2259 D BluetoothAdapterService: onBind()

// 此时 system_server 收到 IBinder 回调 BluetoothServiceConnection
01-02 04:40:07.312698  1686  1686 D BluetoothManagerService: BluetoothServiceConnection: com.android.bluetooth.btservice.AdapterService
// 触发 MESSAGE_BLUETOOTH_SERVICE_CONNECTED 消息
01-02 04:40:07.312920  1686  2033 D BluetoothManagerService: MESSAGE_BLUETOOTH_SERVICE_CONNECTED: 1


01-02 04:40:07.322022  2259  2322 D BluetoothAdapter: onBluetoothServiceUp: com.android.bluetooth.btservice.AdapterService$AdapterServiceBinder@ee20315
01-02 04:40:07.327105  2259  2340 D BluetoothAdapterService: getSupportedProfiles
// 触发 蓝牙服务的 enable 接口
01-02 04:40:07.347695  2259  2340 D BluetoothAdapterService: enable() - Enable called with quiet mode status =  false

• 在 使用 bindServiceAsUser 拉起 蓝牙服务时， 会将服务对应的 Ibind 接口通过 mConnection = new BluetoothServiceConnection() 返回给 system_server 侧。

• 当 system_server 侧监听到 BluetoothAdapterService 服务已经启动：

• service/java/com/android/server/bluetooth/BluetoothManagerService.java

    private class BluetoothServiceConnection implements ServiceConnection {
        public void onServiceConnected(ComponentName componentName, IBinder service) {
			...
            if (DBG) {
                Log.d(TAG, "BluetoothServiceConnection: " + name);
            }
            Message msg = mHandler.obtainMessage(MESSAGE_BLUETOOTH_SERVICE_CONNECTED);
            if (isServiceIBluetooth(name)) {
                msg.arg1 = SERVICE_IBLUETOOTH; // 这里 表示 BluetoothAdapterService: onBind 已经返回了 IBinder了
            } else if (isServiceIBluetoothGatt(name)) {
                msg.arg1 = SERVICE_IBLUETOOTHGATT; // 这里表示 GattService: onBind 已经返回了 Ibinder 了
            } else {
                Log.e(TAG, "Unknown service connected: " + name);
                return;
            }
            msg.obj = service;// 蓝牙服务的 Ibinder
            mHandler.sendMessage(msg); // 发送 MESSAGE_BLUETOOTH_SERVICE_CONNECTED 消息
        }
	
	
	
	}

    private class BluetoothHandler extends Handler {


        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MESSAGE_BLUETOOTH_SERVICE_CONNECTED: {
	                ...
					synchronousEnable(mQuietEnable, mContext.getAttributionSource());
					...
					break;
				}
			}
		}
	}


    private IBluetooth mBluetooth;
    private boolean synchronousEnable(boolean quietMode, AttributionSource attributionSource)
            throws RemoteException, TimeoutException {
		...
        mBluetooth.enable(quietMode, attributionSource, recv); // 调用 AdapterService.enable
		...
    }

bt.server 侧

// android/app/src/com/android/bluetooth/btservice/AdapterService.java
    public synchronized boolean enable(boolean quietMode) {

        debugLog("enable() - Enable called with quiet mode status =  " + quietMode);
        mQuietmode = quietMode;
        mAdapterStateMachine.sendMessage(AdapterState.BLE_TURN_ON); // 此时 将 触发 AdapterState 从 OFF -> BLE_TURNING_ON 
        return true;
    }

• android/app/src/com/android/bluetooth/btservice/AdapterState.java

    private class TurningBleOnState extends BaseAdapterState {

        @Override
        int getStateValue() {
            return BluetoothAdapter.STATE_BLE_TURNING_ON;
        }

        @Override
        public void enter() {
            super.enter();
            final int timeoutDelay = SystemProperties.getInt(
                    BLE_START_TIMEOUT_DELAY_PROPERTY, BLE_START_TIMEOUT_DELAY);
            Log.d(TAG, "Start Timeout Delay: " + timeoutDelay);
            sendMessageDelayed(BLE_START_TIMEOUT, timeoutDelay);
            mAdapterService.bringUpBle(); // 在 TurningBleOnState 主要去 启动 ble 
        }

        @Override
        public void exit() {
            removeMessages(BLE_START_TIMEOUT);
            super.exit();
        }

        @Override
        public boolean processMessage(Message msg) {
            switch (msg.what) {
                case BLE_STARTED:
                    transitionTo(mBleOnState);
                    break;

                case BLE_START_TIMEOUT:
                    errorLog(messageString(msg.what));
                    transitionTo(mTurningBleOffState);
                    break;

                default:
                    infoLog("Unhandled message - " + messageString(msg.what));
                    return false;
            }
            return true;
        }
    }

• 如果要从 BLE_TURNING_ON -> BLE_ON 需要 BLE_STARTED 事件触发

3. 进入 BLE_ON

• BLE 功能可用，但尚未初始化经典蓝牙模块。

• 某些系统功能可以使用 BLE，比如：

  • BLE 广播

  • BLE 扫描

  • BLE 设备连接（如智能手环）

bt.server-jni 侧

当蓝牙协议栈初始化完后， 会调用 adapter_state_change_callback 函数，将状态告知 java 层

// android/app/jni/com_android_bluetooth_btservice_AdapterService.cpp

  method_stateChangeCallback =
      env->GetMethodID(jniCallbackClass, "stateChangeCallback", "(I)V");


static void adapter_state_change_callback(bt_state_t status) {
  CallbackEnv sCallbackEnv(__func__);
  if (!sCallbackEnv.valid()) return;
  ALOGV("%s: Status is: %d", __func__, status);

  sCallbackEnv->CallVoidMethod(sJniCallbacksObj, method_stateChangeCallback,
                               (jint)status);
}

bt.server-java侧

• android/app/src/com/android/bluetooth/btservice/JniCallbacks.java

    void stateChangeCallback(int status) {
        mAdapterService.stateChangeCallback(status);
    }

• android/app/src/com/android/bluetooth/btservice/AdapterService.java

    void stateChangeCallback(int status) {
        if (status == AbstractionLayer.BT_STATE_OFF) {
            debugLog("stateChangeCallback: disableNative() completed");
            mAdapterStateMachine.sendMessage(AdapterState.BLE_STOPPED);
        } else if (status == AbstractionLayer.BT_STATE_ON) {
		    // 此时在这里 将下发  BLE_STARTED 事件， 这就使得  BLE_TURNING_ON  -> BLE_ON
            mAdapterStateMachine.sendMessage(AdapterState.BLE_STARTED);
        } else {
            Log.e(TAG, "Incorrect status " + status + " in stateChangeCallback");
        }
    }

• android/app/src/com/android/bluetooth/btservice/AdapterState.java

    private class BleOnState extends BaseAdapterState {

        @Override
        int getStateValue() {
            return BluetoothAdapter.STATE_BLE_ON;
        }

        @Override
        public boolean processMessage(Message msg) {
            switch (msg.what) {
                case USER_TURN_ON:
                    transitionTo(mTurningOnState);
                    break;

                case BLE_TURN_OFF:
                    transitionTo(mTurningBleOffState);
                    break;

                default:
                    infoLog("Unhandled message - " + messageString(msg.what));
                    return false;
            }
            return true;
        }
    }

• 如果要 向从 BLE_ON -> TURNNING_ON 需要 USER_TURN_ON 事件触发。

4. 进入 TURNING_ON

• 调用 JNI 层请求打开 Classic 模块。

• 初始化 ProfileServices（如 A2DP、HFP、PBAP 等）

• 加载配对信息、设置蓝牙名称、地址

• HAL 层返回状态（通过事件通知）

// bt.server 中， GattService 启动
01-02 04:40:09.023532  2259  2259 D GattService: onBind


// sytem_server 此时监听到
01-02 04:40:09.039431  1686  2033 D BluetoothManagerService: MESSAGE_BLUETOOTH_SERVICE_CONNECTED: 2
01-02 04:40:09.039653  1686  2033 D BluetoothManagerService: continueFromBleOnState()


// 触发 bt.server 此时切换到 TURNING_ON 状态
01-02 04:40:09.042387  2259  2658 I AdapterState0: TURNING_ON : entered 

system_server

• 在 使用 bindServiceAsUser 拉起 蓝牙服务时， 会将服务对应的 Ibind 接口通过 mConnection = new BluetoothServiceConnection() 返回给 system_server 侧。

• 当 system_server 侧监听到 GattService 服务已经启动：

• service/java/com/android/server/bluetooth/BluetoothManagerService.java

    private class BluetoothServiceConnection implements ServiceConnection {
        public void onServiceConnected(ComponentName componentName, IBinder service) {
			...
            if (DBG) {
                Log.d(TAG, "BluetoothServiceConnection: " + name);
            }
            Message msg = mHandler.obtainMessage(MESSAGE_BLUETOOTH_SERVICE_CONNECTED);
            if (isServiceIBluetooth(name)) {
                msg.arg1 = SERVICE_IBLUETOOTH; // 这里 表示 BluetoothAdapterService: onBind 已经返回了 IBinder了
            } else if (isServiceIBluetoothGatt(name)) {
                msg.arg1 = SERVICE_IBLUETOOTHGATT; // 这里表示 GattService: onBind 已经返回了 Ibinder 了
            } else {
                Log.e(TAG, "Unknown service connected: " + name);
                return;
            }
            msg.obj = service;// 蓝牙服务的 Ibinder
            mHandler.sendMessage(msg); // 发送 MESSAGE_BLUETOOTH_SERVICE_CONNECTED 消息
        }
	
	
	
	}

• service/java/com/android/server/bluetooth/BluetoothManagerService.java

    private class BluetoothHandler extends Handler {


        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MESSAGE_BLUETOOTH_SERVICE_CONNECTED: {
                    if (DBG) {
                        Log.d(TAG, "MESSAGE_BLUETOOTH_SERVICE_CONNECTED: " + msg.arg1);
                    }

                    IBinder service = (IBinder) msg.obj;
                    try {
                        mBluetoothLock.writeLock().lock();
                        if (msg.arg1 == SERVICE_IBLUETOOTHGATT) { // 如果是 GattService 已经启动
                            mBluetoothGatt = getBluetoothGatt(service);
                            continueFromBleOnState(); // 这里会继续触发 从 BleOn 状态出发到一下个状态
                            break;
                        } // else must be SERVICE_IBLUETOOTH

	                break;
            }
            
            
        }

}

    private void continueFromBleOnState() {
        if (DBG) {
            Log.d(TAG, "continueFromBleOnState()");
        }
        try {
            mBluetoothLock.readLock().lock();
            if (mBluetooth == null) {
                Log.e(TAG, "onBluetoothServiceUp: mBluetooth is null!");
                return;
            }
            if (!mEnableExternal && !isBleAppPresent()) {
                Log.i(TAG, "Bluetooth was disabled while enabling BLE, disable BLE now");
                mEnable = false;
                synchronousOnBrEdrDown(mContext.getAttributionSource());
                return;
            }

			// 可以重点看一下这个函数 isBluetoothPersistedStateOnBluetooth
            if (isBluetoothPersistedStateOnBluetooth() || !isBleAppPresent()) {
                // This triggers transition to STATE_ON
                synchronousOnLeServiceUp(mContext.getAttributionSource()); // 这里会触发 开启 经典蓝牙
                persistBluetoothSetting(BLUETOOTH_ON_BLUETOOTH);
            }
        } catch (RemoteException | TimeoutException e) {
            Log.e(TAG, "Unable to call onServiceUp", e);
        } finally {
            mBluetoothLock.readLock().unlock();
        }
    }



    /**
     *  Returns true if the Bluetooth saved state is BLUETOOTH_ON_BLUETOOTH
     */
    private boolean isBluetoothPersistedStateOnBluetooth() {
        if (!supportBluetoothPersistedState()) {
            return false;
        }
        /*
	        这里会从 Settings的ContentResolver 获取  bluetooth_on 字段， 如果是 BLUETOOTH_ON_BLUETOOTH 表示支持 开启 经典蓝牙。
	        但是 如果获取不到 里面的值， 默认也是 BLUETOOTH_ON_BLUETOOTH
	        所以 这里不用特意配置， 默认就是支持 打开 经典蓝牙的。

			如果你的项目上只需要  ble 。 可以在这里 做文章。这样蓝牙协议栈就不会继续 去 初始化经典蓝牙。
        */
        return Settings.Global.getInt(mContentResolver, Settings.Global.BLUETOOTH_ON,
                BLUETOOTH_ON_BLUETOOTH) == BLUETOOTH_ON_BLUETOOTH;
    }




    private void synchronousOnLeServiceUp(AttributionSource attributionSource)
            throws RemoteException, TimeoutException {
        if (mBluetooth == null) return;
        final SynchronousResultReceiver recv = SynchronousResultReceiver.get();
        mBluetooth.onLeServiceUp(attributionSource, recv); // 这里继续调用 蓝牙服务的 onLeServiceUp 接口
        recv.awaitResultNoInterrupt(getSyncTimeout()).getValue(null);
    }

bt.server 侧

• android/app/src/com/android/bluetooth/btservice/AdapterService.java

        public void onLeServiceUp(AttributionSource source, SynchronousResultReceiver receiver) {
            try {
                onLeServiceUp(source);
                receiver.send(null);
            } catch (RuntimeException e) {
                receiver.propagateException(e);
            }
        }
        @VisibleForTesting
        void onLeServiceUp(AttributionSource source) {
            AdapterService service = getService();
            if (service == null
                    || !callerIsSystemOrActiveOrManagedUser(service, TAG, "onLeServiceUp")
                    || !Utils.checkConnectPermissionForDataDelivery(service, source, TAG)) {
                return;
            }

            enforceBluetoothPrivilegedPermission(service);

            service.mAdapterStateMachine.sendMessage(AdapterState.USER_TURN_ON); // 这里下发了 USER_TURN_ON 消息， 此时 AdapterState 状态，就从  BLE_ON -> TURNNING_ON 
        }

• android/app/src/com/android/bluetooth/btservice/AdapterState.java

    private class TurningOnState extends BaseAdapterState {

        @Override
        int getStateValue() {
            return BluetoothAdapter.STATE_TURNING_ON;
        }

        @Override
        public void enter() {
            super.enter();
            sendMessageDelayed(BREDR_START_TIMEOUT, BREDR_START_TIMEOUT_DELAY);
            mAdapterService.startProfileServices(); // 在 TurningOnState 中，这里会去触发 启动经典蓝牙所支持的所有 profile. 例如 a2dpsink avrcp hidhost hiddevice hfp pbap 等协议的 profile.
        }

        @Override
        public void exit() {
            removeMessages(BREDR_START_TIMEOUT);
            super.exit();
        }

        @Override
        public boolean processMessage(Message msg) {
            switch (msg.what) {
                case BREDR_STARTED:
                    handleOn();
                    transitionTo(mOnState); // 如果要从 TURNNING_ON -> ON 需要 BREDR_STARTED 触发
                    break;

                case BREDR_START_TIMEOUT:
                    errorLog(messageString(msg.what));
                    transitionTo(mTurningOffState);
                    break;

                default:
                    infoLog("Unhandled message - " + messageString(msg.what));
                    return false;
            }
            return true;
        }

        private void handleOn() {
            if (isDualAdapterMode() &&
                mAdapterService.canEnableNewAdapter()) {
                mPendingOn = true;
                transitionTo(mNewAdapterState);
            } else {
                transitionTo(mOnState);
            }
        }
    }

• 如果要从 TURNNING_ON -> ON 需要 BREDR_STARTED 触发

5. 最终状态：ON

• 所有蓝牙功能可用

• 广播 BluetoothAdapter.ACTION_STATE_CHANGED -> STATE_ON

• 应用可以进行设备扫描、连接、配对、媒体传输等

bt.server

01-02 04:40:09.042387  2259  2658 I AdapterState0: TURNING_ON : entered 



// 经典蓝牙对应的 profile 启动
01-02 04:40:09.208223  2259  2259 D BluetoothAdapterService: processProfileServiceStateChanged: A2dpSinkService, state: 12


01-02 04:40:09.214157  2259  2259 D BluetoothAdapterService: processProfileServiceStateChanged: AvrcpControllerService, state: 12


01-02 04:40:09.229984  2259  2259 D BluetoothAdapterService: processProfileServiceStateChanged: HeadsetClientService, state: 12

01-02 04:40:09.230174  2259  2259 D BluetoothAdapterService: processProfileServiceStateChanged: HidDeviceService, state: 12


01-02 04:40:09.231042  2259  2259 D BluetoothAdapterService: processProfileServiceStateChanged: HidHostService, state: 12


01-02 04:40:09.231235  2259  2259 D BluetoothAdapterService: processProfileServiceStateChanged: PbapClientService, state: 12


// 当所有 profile 启动后， 将 切换到 ON
01-02 04:40:09.238341  2259  2658 I AdapterState0: ON : entered 

• android/app/src/com/android/bluetooth/btservice/AdapterService.java

        private void processProfileServiceStateChanged(ProfileService profile, int state) {
            Log.d(TAG, "processProfileServiceStateChanged: " + profile.getName() + ", state: " + state);
            switch (state) {
                case BluetoothAdapter.STATE_ON:
                    if (!mRegisteredProfiles.contains(profile)) {
                        Log.e(TAG, profile.getName() + " not registered (STATE_ON).");
                        return;
                    }
                    if (mRunningProfiles.contains(profile)) {
                        Log.e(TAG, profile.getName() + " already running.");
                        return;
                    }
                    mRunningProfiles.add(profile);

                    if (isGattService(profile.getName())) {
                        enableNative();
                    } else if (mSupportedProfileClass.size() == mRunningProfiles.size()) {

                        updateUuids();
                        setBluetoothClassFromConfig();
                        initProfileServices();
                        getAdapterPropertyNative(AbstractionLayer.BT_PROPERTY_LOCAL_IO_CAPS);
                        getAdapterPropertyNative(AbstractionLayer.BT_PROPERTY_LOCAL_IO_CAPS_BLE);
                        getAdapterPropertyNative(AbstractionLayer.BT_PROPERTY_DYNAMIC_AUDIO_BUFFER);
                        mAdapterStateMachine.sendMessage(AdapterState.BREDR_STARTED); // 发送  BREDR_STARTED 消息， 此时将从 TRUNING_ON -> ON
                        mBtCompanionManager.loadCompanionInfo();
                    }
                    break;

• android/app/src/com/android/bluetooth/btservice/AdapterState.java

    private class OnState extends BaseAdapterState {

        @Override
        int getStateValue() {
            return BluetoothAdapter.STATE_ON;
        }

        @Override
        public boolean processMessage(Message msg) {
            switch (msg.what) {
                case USER_TURN_OFF:
                    transitionTo(mTurningOffState);
                    break;

                default:
                    infoLog("Unhandled message - " + messageString(msg.what));
                    return false;
            }
            return true;
        }
    }

4.状态转换示意图

     OFF
      ↓ enable()
BLE_TURNING_ON
      ↓
   BLE_ON
      ↓ enable()
TURNING_ON
      ↓
     ON

关闭时则反过来：

     ON
      ↓ disable()
TURNING_OFF
      ↓
   BLE_ON
      ↓ disable()
BLE_TURNING_OFF
      ↓
     OFF

5.这样设计的目的

这套状态设计出发点有以下几个核心目标：

目的	解释
模块化启动	BLE 和 Classic Bluetooth 独立初始化，适应不同场景需求（如只用 BLE）
节能优化	系统可以在只需要 BLE 时不启动经典蓝牙，降低功耗
稳定性	每个状态有明确职责，便于状态机管理和问题排查
热切换能力	支持动态切换 BLE-only 模式和 Full Bluetooth 模式（如配合飞行模式等）
事件驱动	每个状态变更都伴随事件广播，方便应用和其他系统服务感知状态变化

---

6.典型应用场景举例

• 手表只用 BLE 配对手机：仅进入 BLE_ON 状态，不激活 A2DP 等模块，节省资源。
• 车载系统准备连接手机 A2DP：必须进入 ON 状态，完整启动蓝牙协议栈。
• 手机开机自启蓝牙：系统层在启动流程中逐步激活 AdapterService，进入 ON 状态。