【android bluetooth 框架分析 01】【关键线程 2】【bt_stack_manager_thread线程介绍】

1. bt_stack_manager_thread

bt_stack_manager_thread 是蓝牙协议栈中的核心调度线程，负责串行化处理协议栈的生命周期事件，包括初始化、启动、关闭与清理操作。它确保这些状态切换在同一线程中按顺序执行，避免竞态和资源冲突。作为蓝牙栈的“总指挥”，它协调模块管理器、协议子系统（如 L2CAP、GATT、BTM）、以及 JNI 层之间的事件传递，是协议栈有序启动与安全退出的关键保障。

本节就来详细介绍一下 bt_stack_manager_thread 线程。

1.1 线程启动流程

static MessageLoopThread management_thread("bt_stack_manager_thread");

static void ensure_manager_initialized() {
  if (management_thread.IsRunning()) return;

  management_thread.StartUp(); // 这里启动我们的 bt_stack_manager_thread 线程
  if (!management_thread.IsRunning()) {
    LOG_ERROR("%s unable to start stack management thread", __func__);
    return;
  }
}

const stack_manager_t* stack_manager_get_interface() {
  ensure_manager_initialized();
  return &interface;
}

调用流程如下：
com_android_bluetooth_btservice_AdapterService.cpp

static void classInitNative(JNIEnv* env, jclass clazz) {

	if (hal_util_load_bt_library((bt_interface_t const**)&sBluetoothInterface)) {
    ALOGE("No Bluetooth Library found");
  }
}

int hal_util_load_bt_library(const bt_interface_t** interface) {
  *interface = &bluetoothInterface;
  return 0;

}

• 通过 hal_util_load_bt_library 加载 sBluetoothInterface
• 此时加载的接口是 bluetoothInterface ， 这个接口是 bluetooth.cc 中的
  • system/btif/src/bluetooth.cc

EXPORT_SYMBOL bt_interface_t bluetoothInterface = {
    sizeof(bluetoothInterface),
    init, // 这个里面 创建了 bt_stack_manager_thread 线程
    enable,
    disable,
    cleanup,
    get_adapter_properties,
    get_adapter_property,
    set_adapter_property,
    get_remote_device_properties,
    get_remote_device_property,
    set_remote_device_property,
    nullptr,
    get_remote_services,
    start_discovery,
    cancel_discovery,
    create_bond,
    create_bond_out_of_band,
    remove_bond,
    cancel_bond,
    get_connection_state,
    pin_reply,
    ssp_reply,
    get_profile_interface,
    dut_mode_configure,
    dut_mode_send,
    le_test_mode,
    set_os_callouts,
    read_energy_info,
    dump,
    dumpMetrics,
    config_clear,
    interop_database_clear,
    interop_database_add,
    get_avrcp_service,
    obfuscate_address,
    get_metric_id,
    set_dynamic_audio_buffer_size,
    generate_local_oob_data,
    allow_low_latency_audio,
    clear_event_filter,
    load_remote_oob_data,
    metadata_changed};

函数名	功能说明
size	接口结构体的大小，必须设置为 sizeof(bt_interface_t)
init	初始化 Bluetooth 接口，注册回调函数，is_atv 表示是否为 Android TV
enable	启用蓝牙，可指定是否为访客模式（guest_mode）
disable	禁用蓝牙
cleanup	清理接口，释放资源
get_adapter_properties	获取蓝牙适配器的所有属性
get_adapter_property	获取指定类型的蓝牙适配器属性
set_adapter_property	设置指定类型的蓝牙适配器属性（如地址、设备名等）
get_remote_device_properties	获取远程设备的所有属性
get_remote_device_property	获取远程设备指定类型的属性
set_remote_device_property	设置远程设备指定类型的属性
get_remote_service_record	获取远程设备指定 UUID 的服务记录
get_remote_services	执行 SDP 查询，获取远程设备提供的所有服务
start_discovery	开始设备扫描（发现附近蓝牙设备）
cancel_discovery	取消设备扫描
create_bond	建立配对连接（bonding）
create_bond_out_of_band	使用 OOB 数据建立配对连接
remove_bond	移除设备配对信息
cancel_bond	取消正在进行的配对
get_connection_state	获取指定设备的连接状态（0=未连接，非0=已连接）
pin_reply	针对传统配对流程返回 PIN 码
ssp_reply	针对 SSP（安全简单配对）流程返回结果，例如确认或输入 PIN
get_profile_interface	获取指定蓝牙 profile 的接口，例如 A2DP、HFP 等
dut_mode_configure	设置 DUT（Device Under Test）模式，开启蓝牙测试模式
dut_mode_send	向控制器发送 HCI 测试命令，仅限 DUT 模式下使用
le_test_mode	发送 BLE 测试模式命令，如接收测试、发射测试等
set_os_callouts	设置 OS 层接口，如警报、唤醒锁的调用方式
read_energy_info	读取能量信息（控制器电量、耗电情况）
dump	用于 dumpsys 命令输出调试信息
config_clear	清除 /data/misc/bt_config.conf 中的蓝牙配置信息
interop_database_clear	清除设备兼容性数据库的动态部分
interop_database_add	向兼容性数据库添加设备 workarounds 条目，用于特定厂商设备问题处理

• 在 init 中我们触发创建了 bt_stack_manager_thread 线程
• android/app/jni/com_android_bluetooth_btservice_AdapterService.cpp

static bool initNative(JNIEnv* env, jobject obj, jboolean isGuest,
                       jboolean isCommonCriteriaMode, int configCompareResult,
                       jobjectArray initFlags, jboolean isAtvDevice,
                       jstring userDataDirectory) {


// 调用 init 函数
  int ret = sBluetoothInterface->init(
      &sBluetoothCallbacks, isGuest == JNI_TRUE ? 1 : 0,
      isCommonCriteriaMode == JNI_TRUE ? 1 : 0, configCompareResult, flags,
      isAtvDevice == JNI_TRUE ? 1 : 0, user_data_directory);

}

• system/btif/src/bluetooth.cc

static int init(bt_callbacks_t* callbacks, bool start_restricted,
                bool is_common_criteria_mode, int config_compare_result,
                const char** init_flags, bool is_atv,
                const char* user_data_directory) {
  (void)user_data_directory;
  LOG_INFO(
      "%s: start restricted = %d ; common criteria mode = %d, config compare "
      "result = %d",
      __func__, start_restricted, is_common_criteria_mode,
      config_compare_result);

...

  // 这里调用了 stack_manager_get_interface()
  stack_manager_get_interface()->init_stack();
  return BT_STATUS_SUCCESS;
}

• system/btif/src/stack_manager.cc

const stack_manager_t* stack_manager_get_interface() {
  ensure_manager_initialized();
  return &interface;
}

static void ensure_manager_initialized() {
  if (management_thread.IsRunning()) return;

  // 这里启动了  bt_stack_manager_thread 线程
  management_thread.StartUp();
  if (!management_thread.IsRunning()) {
    LOG_ERROR("%s unable to start stack management thread", __func__);
    return;
  }
}

1.2 如何工作的？

上面小节 介绍了 management_thread 是如何启动的，本节介绍是如何 工作的。

• system/btif/src/stack_manager.cc

static const stack_manager_t interface = {init_stack, start_up_stack_async,
                                          shut_down_stack_async, clean_up_stack,
                                          get_stack_is_running};

const stack_manager_t* stack_manager_get_interface() {
  ensure_manager_initialized();
  return &interface;
}

• stack manager 暴露了如下接口
  • init_stack -> event_init_stack
  • start_up_stack_async -> event_start_up_stack
  • shut_down_stack_async -> event_shut_down_stack
  • clean_up_stack -> event_clean_up_stack
  • get_stack_is_running -> return stack_is_running

static void init_stack() {

  semaphore_t* semaphore = semaphore_new(0);
  management_thread.DoInThread(FROM_HERE,
                               base::Bind(event_init_stack, semaphore));
  semaphore_wait(semaphore);
  semaphore_free(semaphore);
}

• management_thread.DoInThread 将 event_init_stack 任务交给 management_thread 线程处理。
• 其他接口类似

咱们就来通俗地剖析一下 bt_stack_manager_thread 的工作流程，重点分析提到的几个事件：

• event_init_stack

• event_start_up_stack

• event_shut_down_stack

• event_clean_up_stack

---

bt_stack_manager_thread 是啥？

这是一个 专门用于管理蓝牙协议栈生命周期的线程，负责按顺序执行蓝牙栈的几个重要状态转换：

1. 初始化蓝牙栈（Init）

2. 启动蓝牙栈（StartUp）

3. 关闭蓝牙栈（ShutDown）

4. 清理资源（CleanUp）

每个状态对应一个事件（event），这些事件会被派发到 bt_stack_manager_thread 这个线程去处理，避免多线程并发操作蓝牙栈带来的崩溃或竞态问题。

---

1. event_init_stack

🕰️ 触发时机：当系统 拉起 AdapterService 服务时自动触发。
🔧 做了啥：

public class AdapterService extends Service {

    static {
        classInitNative(); // 会最终触发调用 event_init_stack
    }

}

# 具体看  2.1 线程启动流程
[classInitNative] -> [sBluetoothInterface->init]

-> [stack_manager_get_interface()->init_stack()] 

👉 具体做了：

// `context`: 上层传入的信号量指针（semaphore），用于同步等待（也可能为 NULL）
    
// 函数是异步派发到 `bt_stack_manager_thread` 中执行的，避免主线程卡顿

static void event_init_stack(void* context) {
  // 如果 context 有值，表示调用方需要知道初始化是否完成（用信号量机制通知）
  semaphore_t* semaphore = (semaphore_t*)context;

  LOG_INFO("is initializing the stack");

  // 避免重复初始化，保证蓝牙栈只初始化一次
  // 在热启动或某些异常恢复流程中非常重要
  if (stack_is_initialized) {
    LOG_INFO("found the stack already in initialized state");
  } else {
    /*
    初始化内部的模块管理系统，比如创建 module 列表、管理模块状态等。所有后续 `module_init()`、`module_start_up()` 都依赖它。
    */
    module_management_start();

	// 初始化 操作系统抽象层（OSI），提供 log、alarm、semaphore、thread 管理等基础功能。
    module_init(get_local_module(OSI_MODULE));

	// 蓝牙通用工具模块，如设备地址工具、设备信息解析、通用接口辅助。
    module_init(get_local_module(BT_UTILS_MODULE));

    // 负责启动 [GD（Gabeldorsche）](https://source.android.com/docs/core/connect/bluetooth/gd) 框架中的 idle 模块，为新架构蓝牙做准备（Android 11+ 引入）。
    module_start_up(get_local_module(GD_IDLE_MODULE));

	// 负责加载并管理配置文件（`bt_config.conf`），如配对记录、配对密钥等。
    module_init(get_local_module(BTIF_CONFIG_MODULE));

	/*
	Bluetooth Interface（BTIF）层初始化，它是 JNI 和 native stack 之间的桥梁 
	例如处理 Java 层调用 enable()、disable() 等动作
	*/
    btif_init_bluetooth();

	/*
	初始化设备兼容性工作模块，用于处理某些设备的特定 workaround（如音响连接问题）
	*/
    module_init(get_local_module(INTEROP_MODULE));

	/*
	这是真正启动 classic Bluetooth stack 的核心入口：

	初始化 HCI 模块

	启动 GAP、SDP、BNEP、RFCOMM 等协议层

	注册 internal 回调机制
	*/
    bte_main_init();

	// 负责加载栈的启动参数配置，比如 Feature Flag、调试开关、协议开关等
    module_init(get_local_module(STACK_CONFIG_MODULE));

    // stack init is synchronous, so no waiting necessary here
    // 标记栈初始化完成
    stack_is_initialized = true;
  }

  LOG_INFO("finished");

	// 发信号（通知等待线程）
  if (semaphore) semaphore_post(semaphore);
}

• 调用 init_stack()：

步骤	模块	含义
1	module_management_start()	启动模块系统
2	OSI_MODULE	基础操作系统抽象
3	BT_UTILS_MODULE	蓝牙通用工具
4	GD_IDLE_MODULE	新架构蓝牙 IDLE
5	BTIF_CONFIG_MODULE	配对信息读取模块
6	btif_init_bluetooth()	初始化 JNI 层接口
7	INTEROP_MODULE	兼容性模块
8	bte_main_init()	启动 classic 蓝牙协议栈
9	STACK_CONFIG_MODULE	加载栈配置项

• event_init_stack() 负责蓝牙栈中最基础的模块初始化，所有后续功能都依赖它的正确执行。

• 如果这一步挂了，蓝牙后续一切功能都不会工作。

• 常见触发点：应用层 enable()、蓝牙重启、系统冷启动。拉起蓝牙服务时，就会触发

举例：你点开手机蓝牙开关，就会触发这个流程

---

2. event_start_up_stack

触发时机：当系统调用 开启蓝牙后， 各个profile 服务启动时，就会触发, 这里拿 GattService 举例，

01-10 01:47:11.513188  2008  2008 D GattService: doStart()

01-10 01:47:11.552258  2008  2008 D BluetoothAdapterService: processProfileServiceStateChanged: GattService, state: 12

01-10 01:47:11.552428  2008  2539 I bt_stack_manager: packages/modules/Bluetooth/system/btif/src/stack_manager.cc:283 event_start_up_stack: event_start_up_stack is bringing up the stack

static int enable() {
  if (!interface_ready()) return BT_STATUS_NOT_READY;

  stack_manager_get_interface()->start_up_stack_async();
  return BT_STATUS_SUCCESS;
}

调用流程：

[ProfileService:doStart]  -> 

[mAdapterService.onProfileServiceStateChanged(this, BluetoothAdapter.STATE_ON);] ->

[processProfileServiceStateChanged((ProfileService) msg.obj, msg.arg1);] ->

[enableNative();] ->

[sBluetoothInterface->enable();] ->

[stack_manager_get_interface()->start_up_stack_async();]

• 上层 profile server 都是继承 ProfileService 。

event_start_up_stack() 逻辑：
是 Bluetooth Stack 启动的第二阶段：event_start_up_stack()，它是在 event_init_stack() 成功执行之后调用的，用于 启动协议栈功能层模块（包括 L2CAP、SDP、GATT、A2DP、RFCOMM、HID 等），完成蓝牙的“上电”启动。

// Synchronous function to start up the stack
static void event_start_up_stack(UNUSED_ATTR void* context) {

  // 防重复启动
  if (stack_is_running) {
    LOG_INFO("%s stack already brought up", __func__);
    return;
  }
  // 如果 event_init_stack() 没跑，就跑一次，确保一切基础组件就绪
  ensure_stack_is_initialized();

  LOG_INFO("%s is bringing up the stack", __func__);


  // 创建 future，用于异步等待
  // 用来等待整个启动过程中某些异步操作完成，比如 controller 模块初始化
  future_t* local_hack_future = future_new();
  hack_future = local_hack_future;

  // 清理旧模块 + 启动新模块
  LOG_INFO("%s Gd shim module enabled", __func__);
  module_shut_down(get_local_module(GD_IDLE_MODULE)); // 关闭 GD_IDLE_MODULE（空模块）
  get_btm_client_interface().lifecycle.btm_init(); // 初始化 BTM 模块（底层管理模块）
  module_start_up(get_local_module(GD_SHIM_MODULE)); // 启动 GD_SHIM_MODULE：GD 是新蓝牙架构模块（Android 11+）
  module_start_up(get_local_module(BTIF_CONFIG_MODULE)); // BTIF_CONFIG 再次启动，以支持后续读写 

  // 初始化协议栈模块（重点）
	l2c_init();         // L2CAP 层
	sdp_init();         // 服务发现协议
	gatt_init();        // GATT 层（BLE）
	SMP_Init();         // 安全配对协议（BLE 安全）
	get_btm_client_interface().lifecycle.btm_ble_init();  // BLE BTM 层

	RFCOMM_Init();      // 串口仿真层
	BNEP_Init();        // 蓝牙以太网仿真协议
	PAN_Init();         // 个人局域网协议
	A2DP_Init();        // 高质量音频传输
	AVRC_Init();        // 遥控控制协议
	GAP_Init();         // 通用访问协议
	HID_HostInit();     // 人机交互设备（鼠标、键盘）

	bta_sys_init();     // 初始化 BTA 系统核心调度
	bta_ar_init();      // 注册音频相关 profile（如 A2DP + AVRCP）

	// 启用调试日志收集，便于排查协议过程中的问题
  module_init(get_local_module(BTE_LOGMSG_MODULE));

  // 启动主线程 bt_main_thread
  // 主线程处理主状态机事件（如连接、断开、认证请求）
  main_thread_start_up();

  // JNI Bridge 初始化完毕，通知上层
  btif_init_ok();     // JNI 层回调标志：Bluetooth Native 已准备好

  // 启动核心状态管理模块  
	BTA_dm_init();                      // Device Manager 初始化
	bta_dm_enable(bte_dm_evt);         // 启动 DM 并注册事件处理器

  // 控制器初始化 & 状态同步
	  bta_set_forward_hw_failures(true);         // 设置硬件错误转发
	btm_acl_device_down();                     // 清除旧 ACL 连接
	CHECK(module_start_up(get_local_module(GD_CONTROLLER_MODULE)));  // 控制器启动
	BTM_reset_complete();                      // 标记芯片初始化完成

  // 通知上层 “蓝牙已上电”
  BTA_dm_on_hw_on();       // 通知 BTA 层 “controller 就绪”

	// 等待异步 future 完成
  if (future_await(local_hack_future) != FUTURE_SUCCESS) {
    LOG_ERROR("%s failed to start up the stack", __func__);
    stack_is_running = true;  // So stack shutdown actually happens
    event_shut_down_stack(nullptr); // 自动触发关闭
    // 如果 controller 初始化失败，则强制回滚，触发 `event_shut_down_stack()`
    return;
  }

  // 启动成功，通知 JNI 层
  // 通知 Android Framework 蓝牙栈已准备完成，可以对外服务！
  stack_is_running = true;
  LOG_INFO("%s finished", __func__);
  do_in_jni_thread(FROM_HERE, base::Bind(event_signal_stack_up, nullptr));
}

• 启动模块（有顺序）：

  • shim, Gki, Bte_main, BTIF_CONFIG_MODULE, BTIF_CONFIG_INTERFACE

  • 启动 HCI 模块（就是控制器通信模块）

  • 启动 profile，如 A2DP、HFP 等

• 设置 HAL 状态为 BT_STATE_ON

• 回调通知上层 “蓝牙启动成功”

功能	内容
协议层初始化	L2CAP、SDP、GATT、SMP
Profile 初始化	A2DP、AVRCP、HID、PAN、RFCOMM
Controller 初始化	启动蓝牙芯片控制器通信能力
上报系统状态	通知 JNI “蓝牙栈已准备”
错误回滚	如果启动失败，立即关闭蓝牙栈防止残留

举例：你点开蓝牙开关之后，系统蓝牙图标亮起，表示可以连接设备了

