From: Jakub Pawlowski Date: Tue, 23 Jan 2018 20:46:07 +0000 (-0800) Subject: Get rid of BTA_SYS_DM - use do_in_bta_thread instead X-Git-Tag: android-x86-9.0-r1~138^2^2^2^2 X-Git-Url: http://git.osdn.net/view?a=commitdiff_plain;h=0d4868040f8762476fa1b4c9b00ee6679479e7b2;p=android-x86%2Fsystem-bt.git Get rid of BTA_SYS_DM - use do_in_bta_thread instead Test: Bond, change device name, scan for classic devices Change-Id: If8d95976c4bb9ee6f346682590285cfc9d163ff5 --- diff --git a/bta/dm/bta_dm_act.cc b/bta/dm/bta_dm_act.cc index 778b7907d..70b8d2928 100644 --- a/bta/dm/bta_dm_act.cc +++ b/bta/dm/bta_dm_act.cc @@ -537,9 +537,9 @@ static void bta_dm_disable_timer_cback(void* data) { } /** Sets local device name */ -void bta_dm_set_dev_name(tBTA_DM_MSG* p_data) { - BTM_SetLocalDeviceName((char*)p_data->set_name.name); - bta_dm_set_eir((char*)p_data->set_name.name); +void bta_dm_set_dev_name(const std::vector& name) { + BTM_SetLocalDeviceName((char*)name.data()); + bta_dm_set_eir((char*)name.data()); } /** Sets discoverability, connectability and pairability */ @@ -703,8 +703,7 @@ void bta_dm_remove_device(const RawAddress& bd_addr) { * required information stored in the NVRAM. *** ******************************************************************************/ -void bta_dm_add_device(tBTA_DM_MSG* p_data) { - tBTA_DM_API_ADD_DEVICE* p_dev = &p_data->add_dev; +void bta_dm_add_device(std::unique_ptr msg) { uint8_t* p_dc = NULL; uint8_t* p_lc = NULL; uint32_t trusted_services_mask[BTM_SEC_SERVICE_ARRAY_SIZE]; @@ -714,30 +713,30 @@ void bta_dm_add_device(tBTA_DM_MSG* p_data) { memset(trusted_services_mask, 0, sizeof(trusted_services_mask)); /* If not all zeros, the device class has been specified */ - if (p_dev->dc_known) p_dc = (uint8_t*)p_dev->dc; + if (msg->dc_known) p_dc = (uint8_t*)msg->dc; - if (p_dev->link_key_known) p_lc = (uint8_t*)p_dev->link_key; + if (msg->link_key_known) p_lc = (uint8_t*)msg->link_key; - if (p_dev->is_trusted) { + if (msg->is_trusted) { /* covert BTA service mask to BTM mask */ - while (p_dev->tm && (index < BTA_MAX_SERVICE_ID)) { - if (p_dev->tm & (uint32_t)(1 << index)) { + while (msg->tm && (index < BTA_MAX_SERVICE_ID)) { + if (msg->tm & (uint32_t)(1 << index)) { btm_mask_index = bta_service_id_to_btm_srv_id_lkup_tbl[index] / BTM_SEC_ARRAY_BITS; trusted_services_mask[btm_mask_index] |= (uint32_t)(1 << (bta_service_id_to_btm_srv_id_lkup_tbl[index] - (uint32_t)(btm_mask_index * 32))); - p_dev->tm &= (uint32_t)(~(1 << index)); + msg->tm &= (uint32_t)(~(1 << index)); } index++; } } - if (!BTM_SecAddDevice(p_dev->bd_addr, p_dc, p_dev->bd_name, p_dev->features, - trusted_services_mask, p_lc, p_dev->key_type, - p_dev->io_cap, p_dev->pin_length)) { - LOG(ERROR) << "BTA_DM: Error adding device " << p_dev->bd_addr; + if (!BTM_SecAddDevice(msg->bd_addr, p_dc, msg->bd_name, msg->features, + trusted_services_mask, p_lc, msg->key_type, msg->io_cap, + msg->pin_length)) { + LOG(ERROR) << "BTA_DM: Error adding device " << msg->bd_addr; } } @@ -848,35 +847,22 @@ void bta_dm_bond_cancel(const RawAddress& bd_addr) { } } -/******************************************************************************* - * - * Function bta_dm_pin_reply - * - * Description Send the pin_reply to a request from BTM - * - * - * Returns void - * - ******************************************************************************/ -void bta_dm_pin_reply(tBTA_DM_MSG* p_data) { +/** Send the pin_reply to a request from BTM */ +void bta_dm_pin_reply(std::unique_ptr msg) { uint32_t trusted_mask[BTM_SEC_SERVICE_ARRAY_SIZE]; - uint32_t* current_trusted_mask; - - current_trusted_mask = BTM_ReadTrustedMask(p_data->pin_reply.bd_addr); + uint32_t* current_trusted_mask = BTM_ReadTrustedMask(msg->bd_addr); if (current_trusted_mask) { memcpy(trusted_mask, current_trusted_mask, sizeof(trusted_mask)); } else { memset(trusted_mask, 0, sizeof(trusted_mask)); } - if (p_data->pin_reply.accept) { - BTM_PINCodeReply(p_data->pin_reply.bd_addr, BTM_SUCCESS, - p_data->pin_reply.pin_len, p_data->pin_reply.p_pin, + if (msg->accept) { + BTM_PINCodeReply(msg->bd_addr, BTM_SUCCESS, msg->pin_len, msg->p_pin, trusted_mask); } else { - BTM_PINCodeReply(p_data->pin_reply.bd_addr, BTM_NOT_AUTHORIZED, 0, NULL, - trusted_mask); + BTM_PINCodeReply(msg->bd_addr, BTM_NOT_AUTHORIZED, 0, NULL, trusted_mask); } } @@ -944,39 +930,17 @@ void bta_dm_confirm(const RawAddress& bd_addr, bool accept) { BTM_ConfirmReqReply(accept ? BTM_SUCCESS : BTM_NOT_AUTHORIZED, bd_addr); } -/******************************************************************************* - * - * Function bta_dm_ci_io_req_act - * - * Description respond to the IO capabilities request from BTM - * - * Returns void - * - ******************************************************************************/ -void bta_dm_ci_io_req_act(tBTA_DM_MSG* p_data) { - tBTM_AUTH_REQ auth_req = BTM_AUTH_AP_NO; - if (p_data->ci_io_req.auth_req) auth_req = BTM_AUTH_AP_YES; - BTM_IoCapRsp(p_data->ci_io_req.bd_addr, p_data->ci_io_req.io_cap, - p_data->ci_io_req.oob_data, auth_req); +/** respond to the IO capabilities request from BTM */ +void bta_dm_ci_io_req_act(const RawAddress& bd_addr, tBTA_IO_CAP io_cap, + tBTA_OOB_DATA oob_data, tBTA_AUTH_REQ auth_req) { + BTM_IoCapRsp(bd_addr, io_cap, oob_data, + auth_req ? BTM_AUTH_AP_YES : BTM_AUTH_AP_NO); } -/******************************************************************************* - * - * Function bta_dm_ci_rmt_oob_act - * - * Description respond to the OOB data request for the remote device from - * BTM - * - * - * Returns void - * - ******************************************************************************/ -void bta_dm_ci_rmt_oob_act(tBTA_DM_MSG* p_data) { - tBTM_STATUS res = BTM_NOT_AUTHORIZED; - - if (p_data->ci_rmt_oob.accept) res = BTM_SUCCESS; - BTM_RemoteOobDataReply(res, p_data->ci_rmt_oob.bd_addr, p_data->ci_rmt_oob.c, - p_data->ci_rmt_oob.r); +/** respond to the OOB data request for the remote device from BTM */ +void bta_dm_ci_rmt_oob_act(std::unique_ptr msg) { + BTM_RemoteOobDataReply(msg->accept ? BTM_SUCCESS : BTM_NOT_AUTHORIZED, + msg->bd_addr, msg->c, msg->r); } /******************************************************************************* @@ -2655,225 +2619,83 @@ static void bta_dm_local_name_cback(UNUSED_ATTR void* p_name) { bta_dm_cb.p_sec_cback(BTA_DM_ENABLE_EVT, &sec_event); } -/******************************************************************************* - * - * Function bta_dm_bl_change_cback - * - * Description Callback from btm when acl connection goes up or down - * - * - * Returns void - * - ******************************************************************************/ -static void bta_dm_bl_change_cback(tBTM_BL_EVENT_DATA* p_data) { - tBTA_DM_ACL_CHANGE* p_msg = - (tBTA_DM_ACL_CHANGE*)osi_malloc(sizeof(tBTA_DM_ACL_CHANGE)); - - p_msg->event = p_data->event; - p_msg->is_new = false; +static void send_busy_level_update(uint8_t busy_level, + uint8_t busy_level_flags) { + if (!bta_dm_cb.p_sec_cback) return; - switch (p_msg->event) { - case BTM_BL_CONN_EVT: - p_msg->is_new = true; - p_msg->bd_addr = *p_data->conn.p_bda; - p_msg->transport = p_data->conn.transport; - p_msg->handle = p_data->conn.handle; - break; - case BTM_BL_DISCN_EVT: - p_msg->bd_addr = *p_data->discn.p_bda; - p_msg->transport = p_data->discn.transport; - p_msg->handle = p_data->discn.handle; - break; - case BTM_BL_UPDATE_EVT: - p_msg->busy_level = p_data->update.busy_level; - p_msg->busy_level_flags = p_data->update.busy_level_flags; - break; - case BTM_BL_ROLE_CHG_EVT: - p_msg->new_role = p_data->role_chg.new_role; - p_msg->hci_status = p_data->role_chg.hci_status; - p_msg->bd_addr = *p_data->role_chg.p_bda; - break; - case BTM_BL_COLLISION_EVT: - p_msg->bd_addr = *p_data->conn.p_bda; - break; - } - - p_msg->hdr.event = BTA_DM_ACL_CHANGE_EVT; - bta_sys_sendmsg(p_msg); -} - -/******************************************************************************* - * - * Function bta_dm_rs_cback - * - * Description Receives the role switch complete event - * - * Returns - * - ******************************************************************************/ -static void bta_dm_rs_cback(UNUSED_ATTR void* p1) { - APPL_TRACE_WARNING("bta_dm_rs_cback:%d", bta_dm_cb.rs_event); - if (bta_dm_cb.rs_event == BTA_DM_API_SEARCH_EVT) { - bta_dm_cb.search_msg.rs_res = - BTA_DM_RS_OK; /* do not care about the result for now */ - bta_dm_cb.rs_event = 0; - bta_dm_search_start((tBTA_DM_MSG*)&bta_dm_cb.search_msg); - } + tBTA_DM_SEC conn; + memset(&conn, 0, sizeof(tBTA_DM_SEC)); + conn.busy_level.level = busy_level; + conn.busy_level.level_flags = busy_level_flags; + bta_dm_cb.p_sec_cback(BTA_DM_BUSY_LEVEL_EVT, &conn); } -/******************************************************************************* - * - * Function bta_dm_check_av - * - * Description This function checks if AV is active - * if yes, make sure the AV link is master - * - * Returns bool - true, if switch is in progress - * - ******************************************************************************/ -static bool bta_dm_check_av(uint16_t event) { - bool avoid_roleswitch = false; - bool switching = false; - uint8_t i; - tBTA_DM_PEER_DEVICE* p_dev; - -#if (BTA_DM_AVOID_A2DP_ROLESWITCH_ON_INQUIRY == TRUE) +static void handle_role_change(const RawAddress& bd_addr, uint8_t new_role, + uint8_t hci_status) { + tBTA_DM_SEC conn; + memset(&conn, 0, sizeof(tBTA_DM_SEC)); - /* avoid role switch upon inquiry if a2dp is actively streaming as it - introduces an audioglitch due to FW scheduling delays (unavoidable) */ - if (event == BTA_DM_API_SEARCH_EVT) { - avoid_roleswitch = true; - } -#endif + tBTA_DM_PEER_DEVICE* p_dev = bta_dm_find_peer_device(bd_addr); + if (!p_dev) return; + APPL_TRACE_DEBUG("role chg info:x%x new_role:%d dev count:%d", p_dev->info, + new_role, bta_dm_cb.device_list.count); + if (p_dev->info & BTA_DM_DI_AV_ACTIVE) { + bool need_policy_change = false; + + /* there's AV activity on this link */ + if (new_role == HCI_ROLE_SLAVE && bta_dm_cb.device_list.count > 1 && + hci_status == HCI_SUCCESS) { + /* more than one connections and the AV connection is role switched + * to slave + * switch it back to master and remove the switch policy */ + BTM_SwitchRole(bd_addr, BTM_ROLE_MASTER, NULL); + need_policy_change = true; + } else if (p_bta_dm_cfg->avoid_scatter && (new_role == HCI_ROLE_MASTER)) { + /* if the link updated to be master include AV activities, remove + * the switch policy */ + need_policy_change = true; + } - APPL_TRACE_WARNING("bta_dm_check_av:%d", bta_dm_cb.cur_av_count); - if (bta_dm_cb.cur_av_count) { - for (i = 0; i < bta_dm_cb.device_list.count; i++) { - p_dev = &bta_dm_cb.device_list.peer_device[i]; - APPL_TRACE_WARNING("[%d]: state:%d, info:x%x, avoid_rs %d", i, - p_dev->conn_state, p_dev->info, avoid_roleswitch); - if ((p_dev->conn_state == BTA_DM_CONNECTED) && - (p_dev->info & BTA_DM_DI_AV_ACTIVE) && (!avoid_roleswitch)) { - /* make master and take away the role switch policy */ - if (BTM_CMD_STARTED == BTM_SwitchRole(p_dev->peer_bdaddr, - HCI_ROLE_MASTER, - bta_dm_rs_cback)) { - /* the role switch command is actually sent */ - bta_dm_cb.rs_event = event; - switching = true; - } - /* else either already master or can not switch for some reasons */ - bta_dm_policy_cback(BTA_SYS_PLCY_CLR, 0, HCI_ENABLE_MASTER_SLAVE_SWITCH, - p_dev->peer_bdaddr); - break; - } + if (need_policy_change) { + bta_dm_policy_cback(BTA_SYS_PLCY_CLR, 0, HCI_ENABLE_MASTER_SLAVE_SWITCH, + p_dev->peer_bdaddr); } + } else { + /* there's AV no activity on this link and role switch happened + * check if AV is active + * if so, make sure the AV link is master */ + bta_dm_check_av(0); } - return switching; + bta_sys_notify_role_chg(bd_addr, new_role, hci_status); + conn.role_chg.bd_addr = bd_addr; + conn.role_chg.new_role = (uint8_t)new_role; + if (bta_dm_cb.p_sec_cback) bta_dm_cb.p_sec_cback(BTA_DM_ROLE_CHG_EVT, &conn); } -/******************************************************************************* - * - * Function bta_dm_acl_change - * - * Description Process BTA_DM_ACL_CHANGE_EVT - * - * - * Returns void - * - ******************************************************************************/ -void bta_dm_acl_change(tBTA_DM_MSG* p_data) { - uint8_t i; - uint8_t* p; - tBTA_DM_SEC conn; - bool is_new = p_data->acl_change.is_new; - const RawAddress& p_bda = p_data->acl_change.bd_addr; - bool need_policy_change = false; +static void bta_dm_acl_change(bool is_new, const RawAddress& bd_addr, + tBT_TRANSPORT transport, uint16_t handle) { bool issue_unpair_cb = false; - tBTA_DM_PEER_DEVICE* p_dev; + tBTA_DM_SEC conn; memset(&conn, 0, sizeof(tBTA_DM_SEC)); - switch (p_data->acl_change.event) { - case BTM_BL_UPDATE_EVT: /* busy level update */ - if (bta_dm_cb.p_sec_cback) { - conn.busy_level.level = p_data->acl_change.busy_level; - conn.busy_level.level_flags = p_data->acl_change.busy_level_flags; - bta_dm_cb.p_sec_cback(BTA_DM_BUSY_LEVEL_EVT, &conn); - } - return; - - case BTM_BL_ROLE_CHG_EVT: /* role change event */ - p_dev = bta_dm_find_peer_device(p_bda); - if (p_dev) { - APPL_TRACE_DEBUG( - "bta_dm_acl_change role chg info:x%x new_role:%d dev count:%d", - p_dev->info, p_data->acl_change.new_role, - bta_dm_cb.device_list.count); - if (p_dev->info & BTA_DM_DI_AV_ACTIVE) { - /* there's AV activity on this link */ - if (p_data->acl_change.new_role == HCI_ROLE_SLAVE && - bta_dm_cb.device_list.count > 1 && - p_data->acl_change.hci_status == HCI_SUCCESS) { - /* more than one connections and the AV connection is role switched - * to slave - * switch it back to master and remove the switch policy */ - BTM_SwitchRole(p_bda, BTM_ROLE_MASTER, NULL); - need_policy_change = true; - } else if (p_bta_dm_cfg->avoid_scatter && - (p_data->acl_change.new_role == HCI_ROLE_MASTER)) { - /* if the link updated to be master include AV activities, remove - * the switch policy */ - need_policy_change = true; - } - - if (need_policy_change) { - bta_dm_policy_cback(BTA_SYS_PLCY_CLR, 0, - HCI_ENABLE_MASTER_SLAVE_SWITCH, - p_dev->peer_bdaddr); - } - } else { - /* there's AV no activity on this link and role switch happened - * check if AV is active - * if so, make sure the AV link is master */ - bta_dm_check_av(0); - } - bta_sys_notify_role_chg(p_data->acl_change.bd_addr, - p_data->acl_change.new_role, - p_data->acl_change.hci_status); - conn.role_chg.bd_addr = p_bda; - conn.role_chg.new_role = (uint8_t)p_data->acl_change.new_role; - if (bta_dm_cb.p_sec_cback) - bta_dm_cb.p_sec_cback(BTA_DM_ROLE_CHG_EVT, &conn); - } - return; - } - - /* Collision report from Stack: Notify profiles */ - if (p_data->acl_change.event == BTM_BL_COLLISION_EVT) { - bta_sys_notify_collision(p_bda); - return; - } - if (is_new) { + uint8_t i; for (i = 0; i < bta_dm_cb.device_list.count; i++) { - if (bta_dm_cb.device_list.peer_device[i].peer_bdaddr == p_bda && - bta_dm_cb.device_list.peer_device[i].conn_handle == - p_data->acl_change.handle) + if (bta_dm_cb.device_list.peer_device[i].peer_bdaddr == bd_addr && + bta_dm_cb.device_list.peer_device[i].conn_handle == handle) break; } if (i == bta_dm_cb.device_list.count) { if (bta_dm_cb.device_list.count < BTA_DM_NUM_PEER_DEVICE) { bta_dm_cb.device_list.peer_device[bta_dm_cb.device_list.count] - .peer_bdaddr = p_bda; + .peer_bdaddr = bd_addr; bta_dm_cb.device_list.peer_device[bta_dm_cb.device_list.count] .link_policy = bta_dm_cb.cur_policy; bta_dm_cb.device_list.count++; - bta_dm_cb.device_list.peer_device[i].conn_handle = - p_data->acl_change.handle; - if (p_data->acl_change.transport == BT_TRANSPORT_LE) - bta_dm_cb.device_list.le_count++; + bta_dm_cb.device_list.peer_device[i].conn_handle = handle; + if (transport == BT_TRANSPORT_LE) bta_dm_cb.device_list.le_count++; } else { APPL_TRACE_ERROR("%s max active connection reached, no resources", __func__); @@ -2883,15 +2705,15 @@ void bta_dm_acl_change(tBTA_DM_MSG* p_data) { bta_dm_cb.device_list.peer_device[i].conn_state = BTA_DM_CONNECTED; bta_dm_cb.device_list.peer_device[i].pref_role = BTA_ANY_ROLE; - conn.link_up.bd_addr = p_bda; + conn.link_up.bd_addr = bd_addr; bta_dm_cb.device_list.peer_device[i].info = BTA_DM_DI_NONE; - conn.link_up.link_type = p_data->acl_change.transport; - bta_dm_cb.device_list.peer_device[i].transport = - p_data->acl_change.transport; + conn.link_up.link_type = transport; + bta_dm_cb.device_list.peer_device[i].transport = transport; + uint8_t* p; if (((NULL != (p = BTM_ReadLocalFeatures())) && HCI_SNIFF_SUB_RATE_SUPPORTED(p)) && - ((NULL != (p = BTM_ReadRemoteFeatures(p_bda))) && + ((NULL != (p = BTM_ReadRemoteFeatures(bd_addr))) && HCI_SNIFF_SUB_RATE_SUPPORTED(p))) { /* both local and remote devices support SSR */ bta_dm_cb.device_list.peer_device[i].info = BTA_DM_DI_USE_SSR; @@ -2901,10 +2723,9 @@ void bta_dm_acl_change(tBTA_DM_MSG* p_data) { if (bta_dm_cb.p_sec_cback) bta_dm_cb.p_sec_cback(BTA_DM_LINK_UP_EVT, &conn); } else { - for (i = 0; i < bta_dm_cb.device_list.count; i++) { - if (bta_dm_cb.device_list.peer_device[i].peer_bdaddr != p_bda || - bta_dm_cb.device_list.peer_device[i].transport != - p_data->acl_change.transport) + for (uint8_t i = 0; i < bta_dm_cb.device_list.count; i++) { + if (bta_dm_cb.device_list.peer_device[i].peer_bdaddr != bd_addr || + bta_dm_cb.device_list.peer_device[i].transport != transport) continue; if (bta_dm_cb.device_list.peer_device[i].conn_state == BTA_DM_UNPAIRING) { @@ -2935,12 +2756,11 @@ void bta_dm_acl_change(tBTA_DM_MSG* p_data) { break; } if (bta_dm_cb.device_list.count) bta_dm_cb.device_list.count--; - if ((p_data->acl_change.transport == BT_TRANSPORT_LE) && - (bta_dm_cb.device_list.le_count)) + if ((transport == BT_TRANSPORT_LE) && (bta_dm_cb.device_list.le_count)) bta_dm_cb.device_list.le_count--; - conn.link_down.link_type = p_data->acl_change.transport; + conn.link_down.link_type = transport; - if (bta_dm_search_cb.wait_disc && bta_dm_search_cb.peer_bdaddr == p_bda) { + if (bta_dm_search_cb.wait_disc && bta_dm_search_cb.peer_bdaddr == bd_addr) { bta_dm_search_cb.wait_disc = false; if (bta_dm_search_cb.sdp_results) { @@ -2962,14 +2782,14 @@ void bta_dm_acl_change(tBTA_DM_MSG* p_data) { } } if (conn.link_down.is_removed) { - BTM_SecDeleteDevice(p_bda); + BTM_SecDeleteDevice(bd_addr); /* need to remove all pending background connection */ - BTA_GATTC_CancelOpen(0, p_bda, false); + BTA_GATTC_CancelOpen(0, bd_addr, false); /* remove all cached GATT information */ - BTA_GATTC_Refresh(p_bda); + BTA_GATTC_Refresh(bd_addr); } - conn.link_down.bd_addr = p_bda; + conn.link_down.bd_addr = bd_addr; conn.link_down.status = (uint8_t)btm_get_acl_disc_reason_code(); if (bta_dm_cb.p_sec_cback) { bta_dm_cb.p_sec_cback(BTA_DM_LINK_DOWN_EVT, &conn); @@ -2981,6 +2801,114 @@ void bta_dm_acl_change(tBTA_DM_MSG* p_data) { bta_dm_adjust_roles(true); } +/** Callback from btm when acl connection goes up or down */ +static void bta_dm_bl_change_cback(tBTM_BL_EVENT_DATA* p_data) { + switch (p_data->event) { + case BTM_BL_CONN_EVT: + /* connection up */ + do_in_bta_thread(FROM_HERE, + base::Bind(bta_dm_acl_change, true, *p_data->conn.p_bda, + p_data->conn.transport, p_data->conn.handle)); + break; + case BTM_BL_DISCN_EVT: + /* connection down */ + do_in_bta_thread( + FROM_HERE, base::Bind(bta_dm_acl_change, false, *p_data->discn.p_bda, + p_data->discn.transport, p_data->discn.handle)); + break; + + case BTM_BL_UPDATE_EVT: { + /* busy level update */ + do_in_bta_thread(FROM_HERE, base::Bind(send_busy_level_update, + p_data->update.busy_level, + p_data->update.busy_level_flags)); + return; + } + case BTM_BL_ROLE_CHG_EVT: { + const auto& tmp = p_data->role_chg; + do_in_bta_thread(FROM_HERE, base::Bind(handle_role_change, *tmp.p_bda, + tmp.new_role, tmp.hci_status)); + return; + } + + case BTM_BL_COLLISION_EVT: + /* Collision report from Stack: Notify profiles */ + do_in_bta_thread( + FROM_HERE, base::Bind(bta_sys_notify_collision, *p_data->conn.p_bda)); + return; + } +} + +/******************************************************************************* + * + * Function bta_dm_rs_cback + * + * Description Receives the role switch complete event + * + * Returns + * + ******************************************************************************/ +static void bta_dm_rs_cback(UNUSED_ATTR void* p1) { + APPL_TRACE_WARNING("bta_dm_rs_cback:%d", bta_dm_cb.rs_event); + if (bta_dm_cb.rs_event == BTA_DM_API_SEARCH_EVT) { + bta_dm_cb.search_msg.rs_res = + BTA_DM_RS_OK; /* do not care about the result for now */ + bta_dm_cb.rs_event = 0; + bta_dm_search_start((tBTA_DM_MSG*)&bta_dm_cb.search_msg); + } +} + +/******************************************************************************* + * + * Function bta_dm_check_av + * + * Description This function checks if AV is active + * if yes, make sure the AV link is master + * + * Returns bool - true, if switch is in progress + * + ******************************************************************************/ +static bool bta_dm_check_av(uint16_t event) { + bool avoid_roleswitch = false; + bool switching = false; + uint8_t i; + tBTA_DM_PEER_DEVICE* p_dev; + +#if (BTA_DM_AVOID_A2DP_ROLESWITCH_ON_INQUIRY == TRUE) + + /* avoid role switch upon inquiry if a2dp is actively streaming as it + introduces an audioglitch due to FW scheduling delays (unavoidable) */ + if (event == BTA_DM_API_SEARCH_EVT) { + avoid_roleswitch = true; + } +#endif + + APPL_TRACE_WARNING("bta_dm_check_av:%d", bta_dm_cb.cur_av_count); + if (bta_dm_cb.cur_av_count) { + for (i = 0; i < bta_dm_cb.device_list.count; i++) { + p_dev = &bta_dm_cb.device_list.peer_device[i]; + APPL_TRACE_WARNING("[%d]: state:%d, info:x%x, avoid_rs %d", i, + p_dev->conn_state, p_dev->info, avoid_roleswitch); + if ((p_dev->conn_state == BTA_DM_CONNECTED) && + (p_dev->info & BTA_DM_DI_AV_ACTIVE) && (!avoid_roleswitch)) { + /* make master and take away the role switch policy */ + if (BTM_CMD_STARTED == BTM_SwitchRole(p_dev->peer_bdaddr, + HCI_ROLE_MASTER, + bta_dm_rs_cback)) { + /* the role switch command is actually sent */ + bta_dm_cb.rs_event = event; + switching = true; + } + /* else either already master or can not switch for some reasons */ + bta_dm_policy_cback(BTA_SYS_PLCY_CLR, 0, HCI_ENABLE_MASTER_SLAVE_SWITCH, + p_dev->peer_bdaddr); + break; + } + } + } + return switching; +} + /******************************************************************************* * * Function bta_dm_disable_conn_down_timer_cback @@ -3631,10 +3559,6 @@ void bta_dm_eir_update_uuid(uint16_t uuid16, bool adding) { } #endif -void bta_dm_enable_test_mode() { BTM_EnableTestMode(); } - -void bta_dm_disable_test_mode() { BTM_DeviceReset(NULL); } - /******************************************************************************* * * Function bta_dm_encrypt_cback @@ -3967,12 +3891,10 @@ static void bta_dm_ble_id_key_cback(uint8_t key_type, * Parameters: * ******************************************************************************/ -void bta_dm_add_blekey(tBTA_DM_MSG* p_data) { - if (!BTM_SecAddBleKey(p_data->add_ble_key.bd_addr, - (tBTM_LE_KEY_VALUE*)&p_data->add_ble_key.blekey, - p_data->add_ble_key.key_type)) { - LOG(ERROR) << "BTA_DM: Error adding BLE Key for device " - << p_data->add_ble_key.bd_addr; +void bta_dm_add_blekey(const RawAddress& bd_addr, tBTA_LE_KEY_VALUE blekey, + tBTA_LE_KEY_TYPE key_type) { + if (!BTM_SecAddBleKey(bd_addr, (tBTM_LE_KEY_VALUE*)&blekey, key_type)) { + LOG(ERROR) << "BTA_DM: Error adding BLE Key for device " << bd_addr; } } diff --git a/bta/dm/bta_dm_api.cc b/bta/dm/bta_dm_api.cc index 738c95eb9..e1c026623 100644 --- a/bta/dm/bta_dm_api.cc +++ b/bta/dm/bta_dm_api.cc @@ -41,8 +41,6 @@ using bluetooth::Uuid; * Constants ****************************************************************************/ -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}; @@ -61,7 +59,6 @@ tBTA_STATUS BTA_EnableBluetooth(tBTA_DM_SEC_CBACK* p_cback) { /* 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 */ @@ -88,32 +85,21 @@ tBTA_STATUS BTA_DisableBluetooth(void) { /** Enables bluetooth device under test mode */ void BTA_EnableTestMode(void) { - do_in_bta_thread(FROM_HERE, base::Bind(bta_dm_enable_test_mode)); + do_in_bta_thread(FROM_HERE, + base::Bind(base::IgnoreResult(BTM_EnableTestMode))); } /** Disable bluetooth device under test mode */ void BTA_DisableTestMode(void) { - do_in_bta_thread(FROM_HERE, base::Bind(bta_dm_disable_test_mode)); + do_in_bta_thread(FROM_HERE, base::Bind(BTM_DeviceReset, nullptr)); } -/******************************************************************************* - * - * Function BTA_DmSetDeviceName - * - * Description This function sets the Bluetooth name of local device - * - * - * Returns void - * - ******************************************************************************/ +/** This function sets the Bluetooth name of local device */ void BTA_DmSetDeviceName(char* p_name) { - tBTA_DM_API_SET_NAME* p_msg = - (tBTA_DM_API_SET_NAME*)osi_malloc(sizeof(tBTA_DM_API_SET_NAME)); - - p_msg->hdr.event = BTA_DM_API_SET_NAME_EVT; - strlcpy((char*)p_msg->name, p_name, BD_NAME_LEN); + std::vector name(BD_NAME_LEN); + strlcpy((char*)name.data(), p_name, BD_NAME_LEN); - bta_sys_sendmsg(p_msg); + do_in_bta_thread(FROM_HERE, base::Bind(bta_dm_set_dev_name, name)); } /** This function sets the Bluetooth connectable, discoverable, pairable and @@ -253,21 +239,18 @@ void BTA_DmBondCancel(const RawAddress& bd_addr) { * ******************************************************************************/ void BTA_DmPinReply(const RawAddress& bd_addr, bool accept, uint8_t pin_len, - uint8_t* p_pin) + uint8_t* p_pin) { + std::unique_ptr msg = + std::make_unique(); -{ - tBTA_DM_API_PIN_REPLY* p_msg = - (tBTA_DM_API_PIN_REPLY*)osi_malloc(sizeof(tBTA_DM_API_PIN_REPLY)); - - p_msg->hdr.event = BTA_DM_API_PIN_REPLY_EVT; - p_msg->bd_addr = bd_addr; - p_msg->accept = accept; + msg->bd_addr = bd_addr; + msg->accept = accept; if (accept) { - p_msg->pin_len = pin_len; - memcpy(p_msg->p_pin, p_pin, pin_len); + msg->pin_len = pin_len; + memcpy(msg->p_pin, p_pin, pin_len); } - bta_sys_sendmsg(p_msg); + do_in_bta_thread(FROM_HERE, base::Bind(bta_dm_pin_reply, base::Passed(&msg))); } /******************************************************************************* @@ -316,32 +299,32 @@ void BTA_DmAddDevice(const RawAddress& bd_addr, DEV_CLASS dev_class, LINK_KEY link_key, tBTA_SERVICE_MASK trusted_mask, bool is_trusted, uint8_t key_type, tBTA_IO_CAP io_cap, uint8_t pin_length) { - tBTA_DM_API_ADD_DEVICE* p_msg = - (tBTA_DM_API_ADD_DEVICE*)osi_calloc(sizeof(tBTA_DM_API_ADD_DEVICE)); + std::unique_ptr msg = + std::make_unique(); - p_msg->hdr.event = BTA_DM_API_ADD_DEVICE_EVT; - p_msg->bd_addr = bd_addr; - p_msg->tm = trusted_mask; - p_msg->is_trusted = is_trusted; - p_msg->io_cap = io_cap; + msg->bd_addr = bd_addr; + msg->tm = trusted_mask; + msg->is_trusted = is_trusted; + msg->io_cap = io_cap; if (link_key) { - p_msg->link_key_known = true; - p_msg->key_type = key_type; - memcpy(p_msg->link_key, link_key, LINK_KEY_LEN); + msg->link_key_known = true; + msg->key_type = key_type; + memcpy(msg->link_key, link_key, LINK_KEY_LEN); } /* Load device class if specified */ if (dev_class) { - p_msg->dc_known = true; - memcpy(p_msg->dc, dev_class, DEV_CLASS_LEN); + msg->dc_known = true; + memcpy(msg->dc, dev_class, DEV_CLASS_LEN); } - memset(p_msg->bd_name, 0, BD_NAME_LEN + 1); - memset(p_msg->features, 0, sizeof(p_msg->features)); - p_msg->pin_length = pin_length; + memset(msg->bd_name, 0, BD_NAME_LEN + 1); + memset(msg->features, 0, sizeof(msg->features)); + msg->pin_length = pin_length; - bta_sys_sendmsg(p_msg); + do_in_bta_thread(FROM_HERE, + base::Bind(bta_dm_add_device, base::Passed(&msg))); } /** This function removes a device fromthe security database list of peer @@ -460,15 +443,8 @@ tBTA_STATUS BTA_DmSetLocalDiRecord(tBTA_DI_RECORD* p_device_info, ******************************************************************************/ void BTA_DmAddBleKey(const RawAddress& bd_addr, tBTA_LE_KEY_VALUE* p_le_key, tBTA_LE_KEY_TYPE key_type) { - tBTA_DM_API_ADD_BLEKEY* p_msg = - (tBTA_DM_API_ADD_BLEKEY*)osi_calloc(sizeof(tBTA_DM_API_ADD_BLEKEY)); - - p_msg->hdr.event = BTA_DM_API_ADD_BLEKEY_EVT; - p_msg->key_type = key_type; - p_msg->bd_addr = bd_addr; - memcpy(&p_msg->blekey, p_le_key, sizeof(tBTA_LE_KEY_VALUE)); - - bta_sys_sendmsg(p_msg); + do_in_bta_thread(FROM_HERE, + base::Bind(bta_dm_add_blekey, bd_addr, *p_le_key, key_type)); } /******************************************************************************* diff --git a/bta/dm/bta_dm_ci.cc b/bta/dm/bta_dm_ci.cc index 062d19278..3d4048001 100644 --- a/bta/dm/bta_dm_ci.cc +++ b/bta/dm/bta_dm_ci.cc @@ -21,14 +21,15 @@ * This is the API implementation file for the BTA device manager. * ******************************************************************************/ -#include - #include "bt_common.h" #include "bta_api.h" #include "bta_dm_ci.h" #include "bta_dm_int.h" #include "bta_sys.h" +#include +#include + /******************************************************************************* * * Function bta_dm_ci_io_req @@ -44,16 +45,8 @@ void bta_dm_ci_io_req(const RawAddress& bd_addr, tBTA_IO_CAP io_cap, tBTA_OOB_DATA oob_data, tBTA_AUTH_REQ auth_req) { - tBTA_DM_CI_IO_REQ* p_msg = - (tBTA_DM_CI_IO_REQ*)osi_malloc(sizeof(tBTA_DM_CI_IO_REQ)); - - p_msg->hdr.event = BTA_DM_CI_IO_REQ_EVT; - p_msg->bd_addr = bd_addr; - p_msg->io_cap = io_cap; - p_msg->oob_data = oob_data; - p_msg->auth_req = auth_req; - - bta_sys_sendmsg(p_msg); + do_in_bta_thread(FROM_HERE, base::Bind(bta_dm_ci_io_req_act, bd_addr, io_cap, + oob_data, auth_req)); } /******************************************************************************* @@ -69,15 +62,15 @@ void bta_dm_ci_io_req(const RawAddress& bd_addr, tBTA_IO_CAP io_cap, ******************************************************************************/ void bta_dm_ci_rmt_oob(bool accept, const RawAddress& bd_addr, BT_OCTET16 c, BT_OCTET16 r) { - tBTA_DM_CI_RMT_OOB* p_msg = - (tBTA_DM_CI_RMT_OOB*)osi_malloc(sizeof(tBTA_DM_CI_RMT_OOB)); + std::unique_ptr msg = + std::make_unique(); - p_msg->hdr.event = BTA_DM_CI_RMT_OOB_EVT; - p_msg->bd_addr = bd_addr; - p_msg->accept = accept; - memcpy(p_msg->c, c, BT_OCTET16_LEN); - memcpy(p_msg->r, r, BT_OCTET16_LEN); + msg->bd_addr = bd_addr; + msg->accept = accept; + memcpy(msg->c, c, BT_OCTET16_LEN); + memcpy(msg->r, r, BT_OCTET16_LEN); - bta_sys_sendmsg(p_msg); + do_in_bta_thread(FROM_HERE, + base::Bind(bta_dm_ci_rmt_oob_act, base::Passed(&msg))); } diff --git a/bta/dm/bta_dm_int.h b/bta/dm/bta_dm_int.h index 26551a2b0..d69225b00 100644 --- a/bta/dm/bta_dm_int.h +++ b/bta/dm/bta_dm_int.h @@ -45,24 +45,6 @@ #define BTA_SERVICE_ID_TO_SERVICE_MASK(id) (1 << (id)) -/* DM events */ -enum { - /* device manager local device API events */ - BTA_DM_API_SET_NAME_EVT = BTA_SYS_EVT_START(BTA_ID_DM), - - BTA_DM_ACL_CHANGE_EVT, - BTA_DM_API_ADD_DEVICE_EVT, - - /* security API events */ - BTA_DM_API_PIN_REPLY_EVT, - - BTA_DM_CI_IO_REQ_EVT, - BTA_DM_CI_RMT_OOB_EVT, - - BTA_DM_API_ADD_BLEKEY_EVT, - BTA_DM_MAX_EVT -}; - /* DM search events */ enum { /* DM search API events */ @@ -79,12 +61,6 @@ enum { }; -/* data type for BTA_DM_API_SET_NAME_EVT */ -typedef struct { - BT_HDR hdr; - BD_NAME name; /* max 248 bytes name, plus must be Null terminated */ -} tBTA_DM_API_SET_NAME; - enum { BTA_DM_RS_NONE, /* straight API call */ BTA_DM_RS_OK, /* the role switch result - successful */ @@ -125,16 +101,13 @@ typedef struct { tBTA_DM_SEARCH_CBACK* p_cback; } tBTA_DM_API_DI_DISC; -/* data type for BTA_DM_API_PIN_REPLY_EVT */ typedef struct { - BT_HDR hdr; RawAddress bd_addr; bool accept; uint8_t pin_len; uint8_t p_pin[PIN_CODE_LEN]; } tBTA_DM_API_PIN_REPLY; -/* data type for BTA_DM_CI_IO_REQ_EVT */ typedef struct { BT_HDR hdr; RawAddress bd_addr; @@ -143,9 +116,7 @@ typedef struct { tBTA_AUTH_REQ auth_req; } tBTA_DM_CI_IO_REQ; -/* data type for BTA_DM_CI_RMT_OOB_EVT */ typedef struct { - BT_HDR hdr; RawAddress bd_addr; BT_OCTET16 c; BT_OCTET16 r; @@ -176,23 +147,7 @@ typedef struct { uint16_t sdp_result; } tBTA_DM_SDP_RESULT; -/* data type for BTA_DM_ACL_CHANGE_EVT */ -typedef struct { - BT_HDR hdr; - tBTM_BL_EVENT event; - uint8_t busy_level; - uint8_t busy_level_flags; - bool is_new; - uint8_t new_role; - RawAddress bd_addr; - uint8_t hci_status; - uint16_t handle; - tBT_TRANSPORT transport; -} tBTA_DM_ACL_CHANGE; - -/* data type for BTA_DM_API_ADD_DEVICE_EVT */ typedef struct { - BT_HDR hdr; RawAddress bd_addr; DEV_CLASS dc; LINK_KEY link_key; @@ -210,14 +165,6 @@ typedef struct { typedef struct { BT_HDR hdr; - RawAddress bd_addr; - tBTA_LE_KEY_VALUE blekey; - tBTA_LE_KEY_TYPE key_type; - -} tBTA_DM_API_ADD_BLEKEY; - -typedef struct { - BT_HDR hdr; bool enable; } tBTA_DM_API_BLE_FEATURE; @@ -225,19 +172,11 @@ typedef struct { typedef union { /* GKI event buffer header */ BT_HDR hdr; - tBTA_DM_API_SET_NAME set_name; - - tBTA_DM_API_ADD_DEVICE add_dev; tBTA_DM_API_SEARCH search; tBTA_DM_API_DISCOVER discover; - tBTA_DM_API_PIN_REPLY pin_reply; - - tBTA_DM_CI_IO_REQ ci_io_req; - tBTA_DM_CI_RMT_OOB ci_rmt_oob; - tBTA_DM_REM_NAME rem_name; tBTA_DM_DISC_RESULT disc_result; @@ -246,11 +185,8 @@ typedef union { tBTA_DM_SDP_RESULT sdp_event; - tBTA_DM_ACL_CHANGE acl_change; - tBTA_DM_API_DI_DISC di_disc; - tBTA_DM_API_ADD_BLEKEY add_ble_key; } tBTA_DM_MSG; #define BTA_DM_NUM_PEER_DEVICE 7 @@ -530,23 +466,20 @@ extern tBTA_DM_SEARCH_CB bta_dm_search_cb; /* DI control block */ extern tBTA_DM_DI_CB bta_dm_di_cb; -extern bool bta_dm_sm_execute(BT_HDR* p_msg); -extern void bta_dm_sm_disable(void); extern bool bta_dm_search_sm_execute(BT_HDR* p_msg); extern void bta_dm_search_sm_disable(void); extern void bta_dm_enable(tBTA_DM_SEC_CBACK*); extern void bta_dm_disable(); extern void bta_dm_init_cb(void); -extern void bta_dm_set_dev_name(tBTA_DM_MSG* p_data); +extern void bta_dm_set_dev_name(const std::vector&); extern void bta_dm_set_visibility(tBTA_DM_DISC, tBTA_DM_CONN, uint8_t, uint8_t); extern void bta_dm_set_scan_config(tBTA_DM_MSG* p_data); extern void bta_dm_vendor_spec_command(tBTA_DM_MSG* p_data); extern void bta_dm_bond(const RawAddress&, tBTA_TRANSPORT); extern void bta_dm_bond_cancel(const RawAddress&); -extern void bta_dm_pin_reply(tBTA_DM_MSG* p_data); -extern void bta_dm_acl_change(tBTA_DM_MSG* p_data); -extern void bta_dm_add_device(tBTA_DM_MSG* p_data); +extern void bta_dm_pin_reply(std::unique_ptr msg); +extern void bta_dm_add_device(std::unique_ptr msg); extern void bta_dm_remove_device(const RawAddress& bd_addr); extern void bta_dm_close_acl(const RawAddress&, bool, tBTA_TRANSPORT); @@ -555,7 +488,9 @@ extern void bta_dm_pm_btm_status(const RawAddress&, tBTM_PM_STATUS, uint16_t, extern void bta_dm_pm_timer(const RawAddress&, tBTA_DM_PM_ACTION); extern void bta_dm_add_ampkey(tBTA_DM_MSG* p_data); -extern void bta_dm_add_blekey(tBTA_DM_MSG* p_data); +extern void bta_dm_add_blekey(const RawAddress& bd_addr, + tBTA_LE_KEY_VALUE blekey, + tBTA_LE_KEY_TYPE key_type); extern void bta_dm_add_ble_device(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, tBT_DEVICE_TYPE dev_type); @@ -581,8 +516,10 @@ extern void bta_dm_ble_get_energy_info(tBTA_BLE_ENERGY_INFO_CBACK*); extern void bta_dm_set_encryption(const RawAddress&, tBTA_TRANSPORT, tBTA_DM_ENCRYPT_CBACK*, tBTA_DM_BLE_SEC_ACT); extern void bta_dm_confirm(const RawAddress&, bool); -extern void bta_dm_ci_io_req_act(tBTA_DM_MSG* p_data); -extern void bta_dm_ci_rmt_oob_act(tBTA_DM_MSG* p_data); +extern void bta_dm_ci_io_req_act(const RawAddress& bd_addr, tBTA_IO_CAP io_cap, + tBTA_OOB_DATA oob_data, + tBTA_AUTH_REQ auth_req); +extern void bta_dm_ci_rmt_oob_act(std::unique_ptr msg); extern void bta_dm_init_pm(void); extern void bta_dm_disable_pm(void); @@ -612,8 +549,5 @@ extern tBTA_DM_PEER_DEVICE* bta_dm_find_peer_device( void bta_dm_eir_update_uuid(uint16_t uuid16, bool adding); -extern void bta_dm_enable_test_mode(); -extern void bta_dm_disable_test_mode(); - extern void bta_dm_remove_all_acl(const tBTA_DM_LINK_TYPE); #endif /* BTA_DM_INT_H */ diff --git a/bta/dm/bta_dm_main.cc b/bta/dm/bta_dm_main.cc index 5831162d2..f9bffe66b 100644 --- a/bta/dm/bta_dm_main.cc +++ b/bta/dm/bta_dm_main.cc @@ -39,24 +39,6 @@ tBTA_DM_DI_CB bta_dm_di_cb; /* type for action functions */ typedef void (*tBTA_DM_ACTION)(tBTA_DM_MSG* p_data); -/* action function list */ -const tBTA_DM_ACTION bta_dm_action[] = { - - /* device manager local device API events */ - bta_dm_set_dev_name, /* 1 BTA_DM_API_SET_NAME_EVT */ - bta_dm_acl_change, /* 2 BTA_DM_ACL_CHANGE_EVT */ - bta_dm_add_device, /* 3 BTA_DM_API_ADD_DEVICE_EVT */ - - /* security API events */ - bta_dm_pin_reply, /* 4 BTA_DM_API_PIN_REPLY_EVT */ - - /* out of band pairing events */ - bta_dm_ci_io_req_act, /* 5 BTA_DM_CI_IO_REQ_EVT */ - bta_dm_ci_rmt_oob_act, /* 6 BTA_DM_CI_RMT_OOB_EVT */ - - bta_dm_add_blekey, /* 7 BTA_DM_API_ADD_BLEKEY_EVT */ -}; - /* state machine action enumeration list */ enum { BTA_DM_API_SEARCH, /* 0 bta_dm_search_start */ @@ -225,41 +207,6 @@ const tBTA_DM_ST_TBL bta_dm_search_st_tbl[] = { /******************************************************************************* * - * Function bta_dm_sm_disable - * - * Description unregister BTA DM - * - * - * Returns void - * - ******************************************************************************/ -void bta_dm_sm_disable() { bta_sys_deregister(BTA_ID_DM); } - -/******************************************************************************* - * - * Function bta_dm_sm_execute - * - * Description State machine event handling function for DM - * - * - * Returns void - * - ******************************************************************************/ -bool bta_dm_sm_execute(BT_HDR* p_msg) { - uint16_t event = p_msg->event & 0x00ff; - - APPL_TRACE_EVENT("bta_dm_sm_execute event:0x%x", event); - - /* execute action functions */ - if (event < BTA_DM_NUM_ACTIONS) { - (*bta_dm_action[event])((tBTA_DM_MSG*)p_msg); - } - - return true; -} - -/******************************************************************************* - * * Function bta_dm_sm_search_disable * * Description unregister BTA SEARCH DM diff --git a/bta/sys/bta_sys.h b/bta/sys/bta_sys.h index 400310434..9a3dec0e6 100644 --- a/bta/sys/bta_sys.h +++ b/bta/sys/bta_sys.h @@ -61,7 +61,6 @@ typedef uint16_t tBTA_SYS_HW_MODULE; /* SW sub-systems */ #define BTA_ID_SYS 0 /* system manager */ /* BLUETOOTH PART - from 0 to BTA_ID_BLUETOOTH_MAX */ -#define BTA_ID_DM 1 /* device manager */ #define BTA_ID_DM_SEARCH 2 /* device manager search */ #define BTA_ID_DM_SEC 3 /* device manager security */ #define BTA_ID_DG 4 /* data gateway */ diff --git a/bta/sys/bta_sys_main.cc b/bta/sys/bta_sys_main.cc index edf927dd6..8d155dbb7 100644 --- a/bta/sys/bta_sys_main.cc +++ b/bta/sys/bta_sys_main.cc @@ -599,7 +599,7 @@ void bta_sys_disable(tBTA_SYS_HW_MODULE module) { switch (module) { case BTA_SYS_HW_BLUETOOTH: - bta_id = BTA_ID_DM; + bta_id = BTA_ID_DM_SEARCH; bta_id_max = BTA_ID_BLUETOOTH_MAX; break; default: