当前位置： 首页 > news >正文

【Bluedriod】蓝牙协议栈GD模块(GD_SHIM_MODULE)启动机制及源码解析

news 2025/6/2 20:12:54

本文深入剖析Android蓝牙协议栈中GD模块的启动机制，从模块生命周期管理、状态转换、异步初始化，到核心组件（HCI层、协议栈管理器、广播/扫描/测距模块）的协同运作。通过源码分析揭示蓝牙协议栈如何通过分层设计实现硬件抽象化、事件驱动和线程安全管理，揭示了蓝牙协议栈从模块加载到功能就绪的底层实现细节，为理解蓝牙系统的模块化架构与跨层交互提供了技术视角。

一、概述

1.1 模块启动核心流程与生命周期管理

1. 模块启动入口 module_start_up

  • 参数校验：确保模块指针有效且状态合法（已初始化或无需初始化）。

  • 异步执行：通过call_lifecycle_function统一处理同步 / 异步回调，支持模块生命周期函数（如start_up）的异步执行与结果等待。

  • 状态管理：使用线程安全的哈希表metadata记录模块状态（INITIALIZED→STARTED），确保多线程环境下的状态一致性。

2. 模块注册表与查找机制

  • 线性查找：通过get_local_module遍历module_table实现模块名称到实例的映射，支持按名称动态查找模块（如GD_SHIM_MODULE）。

  • 依赖管理：模块注册表（ModuleRegistry）维护启动顺序与依赖关系，确保组件按拓扑排序启动（如先初始化 HCI 层，再启动协议栈）。

1.2 GD_SHIM 模块与协议栈启动逻辑

1. GD_SHIM 模块初始化

  • HCI 层接口获取：通过hci_layer_get_interface初始化 HCI 层，注册数据回调post_to_main_message_loop实现硬件数据向上层的传递。

  • 协议栈启动：调用bluetooth::shim::Stack::GetInstance()->StartEverything()触发协议栈启动，初始化基础模块（如metrics、HciHal）并启动核心组件（如 ACL 管理器、扫描管理器）。

2. 协议栈核心类 Stack

  • 单例模式：确保系统中仅有一个协议栈实例，避免资源冲突。

  • 线程管理：创建专用实时线程gd_stack_thread运行协议栈，确保蓝牙通信的低延迟与实时性。

  • 模块初始化：通过ModuleList添加基础模块，调用StackManager::StartUp实现模块依赖解析与启动，确保组件按序初始化（如先启动存储模块，再启动 HCI 控制器模块）。

1.3 HCI 层事件注册与数据流向

1. 事件注册机制

  • 标准 HCI 事件：通过register_event_code筛选关键事件（如加密状态变更、PIN 码请求），调用RegisterEventHandler绑定回调event_callback，将事件数据传递给上层。

  • LE 子事件：通过register_subevent_code过滤 LE 子事件（如连接完成、路径损耗阈值），调用RegisterLeEventHandler绑定回调subevent_callback，处理 BLE 元事件。

  • 供应商特定事件：注册厂商自定义事件（如 BQR 事件），通过专用回调处理硬件扩展功能。

2. 数据流向控制

  • 硬件到上层：HCI 层接收到控制器数据后，通过send_data_upwards回调将事件数据包装为BT_HDR*，传递给 L2CAP、GATT 等上层协议。

  • 上层到硬件：上层数据经分片器（packet_fragmenter）分割为 HCI 可处理的片段，通过transmit_command发送到控制器。

1.4 关键组件初始化与回调机制

1. 广播与扫描管理器

  • 广播初始化：init_advertising_manager创建广播管理器单例，注册底层回调AdvertisingCallback，处理广播集启动、数据设置等事件。

  • 扫描初始化：init_scanning_manager注册扫描回调ScanningCallback，支持设备发现与广播数据接收，同步更新周期性同步管理器回调。

2. 距离测量管理器

  • 功能初始化：init_distance_measurement_manager注册距离测量回调DistanceMeasurementCallbacks，处理测量启动、结果上报等事件，支持基于 BLE 的距离与角度测量。

3. 回调线程管理

  • 跨线程通信：通过do_in_jni_thread和do_in_main_thread确保回调在正确线程执行（如 JNI 回调在 Java 线程，底层逻辑在协议栈线程），避免线程安全问题。

二、源码分析

module_start_up(get_local_module(GD_SHIM_MODULE))

packages/modules/Bluetooth/system/btcore/src/module.cc
bool module_start_up(const module_t* module) {// 1. 参数校验CHECK(module != NULL);// TODO(zachoverflow): remove module->init check once automagic order/call is// in place.// This hack is here so modules which don't require init don't have to have// useless calls// as we're converting the startup sequence.// 2. 状态校验（已初始化 或 不需要初始化）CHECK(get_module_state(module) == MODULE_STATE_INITIALIZED ||module->init == NULL);log::info("Starting module \"{}\"", module->name);// 3. 执行启动回调if (!call_lifecycle_function(module->start_up)) {log::error("Failed to start up module \"{}\"", module->name);return false;}log::info("Started module \"{}\"", module->name);// 4. 状态更新set_module_state(module, MODULE_STATE_STARTED);return true;
}packages/modules/Bluetooth/system/btcore/include/module.h
// 每个生命周期函数返回一个 future_t 指针，说明蓝牙模块的初始化过程是异步的
typedef future_t* (*module_lifecycle_fn)(void);#define BTCORE_MAX_MODULE_DEPENDENCIES 10// 模块的基本结构
typedef struct {const char* name{nullptr};// 四个生命周期函数指针（初始化、启动、关闭、清理）module_lifecycle_fn init{nullptr};module_lifecycle_fn start_up{nullptr};module_lifecycle_fn shut_down{nullptr};module_lifecycle_fn clean_up{nullptr};const char* dependencies[BTCORE_MAX_MODULE_DEPENDENCIES]{nullptr};
} module_t;

模块的启动流程为：

  • 检查模块指针有效性

  • 验证模块状态（必须已初始化或无需初始化）

  • 调用模块的 start_up 生命周期函数

  • 根据调用结果设置模块状态并返回执行结果

call_lifecycle_function

packages/modules/Bluetooth/system/btcore/src/module.cc
static bool call_lifecycle_function(module_lifecycle_fn function) {// A NULL lifecycle function means it isn't needed, so assume successif (!function) return true;future_t* future = function();// A NULL future means synchronous successif (!future) return true; // 表示操作已同步完成且成功。这是同步执行模式的标志// Otherwise fall back to the futurereturn future_await(future); // 等待异步操作完成，并返回最终结果。这是异步执行模式
}

执行模块的生命周期回调（如初始化、启动、关闭等），并根据执行结果返回成功或失败。它的特别之处在于能够统一处理同步和异步两种执行模式。

更新模块状态:set_module_state

packages/modules/Bluetooth/system/btcore/src/module.cc
// 使用线程安全的哈希表存储模块状态
// TODO(jamuraa): remove this lock after the startup sequence is clean
static std::mutex metadata_mutex; // 存储每个模块指针到状态的映射
static std::unordered_map<const module_t*, module_state_t> metadata; // 保护共享数据的互斥锁// 模块的三种状态
typedef enum {MODULE_STATE_NONE = 0, // 初始状态，模块未被初始化MODULE_STATE_INITIALIZED = 1, // 模块已初始化，可启动MODULE_STATE_STARTED = 2 // 模块已启动并运行中
} module_state_t;static void set_module_state(const module_t* module, module_state_t state) {std::lock_guard<std::mutex> lock(metadata_mutex);metadata[module] = state;
}

使用 RAII 风格的std::lock_guard自动管理锁的生命周期，保证在多线程环境下状态更新的原子性。状态转换遵循严格的顺序：NONE → INITIALIZED → STARTED。

模块查找实现:get_local_module

packages/modules/Bluetooth/system/btif/src/stack_manager.cc
// 模块注册表设计
const struct module_lookup module_table[] = {{BTE_LOGMSG_MODULE, &bte_logmsg_module},{BTIF_CONFIG_MODULE, &btif_config_module},{GD_CONTROLLER_MODULE, &gd_controller_module},{GD_SHIM_MODULE, &gd_shim_module},{INTEROP_MODULE, &interop_module},{OSI_MODULE, &osi_module},{RUST_MODULE, &rust_module},{STACK_CONFIG_MODULE, &stack_config_module},{DEVICE_IOT_CONFIG_MODULE, &device_iot_config_module},{NULL, NULL},
};inline const module_t* get_local_module(const char* name) {size_t len = strlen(name);// 线性查找：遍历模块表进行字符串比较for (const struct module_lookup* l = module_table; l->module; l++) {if (strncmp(l->name, name, len) == 0) {return l->module;}}log::fatal("Cannot find module {}, aborting", name);return nullptr;
}