---

3. event_shut_down_stack

触发时机：调用 disable() 或系统关机前触发

event_shut_down_stack() 做的事：
这是 Bluetooth 栈生命周期中第三阶段：event_shut_down_stack()。它负责在关闭蓝牙或失败回滚时，干净、安全地关闭所有协议模块、资源清理、通知上层状态变更。

static void event_shut_down_stack(UNUSED_ATTR void* context) {
 // 防止重复关闭
  if (!stack_is_running) {
    LOG_INFO("%s stack is already brought down", __func__);
    return;
  }

  LOG_INFO("%s is bringing down the stack", __func__);

  // 创建异步 future + 设置状态
  // 后续异步流程依然使用 `future` 来等待任务结束
  future_t* local_hack_future = future_new();
  hack_future = local_hack_future;
  stack_is_running = false;

  // 清理 BLE 功能, 这些操作是异步的，在 `main_thread` 中执行
  do_in_main_thread(FROM_HERE, base::Bind(&btm_ble_multi_adv_cleanup)); // 清理 BLE 广播（BLE Advertising）

  do_in_main_thread(FROM_HERE, base::Bind(&btm_ble_scanner_cleanup)); // 清理 BLE 扫描器（BLE Scanner）


  // 清理 Profile 层, 将所有对外连接/监听都关闭
  
	btif_dm_on_disable();    // 关闭设备管理模块
	btif_sock_cleanup();     // 清除 socket server
	btif_pan_cleanup();      // PAN profile 清理


  // 停止设备管理
  // `bta_dm_disable()` 停止连接管理、bonding、搜索等
  do_in_main_thread(FROM_HERE, base::Bind(bta_dm_disable));
  // 等待任务完成，确保状态稳定
  future_await(local_hack_future);

  // 协议核心关闭
  local_hack_future = future_new();
  hack_future = local_hack_future;

	bta_sys_disable();                 // 停止 BTA 系统任务调度
	bta_set_forward_hw_failures(false);  // 关闭错误转发
	BTA_dm_on_hw_off();               // 通知 BTA 硬件已断电

  // 模块卸载
	module_shut_down(get_local_module(BTIF_CONFIG_MODULE));

  future_await(local_hack_future); // 等待卸载完成

	main_thread_shut_down();         // 主线程停止任务调度


 // 内存释放：GATT/SDP/L2CAP/BTM
 // 完全释放底层协议分配的资源和内存
  module_clean_up(get_local_module(BTE_LOGMSG_MODULE));  // 日志系统清理
	gatt_free();
	sdp_free();
	l2c_free();
	get_btm_client_interface().lifecycle.btm_ble_free();   // BLE BTM 释放

  LOG_INFO("%s Gd shim module disabled", __func__);
  // 关闭 GD 模块，恢复 Idle 状态
  
  module_shut_down(get_local_module(GD_SHIM_MODULE));  // GD 模块关闭
	get_btm_client_interface().lifecycle.btm_free();     // BTM 模块释放
	module_start_up(get_local_module(GD_IDLE_MODULE));   // 回归 idle 模块状态

 // 通知 JNI：蓝牙栈已关闭
 // 通知 Android Framework，**蓝牙状态 = 已关闭**
  hack_future = future_new();
  do_in_jni_thread(FROM_HERE, base::Bind(event_signal_stack_down, nullptr));
  future_await(hack_future);
  LOG_INFO("%s finished", __func__);
}

步骤	动作
异步清理 BLE 功能模块	多播、扫描器
清理 Profile 服务	socket、PAN
停止设备管理任务	bta_dm_disable
关闭主线程	清理主事件调度系统
清除协议栈内存	gatt, sdp, l2cap 等
切换模块状态	GD_SHIM → GD_IDLE
通知 Android 上层	蓝牙栈关闭完成

• 停用所有模块（reverse 顺序）

  • 先断开 Profile（如 A2DP、HFP）

  • 再停 HCI、BTIF、Main、Gki、Shim 等

