android Bluetooth Controller Module start up流程分析

/ android / 没有评论 / 1237浏览

用到的代码文件

vendor/mediatek/proprietary/packages/apps/Bluetooth/:
src/com/android/bluetooth/btservice/AdapterService.java
jni/com_android_bluetooth_btservice_AdapterService.cpp

system/bt/:
btif/src/bluetooth.cc
btif/src/stack_manager.cc
btif/src/btif_core.cc
stack/btu/btu_init.cc
stack/btu/btu_task.cc
stack/btm/btm_devctl.cc
bta/sys/bta_sys_main.cc
bta/dm/bta_dm_api.cc
bta/dm/bta_dm_main.cc
bta/dm/bta_dm_act.cc
btcore/src/module.cc
main/bte_main.cc

代码执行流程图

bluetooth controller module 查看原图

Controller Module start up流程分析

下面的代码基于android O(api 27)。

本文基于MTK(MediaTek)平台基线。

首先从AdapterService.java类的enableNative()方法开始执行。

native boolean enableNative(boolean startRestricted);

接着进入com_android_bluetooth_btservice_AdapterService.cpp文件的enableNative()方法。

static jboolean enableNative(JNIEnv* env, jobject obj, 
    jboolean isGuest) {
  ALOGV("%s", __func__);

  if (!sBluetoothInterface) return JNI_FALSE;
  int ret = sBluetoothInterface->enable(
          isGuest == JNI_TRUE ? 1 : 0);
  return (ret == BT_STATUS_SUCCESS || ret == BT_STATUS_DONE) 
          ? JNI_TRUE: JNI_FALSE;
}

下面进入bluetooth.cc文件的enable()方法。