模块注册表与之前分析的模块生命周期管理系统配合：

1. get_local_module提供按名称查找模块实例的能力

2. 返回的module_t*可用于：

  • 调用生命周期函数（start_up/shut_down）
  • 查询模块状态（通过metadata映射）
  • 解析模块依赖关系

gd_shim_module

packages/modules/Bluetooth/system/main/shim/shim.ccEXPORT_SYMBOL extern const module_t gd_shim_module = {.name = GD_SHIM_MODULE,.init = kUnusedModuleApi,.start_up = ShimModuleStartUp,.shut_down = GeneralShutDown,.clean_up = kUnusedModuleApi,.dependencies = {kUnusedModuleDependencies}};packages/modules/Bluetooth/system/main/shim/shim.h
static const char GD_SHIM_MODULE[] = "gd_shim_module";
constexpr module_lifecycle_fn kUnusedModuleApi = nullptr;
constexpr char* kUnusedModuleDependencies = nullptr;

仅实现必要的生命周期函数（start_up/shut_down）。符合 "接口隔离原则"，避免实现无用功能。

ShimModuleStartUp

packages/modules/Bluetooth/system/main/shim/shim.cc
static future_t* ShimModuleStartUp() {// 通过工厂函数获取 HCI 层接口实例hci = bluetooth::shim::hci_layer_get_interface();  ASSERT_LOG(hci, "%s could not get hci layer interface.", __func__);// 设置数据回调:当 HCI 层接收到数据时，将通过post_to_main_message_loop转发到主线程处理hci->set_data_cb(base::Bind(&post_to_main_message_loop));// 使用单例模式获取协议栈实例，启动整个蓝牙协议栈bluetooth::shim::Stack::GetInstance()->StartEverything();return kReturnImmediate;
}

GD_SHIM 模块的启动逻辑，主要完成 HCI 层初始化和蓝牙协议栈的启动。

hci_layer_get_interface