• 设置 HAL 状态为 BT_STATE_OFF

• 回调通知上层 “蓝牙已关闭”

举例：你点关蓝牙，会先触发这个阶段

---

4. event_clean_up_stack

触发时机：shut_down_stack() 执行完后触发

``event_clean_up_stack() 做的事：

static void event_clean_up_stack(std::promise<void> promise) {
  if (!stack_is_initialized) {
    LOG_INFO("%s found the stack already in a clean state", __func__);
    goto cleanup;
  }

  ensure_stack_is_not_running();

  LOG_INFO("%s is cleaning up the stack", __func__);
  stack_is_initialized = false;

  btif_cleanup_bluetooth();

  module_clean_up(get_local_module(STACK_CONFIG_MODULE));
  module_clean_up(get_local_module(INTEROP_MODULE));

  module_clean_up(get_local_module(BTIF_CONFIG_MODULE));
  module_clean_up(get_local_module(BT_UTILS_MODULE));
  module_clean_up(get_local_module(OSI_MODULE));
  module_shut_down(get_local_module(GD_IDLE_MODULE));
  module_management_stop();
  LOG_INFO("%s finished", __func__);

cleanup:;
  promise.set_value();
}

• 完全清理模块管理器 module_clean_up(get_module_manager())

• 释放 alarm、timer、logging 等资源

• 蓝牙模块生命周期彻底结束，等待下一次 init

举例：系统重启中、蓝牙长时间不用需要彻底释放资源

1.3 Bluetooth Stack 生命周期概览

阶段	关键函数	功能	核心动作
初始化	event_init_stack()	准备 Stack 的基本模块	初始化模块、配置、btif_init_bluetooth() 等
启动	event_start_up_stack()	启动完整蓝牙协议栈	启动 L2CAP/GATT/A2DP 等，初始化 BTM、BTA
关闭	event_shut_down_stack()	停止蓝牙协议栈	停止 BTA、释放协议栈模块
清理	event_clean_up_stack()	完全清理所有模块	清除 BTIF/UTILS/OSI 模块，停止管理器

---

event_init_stack()

• 触发时机：bt_interface_t.init() 时，Bluetooth HAL 初始化蓝牙栈。

• 作用：初始化蓝牙相关基础模块。

• 关键逻辑：

  • 检查是否已初始化（stack_is_initialized）

  • 启动模块管理器

  • 初始化：OSI_MODULE, BT_UTILS_MODULE, INTEROP_MODULE, STACK_CONFIG_MODULE

  • 初始化蓝牙框架层：btif_init_bluetooth(), bte_main_init()

  • 设置标志：stack_is_initialized = true

---

event_start_up_stack()

• 作用：启动所有核心蓝牙协议。

• 关键逻辑：

  • 启动 BTIF_CONFIG 模块、关闭 GD_IDLE 模块，初始化 BLE 和 GATT 协议等

  • 启动协议层模块：L2CAP、RFCOMM、A2DP、HID、GAP、AVRCP、BNEP、PAN 等

  • 启动 BTA（Bluetooth Application layer）

  • 通知 JNI 层：event_signal_stack_up

---

event_shut_down_stack()

• 作用：优雅地关闭所有协议模块，释放资源。

• 关键逻辑：

  • 调用 cleanup 方法：btif_dm_on_disable, btif_sock_cleanup 等

  • 关闭：BTA、GATT、L2CAP、GAP、BNEP、SHIM、BTM

  • 通知 JNI：event_signal_stack_down

---

event_clean_up_stack()

• 作用：彻底清理蓝牙栈模块和资源。

• 关键逻辑：

  • 只有在 stack_is_initialized 为 true 且 stack 已停止时执行

  • 清理：BTIF_CONFIG, INTEROP, STACK_CONFIG, OSI, BT_UTILS

  • 停止模块管理器