static int enable(bool start_restricted) {
  LOG_INFO(LOG_TAG, "method: %s: s", __func__);
  LOG_INFO(LOG_TAG, "%s: start restricted = %d", 
      __func__, start_restricted);

  restricted_mode = start_restricted;

  if (!interface_ready()) return BT_STATUS_NOT_READY;

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

下面进入stack_manager.cc文件的stack_manager_get_interface()方法。

const stack_manager_t* stack_manager_get_interface(){
  LOG_ERROR(LOG_TAG, "method: %s ", __func__);
  ensure_manager_initialized();
  return &interface;
}

下面进入stack_manager.cc文件的ensure_manager_initialized()方法。
这个方法主要是确保有一个"stack_manager"线程被创建。

static void ensure_manager_initialized(void) {
  LOG_ERROR(LOG_TAG, "method: %s ", __func__);
  if (management_thread){
    return;
  }

  management_thread = thread_new("stack_manager");
  if (!management_thread) {
    LOG_ERROR(LOG_TAG, "%s unable to create "
        + "stack management thread", __func__);
    return;
  }
}

下面进入stack_manager.cc文件的start_up_stack_async()方法。
可以看见这里是在"stack_manager"线程中执行event_start_up_stack()方法。

static void start_up_stack_async(void) {
  thread_post(management_thread, event_start_up_stack, NULL);
}

下面进入stack_manager.cc文件的event_start_up_stack()方法。

// Synchronous function to start up the stack
static void event_start_up_stack(UNUSED_ATTR void* context) {
  LOG_INFO(LOG_TAG, "method: %s", __func__);
  if (stack_is_running) {
    LOG_INFO(LOG_TAG, "%s stack already brought up", __func__);
    return;
  }
  /*
    * 在蓝牙进程启动的init过程中已经执行。
    * 所以当前的stack已经被初始化了。
    */
  ensure_stack_is_initialized();

  LOG_INFO(LOG_TAG, "%s is bringing up the stack", __func__);
  /**
    * 创建一个信号量同步对象
    */
  future_t* local_hack_future = future_new();
  hack_future = local_hack_future;

  /*
    * BTIF_CONFIG_MODULE: "btif_config_module"
    * module声明在system/bt/btif/src/btif_config.cc文件中
    * 这个module对应的startup()方法为NULL,所以不执行任何操作
    */
  // Include this for now to put btif config into a 
  // shutdown-able state
  module_start_up(get_module(BTIF_CONFIG_MODULE));
  /*
    * 进入这里
    */
  bte_main_enable();

  if (future_await(local_hack_future) != FUTURE_SUCCESS) {
    LOG_ERROR(LOG_TAG, "%s failed to start up the stack", 
            __func__);
    // So stack shutdown actually happens
    stack_is_running = true;  
    event_shut_down_stack(NULL);
    return;
  }

  stack_is_running = true;
  LOG_INFO(LOG_TAG, "%s finished", __func__);
  btif_thread_post(event_signal_stack_up, NULL);
}

下面进入bte_main.cc文件的bte_main_enable()方法。

void bte_main_enable() {
   LOG_INFO(LOG_TAG, "method: %s ", __func__);
 /*
  * 进入MTK自己定义的一个BTSNOOP_MODULE
  * 启动运行MTK自己的SNOOP log 输出逻辑
  * 暂不深究
  */
#if defined(MTK_STACK_CONFIG_LOG) \
    && (MTK_STACK_CONFIG_LOG == TRUE)
    LOG_ERROR(LOG_TAG, "define if: MTK_BTSNOOP_MODULE ");
  module_start_up(get_module(MTK_BTSNOOP_MODULE));
#else
  module_start_up(get_module(BTSNOOP_MODULE));
    LOG_ERROR(LOG_TAG, "define else: BTSNOOP_MODULE ");
#endif
  /*
    * 启动HCI_MODULE
    * 启动一个HCI线程专门用来硬件进行相关交互
    * 暂不深究
    */
  module_start_up(get_module(HCI_MODULE));
  /*
    * 进入这里
    */
  BTU_StartUp();
}

下面进入btu_init.cc文件的BTU_StartUp()方法。

void BTU_StartUp(void) {
  LOG_ERROR(LOG_TAG, "method: %s ",__func__);
  btu_trace_level = HCI_INITIAL_TRACE_LEVEL;
  /*
    * 创建一个“bt_workqueue”线程
    */
  bt_workqueue_thread = thread_new(BT_WORKQUEUE_NAME);
  if (bt_workqueue_thread == NULL) goto error_exit;

  thread_set_rt_priority(bt_workqueue_thread, 
          BTU_TASK_RT_PRIORITY);

   /*
    * 进入这里
    */
  // Continue startup on bt workqueue thread.
  thread_post(bt_workqueue_thread, btu_task_start_up, 
      NULL);
  return;

error_exit:;
  LOG_ERROR(LOG_TAG, "%s Unable to allocate resources"
          + " for bt_workqueue",
          __func__);
  BTU_ShutDown();
}

下面进入btu_task.cc文件的btu_task_start_up()方法。
这个方法运行在“bt_workqueue”线程中了。

void btu_task_start_up(UNUSED_ATTR void* context) {
  LOG_ERROR(LOG_TAG, "method: %s", __func__);
  LOG(INFO) << "Bluetooth chip preload is complete";

  /*
    * 初始化强制核心堆栈控制块
    * 暂不研究
    * Initialize the mandatory core stack control blocks
    * (BTU, BTM, L2CAP, and SDP)
    */
  btu_init_core();
  /*
    * 初始化任何可选的堆栈组件
    * 暂不研究
    */
  /* Initialize any optional stack components */
  BTE_InitStack();
 /*
   * 进入这里
   */
  bta_sys_init();

  /* Initialise platform trace levels at this point as 
   * BTE_InitStack() and bta_sys_init()
   * reset the control blocks and preset the trace level with
   * XXX_INITIAL_TRACE_LEVEL
   */
  module_init(get_module(BTE_LOGMSG_MODULE));
  LOG_ERROR(LOG_TAG, "create new thread btu message loop");
  message_loop_thread_ = thread_new("btu message loop");
  if (!message_loop_thread_) {
    LOG(FATAL) << __func__ << " unable to create btu"
            + " message loop thread.";
  }

  thread_set_rt_priority(message_loop_thread_, THREAD_RT_PRIORITY);
  thread_post(message_loop_thread_, btu_message_loop_run, nullptr);

}

下面进入bta_sys_main.cc文件的bta_sys_init()方法。

void bta_sys_init(void) {
  LOG_ERROR(LOG_TAG, "method: %s", __func__);
  /*
    * 为对象bta_sys_cb分配内存空间
    */
  memset(&bta_sys_cb, 0, sizeof(tBTA_SYS_CB));

  appl_trace_level = APPL_INITIAL_TRACE_LEVEL;
   /*
     * 进入这里
     */
  /* register BTA SYS message handler */
  bta_sys_register(BTA_ID_SYS, &bta_sys_hw_reg);

  /*
    * 也是设置消息处理的回调
    * 暂不研究
    */
  /* register for BTM notifications */
  BTM_RegisterForDeviceStatusNotif((tBTM_DEV_STATUS_CB*)
          &bta_sys_hw_btm_cback);

// -> true
#if (defined BTA_AR_INCLUDED) && (BTA_AR_INCLUDED == true)
  //为对象分配内存空间
  bta_ar_init();
#endif
}

下面进入bta_sys_main.cc文件的bta_sys_register()方法。
按照我的理解这个方法是给对应的消息注册了一个对应处理方法回调。
结合上面的方法可知对BTA_ID_SYS->0的消息注册了一个bta_sys_hw_reg结构体。
这个结构体中就包含了具体处理消息的方法。

void bta_sys_register(uint8_t id, 
        const tBTA_SYS_REG* p_reg) {
  LOG_ERROR(LOG_TAG, "method: %s", __func__);
  bta_sys_cb.reg[id] = (tBTA_SYS_REG*)p_reg;
  bta_sys_cb.is_reg[id] = true;
}

下面回到btu_task.cc文件的btu_task_start_up()方法。

void btu_task_start_up(UNUSED_ATTR void* context) {
  ......
  /*
   * 初始化 BTE_LOGMSG_MODULE
   * 主要是进行system/bt trace log输出的控制
   * 暂不深究
   *
   * Initialise platform trace levels at this point as 
   * BTE_InitStack() and bta_sys_init()
   * reset the control blocks and preset the trace level 
   * with XXX_INITIAL_TRACE_LEVEL
   */
  module_init(get_module(BTE_LOGMSG_MODULE));
  /*
    * 创建一个"btu message loop"线程
    */
  LOG_ERROR(LOG_TAG, "create new thread btu message loop");
  message_loop_thread_ = thread_new("btu message loop");
  if (!message_loop_thread_) {
    LOG(FATAL) << __func__ << " unable to create btu message"
            + " loop thread.";
  }

  thread_set_rt_priority(message_loop_thread_, THREAD_RT_PRIORITY);
  /*
    * 启动运行这个线程
    */
  thread_post(message_loop_thread_, btu_message_loop_run, nullptr);

}

下面进入btu_task.cc文件的btu_message_loop_run()方法。
这个方法运行在"btu message loop"线程中。

void btu_message_loop_run(UNUSED_ATTR void* context) {
  message_loop_ = new base::MessageLoop();
  LOG_INFO(LOG_TAG, "method: %s  ,  message loop "
          + "pointer: %p", __func__, message_loop_);
  run_loop_ = new base::RunLoop();

  /*
    * 下面这个方法的实质就是在btif_transfer_context()方法中
    * 封装一个btif_init_ok的消息,然后发送的jni线程进行处理
    */
  // Inform the bt jni thread initialization is ok.
  message_loop_->task_runner()->PostTask(
      FROM_HERE, base::Bind(base::IgnoreResult(
          &btif_transfer_context),btif_init_ok, 0, 
          nullptr, 0, nullptr));

  run_loop_->Run();

  delete message_loop_;
  message_loop_ = NULL;

  delete run_loop_;
  run_loop_ = NULL;
}

下面进入btif_core.cc文件的btif_init_ok()方法。
这个方法运行在jni线程中。

void btif_init_ok(UNUSED_ATTR uint16_t event, 
        UNUSED_ATTR char* p_param) {
  LOG_INFO(LOG_TAG, "method: %s", __func__);
  BTIF_TRACE_DEBUG("btif_task: received trigger "
          + "stack init event");
  /*
    * 载入ble相关的key,暂不深究
    */
  btif_dm_load_ble_local_keys();
  /*
    * 进入这里
    */
  BTA_EnableBluetooth(bte_dm_evt);
}

下面进入bta_dm_api.cc文件的BTA_EnableBluetooth()方法。

tBTA_STATUS BTA_EnableBluetooth(tBTA_DM_SEC_CBACK* p_cback) {
    LOG_ERROR(LOG_TAG, "method: %s", __func__);
  /* Bluetooth disabling is in progress */
  if (bta_dm_cb.disabling) return BTA_FAILURE;
  /*
    * 消息注册
    */
  bta_sys_register(BTA_ID_DM, &bta_dm_reg);
  bta_sys_register(BTA_ID_DM_SEARCH, &bta_dm_search_reg);

  /* if UUID list is not provided as static data */
  bta_sys_eir_register(bta_dm_eir_update_uuid);

  tBTA_DM_API_ENABLE* p_msg =
      (tBTA_DM_API_ENABLE*)osi_malloc(sizeof(tBTA_DM_API_ENABLE));
  p_msg->hdr.event = BTA_DM_API_ENABLE_EVT;
  p_msg->p_sec_cback = p_cback;
  /*
    * 发送消息到"btu message loop"线程中进行相关流程处理
    */
  bta_sys_sendmsg(p_msg);

  return BTA_SUCCESS;
}

方法bta_sys_register()定义在system/bt/bta/sys/bta_sys_main.cc中。

void bta_sys_register(uint8_t id, 
        const tBTA_SYS_REG* p_reg) {
  LOG_ERROR(LOG_TAG, "method: %s", __func__);
  bta_sys_cb.reg[id] = (tBTA_SYS_REG*)p_reg;
  bta_sys_cb.is_reg[id] = true;
}

结构体tBTA_SYS_REG定义i载system/bt/bta/sys/bta_sys.h中。

/* registration structure */
typedef struct {
  tBTA_SYS_EVT_HDLR* evt_hdlr;
  tBTA_SYS_DISABLE* disable;
} tBTA_SYS_REG;

下面两个变量定义在system/bt/bta/dm/bta_dm_api.cc文件中。

static const tBTA_SYS_REG bta_dm_reg = {
                    bta_dm_sm_execute,
                    bta_dm_sm_disable};

static const tBTA_SYS_REG bta_dm_search_reg = {
                     bta_dm_search_sm_execute,
                     bta_dm_search_sm_disable};

下面进入bta_sys_main.cc文件的bta_sys_sendmsg()方法。
这个方法是在哪个线程调用就在哪个线程运行。

void bta_sys_sendmsg(void* p_msg) {
  base::MessageLoop* bta_message_loop = get_message_loop();
  LOG_ERROR(LOG_TAG, "method: %s , message loop"
          + " pointer: %p", __func__, bta_message_loop);

  if (!bta_message_loop || 
          !bta_message_loop->task_runner().get()) {
    APPL_TRACE_ERROR("%s: MessageLooper not initialized", 
            __func__);
    return;
  }

  bta_message_loop->task_runner()->PostTask(
      FROM_HERE, base::Bind(&bta_sys_event, 
      static_cast<BT_HDR*>(p_msg)));
}

下面进入bta_sys_main.cc文件的bta_sys_event()方法。

void bta_sys_event(BT_HDR* p_msg) {
   LOG_ERROR(LOG_TAG, "method: %s", __func__);
  uint8_t id;
  bool freebuf = true;

  APPL_TRACE_EVENT("%s: Event 0x%x", __func__, 
          p_msg->event);

  /* get subsystem id from event */
  id = (uint8_t)(p_msg->event >> 8);
  //id: 1  BTA_ID_MAX: 46
  LOG_ERROR(LOG_TAG, "id: %d  , BTA_ID_MAX: %d", 
          id,BTA_ID_MAX);

  /* verify id and call subsystem event handler */
  if ((id < BTA_ID_MAX) && (bta_sys_cb.reg[id] != NULL)) {
    /*
      * 重点是这里
      * 这里执行的就是bta_sys_register()方法注册的内容
      */
    LOG_ERROR(LOG_TAG, "method %s if judge was true", 
            __func__);
    freebuf = (*bta_sys_cb.reg[id]->evt_hdlr)(p_msg);
  } else {
    APPL_TRACE_WARNING("%s: Received unregistered "+
             "event id %d", __func__, id);
  }

  if (freebuf) {
    osi_free(p_msg);
  }
}

在上面的内容中我们一共使用了三次bta_sys_register()方法。
根据log的输出,这里先执行的是:

static const tBTA_SYS_REG bta_dm_reg = {
                        bta_dm_sm_execute,
                        bta_dm_sm_disable};

里面的bta_dm_sm_execute()方法。

下面进入bta_dm_main.cc文件的bta_dm_sm_execute()方法。

bool bta_dm_sm_execute(BT_HDR* p_msg) {
    LOG_ERROR(LOG_TAG, "method: %s", __func__);
  uint16_t event = p_msg->event & 0x00ff;
    // event:0x0
    LOG_ERROR(LOG_TAG, "bta_dm_sm_execute event:0x%x", 
              event);

  /* execute action functions */
  if (event < BTA_DM_NUM_ACTIONS) {
    /*
      * 进入这里
      * bta_dm_action是一个方法数组
      * 这里执行该数组0位置的方法:bta_dm_enable()
      */
    (*bta_dm_action[event])((tBTA_DM_MSG*)p_msg);
  }

  return true;
}

下面进入bta_dm_act.cc文件的bta_dm_enable()方法。

void bta_dm_enable(tBTA_DM_MSG* p_data) {
  LOG_ERROR(LOG_TAG, "method: %s", __func__);
  tBTA_DM_ENABLE enable_event;

  /* if already in use, return an error */
  if (bta_dm_cb.is_bta_dm_active == true) {
    APPL_TRACE_WARNING("%s Device already started by "
            + "another application",
            __func__);
    memset(&enable_event, 0, sizeof(tBTA_DM_ENABLE));
    enable_event.status = BTA_FAILURE;
    if (p_data->enable.p_sec_cback != NULL)
      p_data->enable.p_sec_cback(BTA_DM_ENABLE_EVT,
            (tBTA_DM_SEC*)&enable_event);
    return;
  }

  /* first, register our callback to SYS HW manager */
  bta_sys_hw_register(BTA_SYS_HW_BLUETOOTH, 
          bta_dm_sys_hw_cback);

  /* make sure security callback is saved - if 
  no callback, do not erase the
  previous one,
  it could be an error recovery mechanism */
  if (p_data->enable.p_sec_cback != NULL)
    bta_dm_cb.p_sec_cback = p_data->enable.p_sec_cback;
  /* notify BTA DM is now active */
  bta_dm_cb.is_bta_dm_active = true;

  /* send a message to BTA SYS */
  tBTA_SYS_HW_MSG* sys_enable_event =
      (tBTA_SYS_HW_MSG*)osi_malloc(sizeof(tBTA_SYS_HW_MSG));
  /*
    * 重点是这里
    * BTA_SYS_API_ENABLE_EVT: 0 , BTA_SYS_HW_BLUETOOTH: 0
    */
  LOG_ERROR(LOG_TAG, "method: %s , BTA_SYS_API_ENABLE_EVT: %d ,"
                + " BTA_SYS_HW_BLUETOOTH: %d ",
                __func__, BTA_SYS_API_ENABLE_EVT,
                BTA_SYS_HW_BLUETOOTH);

  sys_enable_event->hdr.event = BTA_SYS_API_ENABLE_EVT;
  sys_enable_event->hw_module = BTA_SYS_HW_BLUETOOTH;
  /*
    * 进入这里
    * 处理新的消息
    */
  bta_sys_sendmsg(sys_enable_event);
}

由前面同样的流程可知,该消息会进入bta_sys_event()方法被处理。

void bta_sys_event(BT_HDR* p_msg) {
   LOG_ERROR(LOG_TAG, "method: %s", __func__);
  uint8_t id;
  bool freebuf = true;

  APPL_TRACE_EVENT("%s: Event 0x%x", __func__, p_msg->event);

  /* get subsystem id from event */
  id = (uint8_t)(p_msg->event >> 8);
  // id: 0 BTA_ID_MAX:46
  LOG_ERROR(LOG_TAG, "id: %d  , BTA_ID_MAX: %d", id,
      BTA_ID_MAX);

  /* verify id and call subsystem event handler */
  if ((id < BTA_ID_MAX) && (bta_sys_cb.reg[id] != NULL)) {
    /*
      * 此时将会执行bta_sys_sm_execute()方法。
      */
    LOG_ERROR(LOG_TAG, "method %s if judge was true",
            __func__);
    freebuf = (*bta_sys_cb.reg[id]->evt_hdlr)(p_msg);
  } else {
    APPL_TRACE_WARNING("%s: Received unregistered event id %d",
             __func__, id);
  }

  if (freebuf) {
    osi_free(p_msg);
  }
}

下面变量定义在system/bt/bta/sys/bta_sys_main.cc中。

static const tBTA_SYS_REG bta_sys_hw_reg = {
                  bta_sys_sm_execute, NULL};

下面进入bta_sys_main.cc文件的bta_sys_sm_execute()方法。

bool bta_sys_sm_execute(BT_HDR* p_msg) {
  LOG_ERROR(LOG_TAG, "method: %s", __func__);
  bool freebuf = true;
  tBTA_SYS_ST_TBL state_table;
  uint8_t action;
  int i;

  LOG_ERROR(LOG_TAG, "bta_sys_sm_execute state:%d, 
          event:0x%x", bta_sys_cb.state,
          p_msg->event);

  /* look up the state table for the current state */
  state_table = bta_sys_st_tbl[bta_sys_cb.state];
  /* update state */
  bta_sys_cb.state = 
      state_table[p_msg->event & 0x00ff][BTA_SYS_NEXT_STATE];

  /* execute action functions */
  for (i = 0; i < BTA_SYS_ACTIONS; i++) {
    action = state_table[p_msg->event & 0x00ff][i];
    if (action != BTA_SYS_IGNORE) {
      /*
        *action: 0
        * bta_sys_action是定义在bta_sys_main.cc中的方法数组
        */
        LOG_ERROR(LOG_TAG, "method: %s to action: %d", 
                __func__,action);
      (*bta_sys_action[action])((tBTA_SYS_HW_MSG*)p_msg);
    } else {
      break;
    }
  }
  return freebuf;
}

下面进入sys/bta_sys_main.cc文件的bta_sys_hw_api_enable()方法。

void bta_sys_hw_api_enable(tBTA_SYS_HW_MSG* p_sys_hw_msg) {
  LOG_ERROR(LOG_TAG, "method: %s", __func__);
  // -> true
  if ((!bta_sys_cb.sys_hw_module_active) &&
      (bta_sys_cb.state != BTA_SYS_HW_ON)) {
      LOG_ERROR(LOG_TAG, "if judge true will send msg" );
    /* register which HW module was turned on */
    bta_sys_cb.sys_hw_module_active 
        |= ((uint32_t)1 << p_sys_hw_msg->hw_module);

    tBTA_SYS_HW_MSG* p_msg =
        (tBTA_SYS_HW_MSG*)osi_malloc(sizeof(tBTA_SYS_HW_MSG));
    p_msg->hdr.event = BTA_SYS_EVT_ENABLED_EVT;
    // BTA_SYS_EVT_ENABLED_EVT: 1
    LOG_ERROR(LOG_TAG, "method: %s , 
        BTA_SYS_EVT_ENABLED_EVT: %d ", __func__, 
        BTA_SYS_EVT_ENABLED_EVT);
    p_msg->hw_module = p_sys_hw_msg->hw_module;
    /*
      * 这是第三次消息
      */
    bta_sys_sendmsg(p_msg);
  } else {
    /* register which HW module was turned on */
    bta_sys_cb.sys_hw_module_active 
        |= ((uint32_t)1 << p_sys_hw_msg->hw_module);

    /* HW already in use, so directly notify the caller */
    if (bta_sys_cb
        .sys_hw_cback[p_sys_hw_msg->hw_module] != NULL)
      bta_sys_cb.
          sys_hw_cback[p_sys_hw_msg->hw_module](BTA_SYS_HW_ON_EVT);
  }

    // bta_sys_hw_api_enable for 0, active modules 0x0001
    LOG_ERROR(LOG_TAG,"bta_sys_hw_api_enable for %d, "
            + "active modules 0x%04X",
            p_sys_hw_msg->hw_module, 
            bta_sys_cb.sys_hw_module_active);
}

再次进入消息的处理流程,进入bta_sys_event()方法。

void bta_sys_event(BT_HDR* p_msg) {
   LOG_ERROR(LOG_TAG, "method: %s", __func__);
  uint8_t id;
  bool freebuf = true;

  APPL_TRACE_EVENT("%s: Event 0x%x", __func__, 
          p_msg->event);

  /* get subsystem id from event */
  id = (uint8_t)(p_msg->event >> 8);
  // id: 0 BTA_ID_MAX:46
  LOG_ERROR(LOG_TAG, "id: %d  , BTA_ID_MAX: %d", 
          id,BTA_ID_MAX);

  /* verify id and call subsystem event handler */
  if ((id < BTA_ID_MAX) && (bta_sys_cb.reg[id] != NULL)) {
    /*
      * 此时将会再次执行bta_sys_sm_execute()方法。
      */
    LOG_ERROR(LOG_TAG, "method %s if judge was true",
            __func__);
    freebuf = (*bta_sys_cb.reg[id]->evt_hdlr)(p_msg);
  } else {
    APPL_TRACE_WARNING("%s: Received unregistered event id %d", 
            __func__, id);
  }

  if (freebuf) {
    osi_free(p_msg);
  }
}

下面进入bta_sys_main.cc文件的bta_sys_sm_execute()方法。

bool bta_sys_sm_execute(BT_HDR* p_msg) {
  LOG_ERROR(LOG_TAG, "method: %s", __func__);
  bool freebuf = true;
  tBTA_SYS_ST_TBL state_table;
  uint8_t action;
  int i;

  //state:1, event:0x1
  LOG_ERROR(LOG_TAG, "bta_sys_sm_execute state:%d, event:0x%x", 
          bta_sys_cb.state,p_msg->event);

  /* look up the state table for the current state */
  state_table = bta_sys_st_tbl[bta_sys_cb.state];
  /* update state */
  bta_sys_cb.state = 
      state_table[p_msg->event & 0x00ff][BTA_SYS_NEXT_STATE];

  /* execute action functions */
  for (i = 0; i < BTA_SYS_ACTIONS; i++) {
    action = state_table[p_msg->event & 0x00ff][i];
    if (action != BTA_SYS_IGNORE) {
       /*
        *action: 1
        * bta_sys_action是定义在bta_sys_main.cc中的方法数组
        */
        LOG_ERROR(LOG_TAG, "method: %s to action: %d",
                __func__,action);
      (*bta_sys_action[action])((tBTA_SYS_HW_MSG*)p_msg);
    } else {
      break;
    }
  }
  return freebuf;
}

下面进入bta_sys_main.cc文件的bta_sys_hw_evt_enabled()方法。

void bta_sys_hw_evt_enabled(tBTA_SYS_HW_MSG* p_sys_hw_msg) {
  LOG_ERROR(LOG_TAG, "method: %s", __func__);
  APPL_TRACE_EVENT("bta_sys_hw_evt_enabled for %i", 
          p_sys_hw_msg->hw_module);
  BTM_DeviceReset(NULL);
}

下面进入btm_devctl.cc文件的BTM_DeviceReset()方法。

void BTM_DeviceReset(UNUSED_ATTR tBTM_CMPL_CB* p_cb) {
  LOG_ERROR(LOG_TAG, "method: %s", __func__);
  /* Flush all ACL connections */
  btm_acl_device_down();

  /* Clear the callback, so application would 
      not hang on reset */
  btm_db_reset();

  /**
    * 这里主要是在方法module_start_up_callbacked_wrapper中
    * 处理module "controller_module"
    */
  module_start_up_callbacked_wrapper(
          get_module(CONTROLLER_MODULE),bt_workqueue_thread, 
          reset_complete);
}

下面进入module.cc文件的module_start_up_callbacked_wrapper()方法。
这个方法主要是创建"module_wrapper"线程执行module "controller_module"。

void module_start_up_callbacked_wrapper(
        const module_t* module,thread_t* callback_thread,
        thread_fn callback) {
  LOG_ERROR(LOG_TAG, "method: %s", __func__);
  callbacked_wrapper_t* wrapper =
      (callbacked_wrapper_t*)osi_calloc(
            sizeof(callbacked_wrapper_t));

  wrapper->module = module;
  wrapper->lifecycle_thread = thread_new("module_wrapper");
  wrapper->callback_thread = callback_thread;
  wrapper->callback = callback;

  // Run the actual module start up
  thread_post(wrapper->lifecycle_thread, 
          run_wrapped_start_up, wrapper);
}

下面进入module.cc文件的run_wrapped_start_up()方法。

static void run_wrapped_start_up(void* context) {
  LOG_ERROR(LOG_TAG, "method: %s", __func__);
  CHECK(context);

  callbacked_wrapper_t* wrapper = 
          (callbacked_wrapper_t*)context;
   /*
    * 进入这里
    */
  wrapper->success = module_start_up(wrapper->module);

  // Post the result back to the callback
  thread_post(wrapper->callback_thread, 
          post_result_to_callback, wrapper);
}

下面进入module.cc文件的module_start_up()方法。

bool module_start_up(const module_t* module) {
  CHECK(module != NULL);
  // 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.
  CHECK(get_module_state(module) == 
        MODULE_STATE_INITIALIZED ||
        module->init == NULL);

  /*
    * 进入这里
    */
  LOG_INFO(LOG_TAG, "%s Starting module \"%s\"", 
          __func__, module->name);
  if (!call_lifecycle_function(module->start_up)) {
    LOG_ERROR(LOG_TAG, "%s Failed to start up module \"%s\"",
               __func__,
              module->name);
    return false;
  }
  LOG_INFO(LOG_TAG, "%s Started module \"%s\"", __func__, 
          module->name);

  set_module_state(module, MODULE_STATE_STARTED);
  return true;
}

controller_module定义在controller.cc文件中。

EXPORT_SYMBOL extern const module_t controller_module = {
    .name = CONTROLLER_MODULE,
    .init = NULL,
    .start_up = start_up,
    .shut_down = shut_down,
    .clean_up = NULL,
    .dependencies = {HCI_MODULE, NULL}};

下面进入module.cc文件的start_up()方法。
这个方法就是执行HCI相关命令进行初始化。
其中包括从硬件中获取bt的mac地址等。

static future_t* start_up(void) {
  LOG_INFO(LOG_TAG, "method: %s", __func__);
  BT_HDR* response;

  // Send the initial reset command
  response = AWAIT_COMMAND(packet_factory->make_reset());
  packet_parser->parse_generic_command_complete(response);

  ......

  // Read the bluetooth address off the controller next
  response = AWAIT_COMMAND(packet_factory->make_read_bd_addr());
  packet_parser->parse_read_bd_addr_response(response, &address);
  
  ......(省略一大段代码)
  
  readable = true;
  return future_new_immediate(FUTURE_SUCCESS);
}

至此执行controller_moduled的start_up()方法流程结束。
这个方法执行结束当前的"module_wrapper"线程就销毁了......

下面回到module.cc文件的run_wrapped_start_up()方法。

static void run_wrapped_start_up(void* context) {
  LOG_ERROR(LOG_TAG, "method: %s", __func__);
  CHECK(context);

  callbacked_wrapper_t* wrapper = 
          (callbacked_wrapper_t*)context;
  /*
    * 这里返回true
    */
  wrapper->success = module_start_up(wrapper->module);

   /*
     * 这里就回到"bt_workqueue"线程中去执行结束后的回调
     */
  // Post the result back to the callback
  thread_post(wrapper->callback_thread, 
          post_result_to_callback, wrapper);
}

下面回到module.cc文件的post_result_to_callback()方法。

static void post_result_to_callback(void* context) {
  CHECK(context);

  callbacked_wrapper_t* wrapper = 
          (callbacked_wrapper_t*)context;

  // Save the values we need for callback
  void* result = 
      wrapper->success ? FUTURE_SUCCESS : FUTURE_FAIL;
   /*
    * 这里的callback就是在btm_devctl.cc文件
    * 的BTM_DeviceReset()方法中
    * 设置的reset_complete()方法。
    */
  thread_fn callback = wrapper->callback;

  // Clean up the resources we used
  thread_free(wrapper->lifecycle_thread);
  osi_free(wrapper);
  /*
    * 执行这里
    */
  callback(result);
}

reset_complete()方法定义在在btm_devctl.cc文件,这个方法执行的内容不属于本文讨论的主题,暂不研究了......

static void reset_complete(void* result) {
    ......
}