packages/modules/Bluetooth/system/main/shim/hci_layer.cc
// HCI 层接口实现
static hci_t interface = {.set_data_cb = set_data_cb, // 设置数据回调函数，用于接收来自硬件的数据.transmit_command = transmit_command, // 发送 HCI 命令到硬件.transmit_downward = transmit_downward}; // 发送数据到下层static const packet_fragmenter_callbacks_t* callbacks;// 该接口提供与蓝牙硬件通信的抽象方法
const hci_t* bluetooth::shim::hci_layer_get_interface() {packet_fragmenter = packet_fragmenter_get_interface();packet_fragmenter->init(&packet_fragmenter_callbacks);return &interface;
}packages/modules/Bluetooth/system/hci/src/packet_fragmenter.cc
// 数据包分片器实现
static const packet_fragmenter_t interface = {init, // 初始化分片器并设置回调cleanup,fragment_and_dispatch, // 分片并分发数据包reassemble_and_dispatch // 重组并分发数据包};const packet_fragmenter_t* packet_fragmenter_get_interface() {buffer_allocator = buffer_allocator_get_interface();return &interface;
}static void init(const packet_fragmenter_callbacks_t* result_callbacks) {callbacks = result_callbacks;
}

初始化流程：

  • 获取数据包分片器接口

  • 初始化分片器并注册回调

  • 返回 HCI 接口实例

数据包分片功能职责：

  • 分片：将上层较大的数据包分割为 HCI 层可处理的片段

  • 重组：将来自 HCI 层的片段重新组装为完整数据包

数据流向：

  • 向上：硬件数据 → HCI 层 → 分片器重组 → 上层协议

  • 向下：上层数据 → 分片器分片 → HCI 层 → 硬件

回调机制：

  • HCI 层通过packet_fragmenter_callbacks_t向分片器注册回调

  • 分片器处理完成后通过回调通知 HCI 层

set_data_cb

static void set_data_cb(base::Callback<void(const base::Location&, BT_HDR*)> send_data_cb) {send_data_upwards = std::move(send_data_cb);
}

bluetooth::shim::Stack::GetInstance()->StartEverything()

bluetooth::shim::Stack

packages/modules/Bluetooth/system/main/shim/stack.h
// The shim layer implementation on the Gd stack side.
namespace bluetooth {
namespace shim {// GD shim stack, having modes corresponding to legacy stack
class Stack {public:// 单例模式static Stack* GetInstance();Stack() = default;Stack(const Stack&) = delete;Stack& operator=(const Stack&) = delete;~Stack() = default;// 生命周期管理// Running mode, everything is upvoid StartEverything(); // 启动所有蓝牙模块void Stop();bool IsRunning();bool IsDumpsysModuleStarted() const;// 组件访问接口StackManager* GetStackManager();const StackManager* GetStackManager() const;legacy::Acl* GetAcl();LinkPolicyInterface* LinkPolicy();Btm* GetBtm();os::Handler* GetHandler();void LockForDumpsys(std::function<void()> dumpsys_callback);// Start the list of modules with the given stack manager threadvoid StartModuleStack(const ModuleList* modules, const os::Thread* thread);// Run the callable object on the module instancetemplate <typename T>bool CallOnModule(std::function<void(T* mod)> run) {std::lock_guard<std::recursive_mutex> lock(Stack::GetInstance()->mutex_);if (Stack::GetInstance()->is_running_) {run(Stack::GetInstance()->GetStackManager()->GetInstance<T>());return true;}return false;}size_t NumModules() const { return num_modules_; }private:mutable std::recursive_mutex mutex_; // 使用递归锁允许同一线程多次加锁StackManager stack_manager_;bool is_running_ = false;os::Thread* stack_thread_ = nullptr; // 协议栈专用线程os::Handler* stack_handler_ = nullptr; // 消息处理句柄，用于异步操作legacy::Acl* acl_ = nullptr;Btm* btm_ = nullptr;size_t num_modules_{0};void Start(ModuleList* modules);
};}  // namespace shim
}  // namespace bluetooth

蓝牙协议栈的核心管理类Stack，负责协调和控制整个蓝牙协议栈的运行。

bluetooth::shim::Stack::GetInstance()

packages/modules/Bluetooth/system/main/shim/stack.cc
Stack* Stack::GetInstance() {static Stack instance;return &instance;
}

单例模式确保系统中只有一个协议栈实例，避免资源冲突，所有组件通过统一接口访问，避免资源竞争和状态不一致问题。

StartEverything

packages/modules/Bluetooth/system/main/shim/stack.cc
void Stack::StartEverything() {std::lock_guard<std::recursive_mutex> lock(mutex_);ASSERT_LOG(!is_running_, "%s Gd stack already running", __func__);LOG_INFO("%s Starting Gd stack", __func__);ModuleList modules;// 1. 添加基础模块modules.add<metrics::CounterMetrics>();modules.add<hal::HciHal>();modules.add<hci::HciLayer>();modules.add<storage::StorageModule>();modules.add<shim::Dumpsys>();modules.add<hci::VendorSpecificEventManager>();modules.add<sysprops::SyspropsModule>();modules.add<hci::Controller>();modules.add<hci::acl_manager::AclScheduler>();modules.add<hci::AclManager>();modules.add<hci::RemoteNameRequestModule>();modules.add<hci::LeAdvertisingManager>();modules.add<hci::MsftExtensionManager>();modules.add<hci::LeScanningManager>();modules.add<hci::DistanceMeasurementManager>();// 2. 启动模块Start(&modules);is_running_ = true;// 3. 验证关键模块已启动// Make sure the leaf modules are startedASSERT(stack_manager_.GetInstance<storage::StorageModule>() != nullptr);ASSERT(stack_manager_.GetInstance<shim::Dumpsys>() != nullptr);// 4. 初始化ACL层if (stack_manager_.IsStarted<hci::Controller>()) {acl_ = new legacy::Acl(stack_handler_, legacy::GetAclInterface(),controller_get_interface()->get_ble_acceptlist_size(),controller_get_interface()->get_ble_resolving_list_max_size());} else {LOG_ERROR("Unable to create shim ACL layer as Controller has not started");}// 5. 初始化各类管理器bluetooth::shim::hci_on_reset_complete();bluetooth::shim::init_advertising_manager();bluetooth::shim::init_scanning_manager();bluetooth::shim::init_distance_measurement_manager();
}

蓝牙协议栈的完整启动流程，通过模块化方式初始化各个组件。

Stack::Start

packages/modules/Bluetooth/system/main/shim/stack.cc
void Stack::Start(ModuleList* modules) {ASSERT_LOG(!is_running_, "%s Gd stack already running", __func__);LOG_INFO("%s Starting Gd stack", __func__);// 1. 创建专用线程stack_thread_ =new os::Thread("gd_stack_thread", os::Thread::Priority::REAL_TIME); // 设置为实时优先级，确保蓝牙通信的及时性// 2. 启动模块管理器stack_manager_.StartUp(modules, stack_thread_);// 3. 创建消息处理器stack_handler_ = new os::Handler(stack_thread_);LOG_INFO("%s Successfully toggled Gd stack", __func__);
}

创建专用线程、初始化模块管理器和消息处理系统。使蓝牙协议栈能够在独立的实时线程中运行，确保关键通信任务得到及时处理。通过模块管理器和消息处理系统的协同工作，实现了组件间的解耦和异步通信，提高了系统的可维护性和可靠性。

StackManager::StartUp

packages/modules/Bluetooth/system/gd/stack_manager.cc
void StackManager::StartUp(ModuleList* modules, Thread* stack_thread) {// 1. 创建管理线程和处理器management_thread_ = new Thread("management_thread", Thread::Priority::NORMAL);handler_ = new Handler(management_thread_);// 2. 获取唤醒锁，防止系统休眠WakelockManager::Get().Acquire();// 3. 异步执行初始化std::promise<void> promise;auto future = promise.get_future();handler_->Post(common::BindOnce(&StackManager::handle_start_up, common::Unretained(this), modules, stack_thread,std::move(promise)));// 4. 等待初始化完成或超时auto init_status = future.wait_for(std::chrono::milliseconds(get_gd_stack_timeout_ms(/* is_start = */ true)));// 5. 释放唤醒锁WakelockManager::Get().Release();LOG_INFO("init_status == %d", init_status);ASSERT_LOG(init_status == std::future_status::ready,"Can't start stack, last instance: %s",registry_.last_instance_.c_str());LOG_INFO("init complete");
}

蓝牙协议栈的启动管理逻辑，包含线程创建、异步初始化和超时控制等关键机制。

stack_manager_.IsStarted<hci::Controller>()

packages/modules/Bluetooth/system/main/shim/stack.h
StackManager stack_manager_;// 对外提供模块生命周期管理接口（StartUp/ShutDown）// 负责创建管理线程和消息处理器// 通过 ModuleRegistry 实现模块的注册与启动
namespace bluetooth {class StackManager {public:void StartUp(ModuleList *modules, os::Thread* stack_thread);void ShutDown();template <class T>T* GetInstance() const {return static_cast<T*>(registry_.Get(&T::Factory));}packages/modules/Bluetooth/system/gd/stack_manager.htemplate <class T>bool IsStarted() const {return registry_.IsStarted(&T::Factory);}private:os::Thread* management_thread_ = nullptr;os::Handler* handler_ = nullptr;ModuleRegistry registry_;void handle_start_up(ModuleList* modules, os::Thread* stack_thread, std::promise<void> promise);void handle_shut_down(std::promise<void> promise);static std::chrono::milliseconds get_gd_stack_timeout_ms(bool is_start);
};}  // namespace bluetoothpackages/modules/Bluetooth/system/gd/module.h
// 维护模块注册表和启动顺序// 提供模块查找、启动状态查询等功能// 实现依赖解析和拓扑排序
class ModuleRegistry {friend Module;friend ModuleDumper;friend class StackManager;public:template <class T>bool IsStarted() const {return IsStarted(&T::Factory);}bool IsStarted(const ModuleFactory* factory) const;// Start all the modules on this list and their dependencies// in dependency ordervoid Start(ModuleList* modules, ::bluetooth::os::Thread* thread);template <class T>T* Start(::bluetooth::os::Thread* thread) {return static_cast<T*>(Start(&T::Factory, thread));}Module* Start(const ModuleFactory* id, ::bluetooth::os::Thread* thread);// Stop all running modules in reverse order of startvoid StopAll();protected:Module* Get(const ModuleFactory* module) const;void set_registry_and_handler(Module* instance, ::bluetooth::os::Thread* thread) const;os::Handler* GetModuleHandler(const ModuleFactory* module) const;std::map<const ModuleFactory*, Module*> started_modules_;std::vector<const ModuleFactory*> start_order_;std::string last_instance_;
};

蓝牙协议栈的模块注册与管理系统，是整个架构的核心基础设施。通过严格的依赖管理和拓扑排序，确保了系统组件按正确顺序启动，提高了系统的稳定性和可维护性。

bluetooth::shim::hci_on_reset_complete()

packages/modules/Bluetooth/system/main/shim/hci_layer.cc
// 负责将 HCI 事件数据向上层（如 L2CAP、GATT 等协议层）传递
// 所有 HCI 层相关的操作共享同一个回调，确保数据上传路径的统一性和线程安全性
static base::Callback<void(const base::Location&, BT_HDR*)> send_data_upwards;void bluetooth::shim::hci_on_reset_complete() {ASSERT(send_data_upwards);// 1. 标准 HCI 事件注册for (uint16_t event_code_raw = 0; event_code_raw < 0x100; event_code_raw++) {auto event_code = static_cast<bluetooth::hci::EventCode>(event_code_raw);if (!register_event_code(event_code)) { // 判断当前事件是否需要注册continue;}//注册逻辑：调用底层实现（通过 HCI 命令LE Set Event Mask或Set Event Mask）,告知控制器上报该事件cpp::register_event(event_code); }//  2. LE 子事件注册:BLE的扩展事件，例如连接完成、广播报告等，通过子事件码（8 位，0x00~0xFF）标识for (uint16_t subevent_code_raw = 0; subevent_code_raw < 0x100;subevent_code_raw++) {auto subevent_code =static_cast<bluetooth::hci::SubeventCode>(subevent_code_raw);if (!register_subevent_code(subevent_code)) { // 过滤需要关注的子事件continue;}cpp::register_le_event(subevent_code); // 通知控制器上报这些 LE 子事件}// 3. 供应商特定事件注册:蓝牙 SIG 允许厂商自定义扩展事件（如高通的 BQR 事件），用于实现专有功能// TODO handle BQR event in GDbluetooth::shim::GetVendorSpecificEventManager()->RegisterEventHandler(bluetooth::hci::VseSubeventCode::BQR_EVENT,get_main_thread()->Bind(cpp::vendor_specific_event_callback));// 4. ISO事件注册：蓝牙 5.2 引入的等时同步通道，用于传输实时音频、视频等数据cpp::register_for_iso();
}

当蓝牙控制器（Controller）完成复位操作后，Host（主机）需要告知控制器：哪些 HCI 事件（Event）、LE（低功耗蓝牙）子事件（Subevent）、供应商特定事件（Vendor Specific Event）以及 ISO（等时同步）事件需要被上报。hci_on_reset_complete函数的作用就是完成这些事件的注册，建立从硬件到上层协议栈的事件传递通道。

register_event_code & register_subevent_code

packages/modules/Bluetooth/system/main/shim/hci_layer.cc
namespace {
// HCI 事件过滤:判断是否需要注册标准 HCI 事件（非低功耗蓝牙事件）
// 通过switch-case白名单机制，仅允许特定类型的事件被注册。
bool register_event_code(bluetooth::hci::EventCode event_code) {switch (event_code) {// SCOcase bluetooth::hci::EventCode::SYNCHRONOUS_CONNECTION_COMPLETE: // 同步连接完成事件（用于语音通话等实时同步业务）case bluetooth::hci::EventCode::SYNCHRONOUS_CONNECTION_CHANGED: // 同步连接参数变更事件（如带宽、延迟变化）// SecurityEventscase bluetooth::hci::EventCode::ENCRYPTION_CHANGE:        // 加密状态变更case bluetooth::hci::EventCode::PIN_CODE_REQUEST:         // PIN码请求（传统配对）case bluetooth::hci::EventCode::LINK_KEY_REQUEST:         // 链路密钥请求case bluetooth::hci::EventCode::LINK_KEY_NOTIFICATION:   // 链路密钥通知case bluetooth::hci::EventCode::ENCRYPTION_KEY_REFRESH_COMPLETE:  // 加密密钥刷新完成case bluetooth::hci::EventCode::IO_CAPABILITY_REQUEST:    // IO能力请求（安全配对）case bluetooth::hci::EventCode::IO_CAPABILITY_RESPONSE:   // IO能力响应case bluetooth::hci::EventCode::REMOTE_OOB_DATA_REQUEST:// 远程OOB数据请求（带外数据配对）case bluetooth::hci::EventCode::SIMPLE_PAIRING_COMPLETE:  // 简单配对完成case bluetooth::hci::EventCode::USER_PASSKEY_NOTIFICATION:// 用户密钥通知（数字输入配对）case bluetooth::hci::EventCode::USER_CONFIRMATION_REQUEST:// 用户确认请求（确认配对）case bluetooth::hci::EventCode::USER_PASSKEY_REQUEST:     // 用户密钥请求（输入PIN码）return true;default:// 除上述事件外，其他 HCI 事件不会被注册，避免硬件上报无关数据，减少资源消耗return false;}
};// LE 子事件过滤:判断是否需要注册LE子事件
static bool register_subevent_code(bluetooth::hci::SubeventCode subevent_code) {switch (subevent_code) {case bluetooth::hci::SubeventCode::READ_REMOTE_FEATURES_COMPLETE: // 读取对端特性完成（连接初始化）case bluetooth::hci::SubeventCode::LONG_TERM_KEY_REQUEST: // 长期密钥请求case bluetooth::hci::SubeventCode::READ_LOCAL_P256_PUBLIC_KEY_COMPLETE: // 读取本地P256公钥完成（安全配对）case bluetooth::hci::SubeventCode::GENERATE_DHKEY_COMPLETE: // 生成DH密钥完成（安全配对）case bluetooth::hci::SubeventCode::CHANNEL_SELECTION_ALGORITHM: // 信道选择算法事件（优化连接稳定性）case bluetooth::hci::SubeventCode::CONNECTIONLESS_IQ_REPORT: // 无连接IQ报告（用于定位）case bluetooth::hci::SubeventCode::CONNECTION_IQ_REPORT: // 连接IQ报告（用于定位）case bluetooth::hci::SubeventCode::CTE_REQUEST_FAILED: // CTE（信道状态信息）请求失败case bluetooth::hci::SubeventCode::CIS_ESTABLISHED: // 同步连接（CIS）建立完成case bluetooth::hci::SubeventCode::CIS_REQUEST: // 同步连接请求case bluetooth::hci::SubeventCode::CREATE_BIG_COMPLETE: // 创建广播等时组（BIG）完成case bluetooth::hci::SubeventCode::TERMINATE_BIG_COMPLETE: // 终止BIG完成case bluetooth::hci::SubeventCode::BIG_SYNC_ESTABLISHED:  // BIG同步建立case bluetooth::hci::SubeventCode::BIG_SYNC_LOST:  // BIG同步丢失case bluetooth::hci::SubeventCode::REQUEST_PEER_SCA_COMPLETE: // 请求对端SCA（安全连接认证）完成case bluetooth::hci::SubeventCode::PATH_LOSS_THRESHOLD: // 路径损耗阈值事件（用于连接管理）return true;default: // 仅明确列出的 LE 子事件会被注册，其他子事件被忽略，确保协议栈聚焦于当前支持的功能return false;}
}}  // namespace

两个事件过滤函数（register_event_code和register_subevent_code），位于匿名命名空间内，仅在当前文件可见。它们筛选需要注册的 HCI 事件（Event）和 LE 子事件（Subevent），确保蓝牙协议栈只关注与当前功能相关的事件，避免冗余数据上报，提升系统效率。

register_event

packages/modules/Bluetooth/system/main/shim/hci_layer.cc
static void register_event(bluetooth::hci::EventCode event_code) {// 获取事件处理器（Handler）auto handler = bluetooth::shim::GetGdShimHandler();// 绑定回调函数到处理器, 向 HCI 层注册事件处理bluetooth::shim::GetHciLayer()->RegisterEventHandler(event_code, handler->Bind(event_callback));
}

为指定的 HCI 事件注册一个事件回调函数（event_callback）。当蓝牙控制器（硬件）上报该事件时，HCI 层会触发此回调，将事件数据传递给上层协议栈处理。

RegisterEventHandler

packages/modules/Bluetooth/system/gd/hci/hci_layer.cc
void HciLayer::RegisterEventHandler(EventCode event, ContextualCallback<void(EventView)> handler) {CallOn(impl_, &impl::register_event, event, handler);
}std::map<EventCode, ContextualCallback<void(EventView)>> event_handlers_;void register_event(EventCode event, ContextualCallback<void(EventView)> handler) {//  禁止注册 LE_META_EVENT 事件ASSERT_LOG(event != EventCode::LE_META_EVENT,"Can not register handler for %02hhx (%s)",EventCode::LE_META_EVENT,EventCodeText(EventCode::LE_META_EVENT).c_str());// CONNECTION_REQUEST 事件的特殊处理// Allow GD Cert tests to register for CONNECTION_REQUESTif (event == EventCode::CONNECTION_REQUEST && module_.on_acl_connection_request_.IsEmpty()) {LOG_INFO("Registering test for CONNECTION_REQUEST, since there's no ACL");event_handlers_.erase(event);}//  防止重复注册事件处理器ASSERT_LOG(event_handlers_.count(event) == 0,"Can not register a second handler for %02hhx (%s)",event,EventCodeText(event).c_str());    //注册事件处理器event_handlers_[event] = handler;}

将上层传入的事件处理器（handler）与特定 HCI 事件（event）绑定，并通过断言和校验确保注册操作的安全性和唯一性。

将事件（event）与对应的处理器（handler）存入event_handlers_映射表，完成最终的注册。当蓝牙控制器上报该事件时，HCI 层会从event_handlers_中查找并调用对应的处理器。

event_callback

packages/modules/Bluetooth/system/main/shim/hci_layer.cc
static void event_callback(bluetooth::hci::EventView event_packet_view) {if (!send_data_upwards) {return;}send_data_upwards.Run(FROM_HERE, WrapPacketAndCopy(MSG_HC_TO_STACK_HCI_EVT,&event_packet_view));
}

蓝牙协议栈中 HCI（Host Controller Interface）层事件处理的 “最后一公里”，负责将硬件上报的 HCI 事件数据向上传递给上层协议栈（如 L2CAP、安全管理器等）。当 HCI 层从蓝牙控制器（硬件）接收到特定事件时，将事件数据包装成上层协议栈可识别的格式，并通过全局回调send_data_upwards传递给上层处理。

register_le_event

packages/modules/Bluetooth/system/main/shim/hci_layer.cc
static void register_le_event(bluetooth::hci::SubeventCode subevent_code) {auto handler = bluetooth::shim::GetGdShimHandler();bluetooth::shim::GetHciLayer()->RegisterLeEventHandler(subevent_code, handler->Bind(subevent_callback));
}

为指定的 LE 子事件注册一个子事件回调函数（subevent_callback）。当蓝牙控制器（硬件）上报该 LE 子事件时，HCI 层会触发此回调，将事件数据传递给上层协议栈处理。

RegisterLeEventHandler

packages/modules/Bluetooth/system/gd/hci/hci_layer.cc
void HciLayer::RegisterLeEventHandler(SubeventCode event, ContextualCallback<void(LeMetaEventView)> handler) {CallOn(impl_, &impl::register_le_event, event, handler);
}// 存储已注册的 LE 子事件与回调的映射
std::map<SubeventCode, ContextualCallback<void(LeMetaEventView)>> subevent_handlers_;void register_le_event(SubeventCode event, ContextualCallback<void(LeMetaEventView)> handler) {ASSERT_LOG(subevent_handlers_.count(event) == 0,"Can not register a second handler for %02hhx (%s)",event,SubeventCodeText(event).c_str());subevent_handlers_[event] = handler;
}

蓝牙 HCI 层对BLE子事件的注册管理机制，是 BLE 协议栈处理 LE 元事件（LE_META_EVENT）及其子事件的核心基础设施。将子事件（event）与对应的回调（handler）存入subevent_handlers_，完成最终绑定。

HCI 层的典型处理流程如下：

  • 蓝牙控制器上报LE_META_EVENT，其有效载荷包含一个或多个 LE 子事件（如CONNECTION_COMPLETE）。

  • HCI 层解析LE_META_EVENT的有效载荷，提取子事件码（SubeventCode）和子事件数据（LeMetaEventView）。

  • HCI 层根据子事件码在subevent_handlers_中查找对应的回调，并调用该回调处理子事件数据。

subevent_callback

packages/modules/Bluetooth/system/main/shim/hci_layer.cc
static void subevent_callback(bluetooth::hci::LeMetaEventView le_meta_event_view) {if (!send_data_upwards) {return;}send_data_upwards.Run(FROM_HERE, WrapPacketAndCopy(MSG_HC_TO_STACK_HCI_EVT,&le_meta_event_view));
}

蓝牙协议栈中低功耗蓝牙LE 子事件（Subevent）处理的 “最后一公里”，负责将 HCI 层接收到的 LE 子事件数据向上传递给上层协议栈（如 L2CAP、GATT 等）。当 HCI 层从蓝牙控制器（硬件）接收到 LE 元事件（LE_META_EVENT）并解析出其中的 LE 子事件（由le_meta_event_view表示）时，将子事件数据包装成上层协议栈可识别的格式，并通过全局回调send_data_upwards传递给上层处理。

bluetooth::shim::init_advertising_manager()

packages/modules/Bluetooth/system/main/shim/le_advertising_manager.cc
namespace {
constexpr char kBtmLogTag[] = "ADV";
}class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface,public bluetooth::hci::AdvertisingCallback {public:~BleAdvertiserInterfaceImpl() override{};void Init() {// Register callbackbluetooth::shim::GetAdvertising()->RegisterAdvertisingCallback(this);}void RegisterAdvertiser(IdStatusCallback cb) override {LOG(INFO) << __func__ << " in shim layer";bluetooth::shim::GetAdvertising()->RegisterAdvertiser(bluetooth::shim::GetGdShimHandler()->BindOnce([](IdStatusCallback cb, uint8_t id, uint8_t status) {do_in_main_thread(FROM_HERE,base::BindOnce([](IdStatusCallback cb, uint8_t id,uint8_t status) { cb.Run(id, status); },cb, id, status));},cb));}void Unregister(uint8_t advertiser_id) override {LOG(INFO) << __func__ << " in shim layer";bluetooth::shim::GetAdvertising()->RemoveAdvertiser(advertiser_id);int reg_id =bluetooth::shim::GetAdvertising()->GetAdvertiserRegId(advertiser_id);uint8_t client_id = is_native_advertiser(reg_id);// if registered by native client, remove the register idif (client_id != kAdvertiserClientIdJni) {native_reg_id_map[client_id].erase(reg_id);}BTM_LogHistory(kBtmLogTag, RawAddress::kEmpty, "Le advert stopped",base::StringPrintf("advert_id:%d", advertiser_id));}void GetOwnAddress(uint8_t advertiser_id, GetAddressCallback cb) override {LOG(INFO) << __func__ << " in shim layer";address_callbacks_[advertiser_id] = jni_thread_wrapper(FROM_HERE, cb);bluetooth::shim::GetAdvertising()->GetOwnAddress(advertiser_id);}void SetParameters(uint8_t advertiser_id, AdvertiseParameters params,ParametersCallback /* cb */) override {LOG(INFO) << __func__ << " in shim layer";bluetooth::hci::AdvertisingConfig config{};parse_parameter(config, params);bluetooth::shim::GetAdvertising()->SetParameters(advertiser_id, config);}void SetData(int advertiser_id, bool set_scan_rsp, vector<uint8_t> data,StatusCallback /* cb */) override {LOG(INFO) << __func__ << " in shim layer";std::vector<GapData> advertising_data = {};parse_gap_data(data, advertising_data);bluetooth::shim::GetAdvertising()->SetData(advertiser_id, set_scan_rsp,advertising_data);}void Enable(uint8_t advertiser_id, bool enable, StatusCallback /* cb */,uint16_t duration, uint8_t maxExtAdvEvents,StatusCallback /* timeout_cb */) override {LOG(INFO) << __func__ << " in shim layer";bluetooth::shim::GetAdvertising()->EnableAdvertiser(advertiser_id, enable, duration, maxExtAdvEvents);}// nobody use this functionvoid StartAdvertising(uint8_t advertiser_id, StatusCallback cb,AdvertiseParameters params,std::vector<uint8_t> advertise_data,std::vector<uint8_t> scan_response_data, int timeout_s,StatusCallback timeout_cb) override {LOG(INFO) << __func__ << " in shim layer";bluetooth::hci::AdvertisingConfig config{};parse_parameter(config, params);parse_gap_data(advertise_data, config.advertisement);parse_gap_data(scan_response_data, config.scan_response);bluetooth::shim::GetAdvertising()->StartAdvertising(advertiser_id, config, timeout_s * 100, cb, timeout_cb, scan_callback,set_terminated_callback, bluetooth::shim::GetGdShimHandler());}void StartAdvertisingSet(uint8_t client_id, int reg_id,IdTxPowerStatusCallback /* register_cb */,AdvertiseParameters params,std::vector<uint8_t> advertise_data,std::vector<uint8_t> scan_response_data,PeriodicAdvertisingParameters periodic_params,std::vector<uint8_t> periodic_data,uint16_t duration, uint8_t maxExtAdvEvents,IdStatusCallback /* timeout_cb */) {LOG(INFO) << __func__ << " in shim layer";bluetooth::hci::AdvertisingConfig config{};parse_parameter(config, params);parse_periodic_advertising_parameter(config.periodic_advertising_parameters,periodic_params);parse_gap_data(advertise_data, config.advertisement);parse_gap_data(scan_response_data, config.scan_response);parse_gap_data(periodic_data, config.periodic_data);// if registered by native client, add the register idif (client_id != kAdvertiserClientIdJni) {native_reg_id_map[client_id].insert(reg_id);}bluetooth::shim::GetAdvertising()->ExtendedCreateAdvertiser(client_id, reg_id, config, scan_callback, set_terminated_callback,duration, maxExtAdvEvents, bluetooth::shim::GetGdShimHandler());LOG_INFO("create advertising set, client_id:%d, reg_id:%d", client_id,reg_id);BTM_LogHistory(kBtmLogTag, RawAddress::kEmpty, "Le advert started",base::StringPrintf("reg_id:%d", reg_id));return;}void SetPeriodicAdvertisingParameters(int advertiser_id, PeriodicAdvertisingParameters periodic_params,StatusCallback /* cb */) override {LOG(INFO) << __func__ << " in shim layer";bluetooth::hci::PeriodicAdvertisingParameters parameters;parameters.max_interval = periodic_params.max_interval;parameters.min_interval = periodic_params.min_interval;parameters.properties = periodic_params.periodic_advertising_properties;bluetooth::shim::GetAdvertising()->SetPeriodicParameters(advertiser_id,parameters);}void SetPeriodicAdvertisingData(int advertiser_id, std::vector<uint8_t> data,StatusCallback /* cb */) override {LOG(INFO) << __func__ << " in shim layer";std::vector<GapData> advertising_data = {};parse_gap_data(data, advertising_data);bluetooth::shim::GetAdvertising()->SetPeriodicData(advertiser_id,advertising_data);}void SetPeriodicAdvertisingEnable(int advertiser_id, bool enable,bool include_adi,StatusCallback /* cb */) override {LOG(INFO) << __func__ << " in shim layer";bluetooth::shim::GetAdvertising()->EnablePeriodicAdvertising(advertiser_id, enable, include_adi);}void RegisterCallbacks(AdvertisingCallbacks* callbacks) {advertising_callbacks_ = callbacks;}void RegisterCallbacksNative(AdvertisingCallbacks* callbacks,uint8_t client_id) {native_adv_callbacks_map_[client_id] = callbacks;}void on_scan(Address /* address */, AddressType /* address_type */) {LOG(INFO) << __func__ << " in shim layer";}void on_set_terminated(ErrorCode /* error_code */, uint8_t, uint8_t) {LOG(INFO) << __func__ << " in shim layer";}const bluetooth::common::Callback<void(Address, AddressType)> scan_callback =bluetooth::common::Bind(&BleAdvertiserInterfaceImpl::on_scan,bluetooth::common::Unretained(this));const bluetooth::common::Callback<void(ErrorCode, uint8_t, uint8_t)>set_terminated_callback = bluetooth::common::Bind(&BleAdvertiserInterfaceImpl::on_set_terminated,bluetooth::common::Unretained(this));// AdvertisingCallbackvoid OnAdvertisingSetStarted(int reg_id, uint8_t advertiser_id,int8_t tx_power,AdvertisingStatus status) override {uint8_t client_id = is_native_advertiser(reg_id);if (client_id != kAdvertiserClientIdJni) {// Invoke callback for native clientdo_in_main_thread(FROM_HERE,base::Bind(&AdvertisingCallbacks::OnAdvertisingSetStarted,base::Unretained(native_adv_callbacks_map_[client_id]),reg_id, advertiser_id, tx_power, status));return;}do_in_jni_thread(FROM_HERE,base::BindOnce(&AdvertisingCallbacks::OnAdvertisingSetStarted,base::Unretained(advertising_callbacks_), reg_id,advertiser_id, tx_power, status));}void OnAdvertisingEnabled(uint8_t advertiser_id, bool enable,uint8_t status) {int reg_id =bluetooth::shim::GetAdvertising()->GetAdvertiserRegId(advertiser_id);uint8_t client_id = is_native_advertiser(reg_id);if (client_id != kAdvertiserClientIdJni) {// Invoke callback for native clientdo_in_main_thread(FROM_HERE,base::Bind(&AdvertisingCallbacks::OnAdvertisingEnabled,base::Unretained(native_adv_callbacks_map_[client_id]),advertiser_id, enable, status));return;}do_in_jni_thread(FROM_HERE,base::BindOnce(&AdvertisingCallbacks::OnAdvertisingEnabled,base::Unretained(advertising_callbacks_),advertiser_id, enable, status));}void OnAdvertisingDataSet(uint8_t advertiser_id, uint8_t status) {do_in_jni_thread(FROM_HERE,base::BindOnce(&AdvertisingCallbacks::OnAdvertisingDataSet,base::Unretained(advertising_callbacks_),advertiser_id, status));}void OnScanResponseDataSet(uint8_t advertiser_id, uint8_t status) {do_in_jni_thread(FROM_HERE, base::BindOnce(&AdvertisingCallbacks::OnScanResponseDataSet,base::Unretained(advertising_callbacks_),advertiser_id, status));}void OnAdvertisingParametersUpdated(uint8_t advertiser_id, int8_t tx_power,uint8_t status) {do_in_jni_thread(FROM_HERE,base::BindOnce(&AdvertisingCallbacks::OnAdvertisingParametersUpdated,base::Unretained(advertising_callbacks_), advertiser_id,tx_power, status));}void OnPeriodicAdvertisingParametersUpdated(uint8_t advertiser_id,uint8_t status) {do_in_jni_thread(FROM_HERE,base::BindOnce(&AdvertisingCallbacks::OnPeriodicAdvertisingParametersUpdated,base::Unretained(advertising_callbacks_), advertiser_id, status));}void OnPeriodicAdvertisingDataSet(uint8_t advertiser_id, uint8_t status) {do_in_jni_thread(FROM_HERE,base::BindOnce(&AdvertisingCallbacks::OnPeriodicAdvertisingDataSet,base::Unretained(advertising_callbacks_), advertiser_id,status));}void OnPeriodicAdvertisingEnabled(uint8_t advertiser_id, bool enable,uint8_t status) {do_in_jni_thread(FROM_HERE,base::BindOnce(&AdvertisingCallbacks:azwsx:OnPeriodicAdvertisingEnabled,base::Unretained(advertising_callbacks_), advertiser_id,enable, status));}void OnOwnAddressRead(uint8_t advertiser_id, uint8_t address_type,bluetooth::hci::Address address) {RawAddress raw_address = bluetooth::ToRawAddress(address);if (address_callbacks_.find(advertiser_id) != address_callbacks_.end()) {address_callbacks_[advertiser_id].Run(address_type, raw_address);address_callbacks_.erase(advertiser_id);return;}do_in_jni_thread(FROM_HERE,base::BindOnce(&AdvertisingCallbacks::OnOwnAddressRead,base::Unretained(advertising_callbacks_),advertiser_id, address_type, raw_address));}AdvertisingCallbacks* advertising_callbacks_;std::map<uint8_t, AdvertisingCallbacks*> native_adv_callbacks_map_;private:void parse_parameter(bluetooth::hci::AdvertisingConfig& config,AdvertiseParameters params) {config.connectable = params.advertising_event_properties & 0x01;config.scannable = params.advertising_event_properties & 0x02;config.discoverable = params.advertising_event_properties & 0x04;config.legacy_pdus = params.advertising_event_properties & 0x10;config.anonymous = params.advertising_event_properties & 0x20;config.include_tx_power = params.advertising_event_properties & 0x40;config.interval_min = params.min_interval;config.interval_max = params.max_interval;config.channel_map = params.channel_map;config.tx_power = params.tx_power;config.use_le_coded_phy = params.primary_advertising_phy == 0x03;config.secondary_advertising_phy =static_cast<bluetooth::hci::SecondaryPhyType>(params.secondary_advertising_phy);config.enable_scan_request_notifications =static_cast<bluetooth::hci::Enable>(params.scan_request_notification_enable);// Matching the ADDRESS_TYPE_* enums from Javaswitch (params.own_address_type) {case -1:config.requested_advertiser_address_type =AdvertiserAddressType::RESOLVABLE_RANDOM;break;case 0:config.requested_advertiser_address_type =AdvertiserAddressType::PUBLIC;break;case 1:config.requested_advertiser_address_type =AdvertiserAddressType::RESOLVABLE_RANDOM;break;case 2:config.requested_advertiser_address_type =AdvertiserAddressType::NONRESOLVABLE_RANDOM;break;default:LOG_ERROR("Received unexpected address type: %d",params.own_address_type);config.requested_advertiser_address_type =AdvertiserAddressType::RESOLVABLE_RANDOM;}}void parse_periodic_advertising_parameter(bluetooth::hci::PeriodicAdvertisingParameters& config,PeriodicAdvertisingParameters periodic_params) {config.max_interval = periodic_params.max_interval;config.min_interval = periodic_params.min_interval;config.properties = periodic_params.periodic_advertising_properties;config.enable = periodic_params.enable;config.include_adi = periodic_params.include_adi;}uint8_t is_native_advertiser(int reg_id) {// Return client id if it's native advertiser, otherwise return jni id as// defaultfor (auto const& entry : native_adv_callbacks_map_) {if (native_reg_id_map[entry.first].count(reg_id)) {return entry.first;}}return kAdvertiserClientIdJni;}std::map<uint8_t, GetAddressCallback> address_callbacks_;std::map<uint8_t, std::set<int>> native_reg_id_map;
};BleAdvertiserInterfaceImpl* bt_le_advertiser_instance = nullptr;BleAdvertiserInterface* bluetooth::shim::get_ble_advertiser_instance() {if (bt_le_advertiser_instance == nullptr) {bt_le_advertiser_instance = new BleAdvertiserInterfaceImpl();}return bt_le_advertiser_instance;
};void bluetooth::shim::init_advertising_manager() {static_cast<BleAdvertiserInterfaceImpl*>(bluetooth::shim::get_ble_advertiser_instance())->Init();
}

bluetooth::shim::init_advertising_manager() 是蓝牙协议栈中BLE 广播管理器的初始化入口函数，通过单例模式初始化广播管理器实例，并注册底层广播回调，确保上层业务逻辑能够接收并处理广播相关事件（如广播集启动、数据设置完成）。是 BLE 广播功能（如设备发现、广播数据发送）正常运行的前提条件。建立底层 HCI 广告模块与上层业务逻辑之间的事件回调通道。

init_advertising_manager 的核心职责是：

  1. 获取 BLE 广播管理器的单例实例（BleAdvertiserInterfaceImpl）。

  2. 触发该实例的初始化逻辑（Init方法），完成广播回调的注册，确保底层广播事件能传递到上层。

LeAdvertisingManager::RegisterAdvertisingCallback

packages/modules/Bluetooth/system/gd/hci/le_advertising_manager.cc
void LeAdvertisingManager::RegisterAdvertisingCallback(AdvertisingCallback* advertising_callback) {CallOn(pimpl_.get(), &impl::register_advertising_callback, advertising_callback);
}class AdvertisingCallback {public:enum AdvertisingStatus {SUCCESS,DATA_TOO_LARGE,TOO_MANY_ADVERTISERS,ALREADY_STARTED,INTERNAL_ERROR,FEATURE_UNSUPPORTED};virtual ~AdvertisingCallback() = default;virtual void OnAdvertisingSetStarted(int reg_id, uint8_t advertiser_id, int8_t tx_power, AdvertisingStatus status) = 0;virtual void OnAdvertisingEnabled(uint8_t advertiser_id, bool enable, uint8_t status) = 0;virtual void OnAdvertisingDataSet(uint8_t advertiser_id, uint8_t status) = 0;virtual void OnScanResponseDataSet(uint8_t advertiser_id, uint8_t status) = 0;virtual void OnAdvertisingParametersUpdated(uint8_t advertiser_id, int8_t tx_power, uint8_t status) = 0;virtual void OnPeriodicAdvertisingParametersUpdated(uint8_t advertiser_id, uint8_t status) = 0;virtual void OnPeriodicAdvertisingDataSet(uint8_t advertiser_id, uint8_t status) = 0;virtual void OnPeriodicAdvertisingEnabled(uint8_t advertiser_id, bool enable, uint8_t status) = 0;virtual void OnOwnAddressRead(uint8_t advertiser_id, uint8_t address_type, Address address) = 0;
};AdvertisingCallback* advertising_callbacks_ = nullptr;
void register_advertising_callback(AdvertisingCallback* advertising_callback) {advertising_callbacks_ = advertising_callback;
}

BLE广播管理模块中回调注册接口，负责建立底层广播操作与上层业务逻辑之间的事件通知通道。允许上层注册一个广播事件回调接口（AdvertisingCallback），当 BLE 广告模块完成关键操作（如广播集启动、广播数据设置）或发生异常时，底层通过此接口通知上层，触发相应的业务逻辑（如更新 UI 状态、处理错误）。

bluetooth::shim::init_scanning_manager()

packages/modules/Bluetooth/system/main/shim/le_scanning_manager.cc
BleScannerInterfaceImpl* bt_le_scanner_instance = nullptr;BleScannerInterface* bluetooth::shim::get_ble_scanner_instance() {if (bt_le_scanner_instance == nullptr) {bt_le_scanner_instance = new BleScannerInterfaceImpl();}return bt_le_scanner_instance;
}void bluetooth::shim::init_scanning_manager() {static_cast<BleScannerInterfaceImpl*>(bluetooth::shim::get_ble_scanner_instance())->Init();
}void BleScannerInterfaceImpl::Init() {LOG_INFO("init BleScannerInterfaceImpl");bluetooth::shim::GetScanning()->RegisterScanningCallback(this);if (bluetooth::shim::GetMsftExtensionManager()) {bluetooth::shim::GetMsftExtensionManager()->SetScanningCallback(this);}
}void BleScannerInterfaceImpl::Init() {LOG_INFO("init BleScannerInterfaceImpl");bluetooth::shim::GetScanning()->RegisterScanningCallback(this);if (bluetooth::shim::GetMsftExtensionManager()) {bluetooth::shim::GetMsftExtensionManager()->SetScanningCallback(this);}
}

蓝牙协议栈中BLE 扫描管理器的初始化入口函数，完成扫描模块的初始化流程，建立底层扫描模块与上层业务逻辑之间的事件回调通道，确保扫描功能（如设备发现、广播数据接收）能够正常工作。

init_scanning_manager 的核心职责是：

  1. 获取 BLE 扫描管理器的单例实例（BleScannerInterfaceImpl）。

  2. 触发该实例的初始化逻辑（Init方法），完成扫描回调的注册，确保底层扫描事件能传递到上层。

init_scanning_manager 是扫描功能的初始化起点，其调用链通常如下：

蓝牙模块启动 → init_scanning_manager() → 获取单例实例 → 调用Init() → 注册扫描回调 → 扫描功能就绪

后续的扫描操作（如StartScan、StopScan、SetScanParameters）均依赖此初始化完成的回调通道：

  • 上层通过BleScannerInterface接口（如StartScan）发起扫描操作。

  • 底层扫描模块执行操作后（如接收到广播数据），通过ScanningCallback接口（如OnScanResult）通知BleScannerInterfaceImpl。

  • BleScannerInterfaceImpl再将事件转发到上层业务（如 JNI 回调或应用层），触发设备发现、数据解析等逻辑。

register_scanning_callback

packages/modules/Bluetooth/system/gd/hci/le_scanning_manager.cc
void LeScanningManager::RegisterScanningCallback(ScanningCallback* scanning_callback) {CallOn(pimpl_.get(), &impl::register_scanning_callback, scanning_callback);
}ScanningCallback* scanning_callbacks_ = &null_scanning_callback_;
PeriodicSyncManager periodic_sync_manager_{&null_scanning_callback_};void register_scanning_callback(ScanningCallback* scanning_callbacks) {scanning_callbacks_ = scanning_callbacks; // 更新主扫描回调periodic_sync_manager_.SetScanningCallback(scanning_callbacks_); // 同步周期性同步管理器的回调
}void SetScanningCallback(ScanningCallback* callbacks) {callbacks_ = callbacks;
}

BLE扫描模块中扫描回调注册函数，负责将上层实现的扫描回调接口（ScanningCallback）注册到底层扫描模块（LeScanningManager），并同步更新周期性同步管理器（PeriodicSyncManager）的回调，确保所有扫描相关事件（包括普通扫描和周期性同步事件）能够通过同一回调接口通知上层。

假设上层（如 JNI 层）需要接收 BLE 扫描结果：

  1. 上层实现ScanningCallback接口，重写OnScanResult（扫描到设备）、OnPeriodicSyncEstablished（周期性同步建立）等方法。

  2. 上层调用LeScanningManager::RegisterScanningCallback(impl)，触发register_scanning_callback。

  3. scanning_callbacks_被更新为上层的impl，periodic_sync_manager_也同步设置该回调。

  4. 底层扫描模块接收到普通广播数据时，调用scanning_callbacks_->OnScanResult(...)通知上层。

  5. 底层周期性同步管理器建立同步时，调用callbacks_->OnPeriodicSyncEstablished(...)（通过periodic_sync_manager_的callbacks_）通知上层。

bluetooth::shim::init_distance_measurement_manager()

packages/modules/Bluetooth/system/main/shim/distance_measurement_manager.cc
using bluetooth::hci::DistanceMeasurementErrorCode;
using bluetooth::hci::DistanceMeasurementMethod;class DistanceMeasurementInterfaceImpl: public DistanceMeasurementInterface,public bluetooth::hci::DistanceMeasurementCallbacks {public:~DistanceMeasurementInterfaceImpl() override{};void Init() {// Register callbackbluetooth::shim::GetDistanceMeasurementManager()->RegisterDistanceMeasurementCallbacks(this);}void RegisterDistanceMeasurementCallbacks(::DistanceMeasurementCallbacks* callbacks) {distance_measurement_callbacks_ = callbacks;}void StartDistanceMeasurement(RawAddress raw_address, uint16_t interval,uint8_t method) {bluetooth::shim::GetDistanceMeasurementManager()->StartDistanceMeasurement(bluetooth::ToGdAddress(raw_address), interval,static_cast<DistanceMeasurementMethod>(method));}void StopDistanceMeasurement(RawAddress raw_address, uint8_t method) {bluetooth::shim::GetDistanceMeasurementManager()->StopDistanceMeasurement(bluetooth::ToGdAddress(raw_address),static_cast<DistanceMeasurementMethod>(method));}void OnDistanceMeasurementStarted(bluetooth::hci::Address address,DistanceMeasurementMethod method) override {do_in_jni_thread(FROM_HERE,base::BindOnce(&::DistanceMeasurementCallbacks::OnDistanceMeasurementStarted,base::Unretained(distance_measurement_callbacks_),bluetooth::ToRawAddress(address), static_cast<uint8_t>(method)));}void OnDistanceMeasurementStartFail(bluetooth::hci::Address address, DistanceMeasurementErrorCode reason,DistanceMeasurementMethod method) override {do_in_jni_thread(FROM_HERE,base::BindOnce(&::DistanceMeasurementCallbacks::OnDistanceMeasurementStartFail,base::Unretained(distance_measurement_callbacks_),bluetooth::ToRawAddress(address), static_cast<uint8_t>(reason),static_cast<uint8_t>(method)));}void OnDistanceMeasurementStopped(bluetooth::hci::Address address,DistanceMeasurementErrorCode reason,DistanceMeasurementMethod method) override {do_in_jni_thread(FROM_HERE,base::BindOnce(&::DistanceMeasurementCallbacks::OnDistanceMeasurementStopped,base::Unretained(distance_measurement_callbacks_),bluetooth::ToRawAddress(address), static_cast<uint8_t>(reason),static_cast<uint8_t>(method)));}void OnDistanceMeasurementResult(bluetooth::hci::Address address,uint32_t centimeter,uint32_t error_centimeter, int azimuth_angle,int error_azimuth_angle, int altitude_angle,int error_altitude_angle,DistanceMeasurementMethod method) override {do_in_jni_thread(FROM_HERE,base::BindOnce(&::DistanceMeasurementCallbacks::OnDistanceMeasurementResult,base::Unretained(distance_measurement_callbacks_),bluetooth::ToRawAddress(address), centimeter, error_centimeter,azimuth_angle, error_azimuth_angle, altitude_angle,error_altitude_angle, static_cast<uint8_t>(method)));}private:::DistanceMeasurementCallbacks* distance_measurement_callbacks_;
};DistanceMeasurementInterfaceImpl* distance_measurement_instance = nullptr;void bluetooth::shim::init_distance_measurement_manager() {static_cast<DistanceMeasurementInterfaceImpl*>(bluetooth::shim::get_distance_measurement_instance())->Init(); // 触发实例初始化
}DistanceMeasurementInterface*
bluetooth::shim::get_distance_measurement_instance() {if (distance_measurement_instance == nullptr) {distance_measurement_instance = new DistanceMeasurementInterfaceImpl();}return distance_measurement_instance;
};

bluetooth::shim::init_distance_measurement_manager() 是蓝牙协议栈中距离测量（Distance Measurement）功能的初始化入口函数，完成距离测量模块的初始化流程，建立底层距离测量功能与上层业务逻辑之间的事件回调通道，确保距离测量操作（如启动、停止、结果上报）能够正常工作。

init_distance_measurement_manager 的核心职责：

  1. 获取距离测量管理器的单例实例（DistanceMeasurementInterfaceImpl）。

  2. 触发该实例的初始化逻辑（Init方法），完成底层距离测量回调的注册，确保底层距离测量事件能传递到上层。

后续的距离测量操作（如StartDistanceMeasurement、StopDistanceMeasurement）均依赖此初始化完成的回调通道：

  1. 上层发起操作：上层（如应用层或 JNI 层）通过DistanceMeasurementInterface接口（如StartDistanceMeasurement）发起距离测量请求。

  2. 底层执行操作：底层距离测量模块（如 HCI 层或 GD 层）执行测量操作（如与对端设备协商测量参数、采集信号强度 / 角度数据）。

  3. 底层事件通知：底层完成操作后（如测量启动成功、获取到测量结果），通过DistanceMeasurementCallbacks接口（如OnDistanceMeasurementStarted、OnDistanceMeasurementResult）通知DistanceMeasurementInterfaceImpl。

  4. 上层处理事件：DistanceMeasurementInterfaceImpl将事件通过do_in_jni_thread转发到 JNI 线程，调用上层的::DistanceMeasurementCallbacks回调（如更新 UI 显示距离、处理错误提示）。

RegisterDistanceMeasurementCallbacks

packages/modules/Bluetooth/system/gd/hci/distance_measurement_manager.cc
void DistanceMeasurementManager::RegisterDistanceMeasurementCallbacks(DistanceMeasurementCallbacks* callbacks) {CallOn(pimpl_.get(), &impl::register_distance_measurement_callbacks, callbacks);
}class DistanceMeasurementCallbacks {public:virtual ~DistanceMeasurementCallbacks() = default;virtual void OnDistanceMeasurementStarted(Address address, DistanceMeasurementMethod method) = 0;virtual void OnDistanceMeasurementStartFail(Address address, DistanceMeasurementErrorCode reason, DistanceMeasurementMethod method) = 0;virtual void OnDistanceMeasurementStopped(Address address, DistanceMeasurementErrorCode reason, DistanceMeasurementMethod method) = 0;virtual void OnDistanceMeasurementResult(Address address,uint32_t centimeter,uint32_t error_centimeter,int azimuth_angle,int error_azimuth_angle,int altitude_angle,int error_altitude_angle,DistanceMeasurementMethod method) = 0;
};DistanceMeasurementCallbacks* distance_measurement_callbacks_;
void register_distance_measurement_callbacks(DistanceMeasurementCallbacks* callbacks) {distance_measurement_callbacks_ = callbacks;
}

DistanceMeasurementManager::RegisterDistanceMeasurementCallbacks 是BLE距离测量模块中回调注册的核心接口，负责建立底层距离测量操作与上层业务逻辑之间的事件通知通道。当 BLE 距离测量模块完成关键操作（如测量启动、结果生成）或发生异常时，底层通过此接口通知上层，触发相应的业务逻辑（如更新 UI 显示距离、处理启动失败错误）。

典型的距离测量流程如下：

  1. 上层注册回调：上层（如DistanceMeasurementInterfaceImpl）通过RegisterDistanceMeasurementCallbacks注册自己的DistanceMeasurementCallbacks实现。

  2. 发起测量操作：上层调用DistanceMeasurementManager的接口（如StartDistanceMeasurement）发起测量请求。

  3. 底层执行与事件通知：底层距离测量模块（如 HCI 层或 GD 层）执行测量操作（如与对端设备协商参数、采集信号数据）后，通过distance_measurement_callbacks_调用注册的回调方法（如OnDistanceMeasurementStarted、OnDistanceMeasurementResult），向上层反馈结果（如成功 / 失败状态、距离值、角度数据等）。

  4. 上层处理事件：上层根据回调参数（如DistanceMeasurementErrorCode）更新状态（如 UI 显示测量中）或处理错误（如提示用户设备不支持测量）。

三、路程图

模块注册与启动流程

GD_SHIM 模块启动与 HCI 层初始化

HCI 事件注册与过滤流程

BLE 扫描管理器初始化与回调注册

距离测量模块初始化流程

四、总结

Bluedriod 的模块启动机制通过模块化设计、异步回调与线程安全控制，实现蓝牙协议栈的高效初始化与稳定运行。核心设计亮点包括：

  1. 生命周期抽象：通过module_t统一管理模块的初始化、启动、关闭流程，支持同步 / 异步执行模式，提升框架灵活性。

  2. 硬件无关性：HCI 层与协议栈的解耦设计（如hci_layer_get_interface），使得上层逻辑不依赖具体硬件实现，增强跨平台兼容性。

  3. 事件驱动架构：通过事件注册与回调机制（如AdvertisingCallback、ScanningCallback），实现底层硬件事件与上层业务逻辑的解耦，便于功能扩展与维护。

  4. 实时性保障：专用线程（gd_stack_thread）与实时优先级设置，确保蓝牙通信任务在复杂系统环境下的及时响应。

此机制为蓝牙设备的连接管理、数据传输、安全配对等核心功能提供了底层支撑，是 Bluedriod 协议栈高效运行的基石。通过理解模块启动流程与回调机制，更好地进行协议栈定制、性能优化及跨层问题定位。

http://www.xdnf.cn/news/743383.html

相关文章：

  • LXQt修改开始菜单高亮
  • 第12讲、Odoo 18 权限控制机制详解
  • kafka核心组件
  • Java数据结构之ArrayList（如果想知道Java中有关ArrayList的知识点，那么只看这一篇就足够了！）
  • MySql（九）
  • 【stm32开发板】单片机最小系统原理图设计
  • 基于大模型的数据库MCP Server设计与实现
  • 自动驾驶系统研发系列—端到端自动驾驶：愿景、陷阱与现实博弈
  • 跟单业务并发量分析
  • MonitorSDK_性能监控（从Web Vital性能指标、PerformanceObserver API和具体代码实现）
  • vue3 el-input type=“textarea“ 字体样式 及高度设置
  • 《Effective Python》第六章 推导式和生成器——避免在推导式中使用超过两个控制子表达式
  • 生活小记啊
  • 核心机制三:连接管理(三次握手)
  • Ollama：本地大模型推理与应用的创新平台
  • 2025年- H62-Lc170--34.在排序数组中查找元素的第一个和最后一个位置(2次二分查找，标记向左寻找，标记向右寻找）--Java版
  • 记一次idea中lombok无法使用的解决方案
  • 设计模式——简单工厂模式（创建型）
  • 【深度学习】16. Deep Generative Models：生成对抗网络（GAN）
  • Windows上用FFmpeg采集摄像头推流 → MediaMTX服务器转发流 → WSL2上拉流播放
  • GIS常见数据及主要应用综述：类型解析、应用案例与未来趋势全景解读
  • 通过mqtt 发布温湿度
  • 【机器学习基础】机器学习入门核心算法：XGBoost 和 LightGBM
  • 江科大IIC读取MPU6050hal库实现
  • C++中 newdelete 与 mallocfree 的异同详解
  • 【深度学习】14. DL在CV中的应用章：目标检测: R-CNN, Fast R-CNN, Faster R-CNN, MASK R-CNN
  • 【Linux 学习计划】-- 进程地址空间
  • 使用 Let‘s Encrypt 和 Certbot 为 Cloudflare 托管的域名申请 SSL 证书
  • Reactor 和 Preactor
  • LeetCode - 876. 链表的中间结点