diff --git a/components/bt/common/btc/core/btc_task.c b/components/bt/common/btc/core/btc_task.c index c240004a16..41c0b4368e 100644 --- a/components/bt/common/btc/core/btc_task.c +++ b/components/bt/common/btc/core/btc_task.c @@ -490,10 +490,10 @@ static bt_status_t btc_init_mem(void) { #endif #if BTC_HF_INCLUDED == TRUE && HFP_DYNAMIC_MEMORY == TRUE - if ((hf_local_param_ptr = (hf_local_param_t *)osi_malloc(BTC_HF_NUM_CB * sizeof(hf_local_param_t))) == NULL) { + if ((hf_local_param_ptr = (hf_local_param_t *)osi_malloc(sizeof(hf_local_param_t))) == NULL) { goto error_exit; } - memset((void *)hf_local_param_ptr, 0, BTC_HF_NUM_CB * sizeof(hf_local_param_t)); + memset((void *)hf_local_param_ptr, 0, sizeof(hf_local_param_t)); #endif #if BTC_HF_CLIENT_INCLUDED == TRUE && HFP_DYNAMIC_MEMORY == TRUE diff --git a/components/bt/host/bluedroid/btc/profile/std/hf_ag/btc_hf_ag.c b/components/bt/host/bluedroid/btc/profile/std/hf_ag/btc_hf_ag.c index b7df3635c0..0e4947ee41 100644 --- a/components/bt/host/bluedroid/btc/profile/std/hf_ag/btc_hf_ag.c +++ b/components/bt/host/bluedroid/btc/profile/std/hf_ag/btc_hf_ag.c @@ -66,7 +66,7 @@ static UINT16 btc_max_hf_clients = BTC_HF_NUM_CB; /* HF Param Definition */ #if HFP_DYNAMIC_MEMORY == FALSE -static hf_local_param_t hf_local_param[BTC_HF_NUM_CB]; +static hf_local_param_t hf_local_param; #else hf_local_param_t *hf_local_param_ptr = NULL; #endif @@ -117,7 +117,7 @@ do { if ((idx < 0) || (idx >= BTC_HF_NUM_CB)) { \ return BT_STATUS_FAIL; \ } \ - if (!hf_local_param[idx].btc_hf_cb.initialized) { \ + if (!hf_local_param.initialized) { \ BTIF_TRACE_WARNING("CHECK_HF_INIT: %s: HF AG not initialized", __FUNCTION__); \ return BT_STATUS_NOT_READY; \ } else { \ @@ -130,8 +130,8 @@ do { if ((idx < 0) || (idx >= BTC_HF_NUM_CB)) { \ return BT_STATUS_FAIL; \ } \ - if (!hf_local_param[idx].btc_hf_cb.initialized || \ - hf_local_param[idx].btc_hf_cb.connection_state != ESP_HF_CONNECTION_STATE_SLC_CONNECTED) { \ + if (!hf_local_param.initialized || \ + hf_local_param.btc_hf_cb[idx].connection_state != ESP_HF_CONNECTION_STATE_SLC_CONNECTED) { \ BTIF_TRACE_WARNING("CHECK_HF_SLC_CONNECTED: %s: HF AG SLC not connected", __FUNCTION__); \ return BT_STATUS_NOT_READY; \ } else { \ @@ -141,10 +141,10 @@ do { #define clear_phone_state() \ - hf_local_param[idx].btc_hf_cb.call_state = ESP_HF_CALL_STATUS_NO_CALLS; \ - hf_local_param[idx].btc_hf_cb.call_setup_state = ESP_HF_CALL_SETUP_STATUS_IDLE;\ - hf_local_param[idx].btc_hf_cb.num_active = 0; \ - hf_local_param[idx].btc_hf_cb.num_held = 0; + hf_local_param.btc_hf_cb[idx].call_state = ESP_HF_CALL_STATUS_NO_CALLS; \ + hf_local_param.btc_hf_cb[idx].call_setup_state = ESP_HF_CALL_SETUP_STATUS_IDLE;\ + hf_local_param.btc_hf_cb[idx].num_active = 0; \ + hf_local_param.btc_hf_cb[idx].num_held = 0; #define CHECK_HF_IDX(idx) \ do { \ @@ -160,7 +160,7 @@ do { static int btc_hf_idx_by_bdaddr(bt_bdaddr_t *bd_addr) { for (int i = 0; i < btc_max_hf_clients; ++i) { - if (bdcmp(bd_addr->address, hf_local_param[i].btc_hf_cb.connected_bda.address) == 0) { + if (bdcmp(bd_addr->address, hf_local_param.btc_hf_cb[i].connected_bda.address) == 0) { return i; } } @@ -170,8 +170,8 @@ static int btc_hf_idx_by_bdaddr(bt_bdaddr_t *bd_addr) static int btc_hf_find_free_idx(void) { for (int idx = 0; idx < btc_max_hf_clients; ++idx) { - if (hf_local_param[idx].btc_hf_cb.initialized && - hf_local_param[idx].btc_hf_cb.connection_state == ESP_HF_CONNECTION_STATE_DISCONNECTED) { + if (hf_local_param.initialized && + hf_local_param.btc_hf_cb[idx].connection_state == ESP_HF_CONNECTION_STATE_DISCONNECTED) { return idx; } } @@ -180,9 +180,9 @@ static int btc_hf_find_free_idx(void) static BOOLEAN is_connected(int idx, bt_bdaddr_t *bd_addr) { - if ((bdcmp(bd_addr->address,hf_local_param[idx].btc_hf_cb.connected_bda.address) == 0) && - ((hf_local_param[idx].btc_hf_cb.connection_state == ESP_HF_CONNECTION_STATE_CONNECTED) || - (hf_local_param[idx].btc_hf_cb.connection_state == ESP_HF_CONNECTION_STATE_SLC_CONNECTED))) { + if ((bdcmp(bd_addr->address,hf_local_param.btc_hf_cb[idx].connected_bda.address) == 0) && + ((hf_local_param.btc_hf_cb[idx].connection_state == ESP_HF_CONNECTION_STATE_CONNECTED) || + (hf_local_param.btc_hf_cb[idx].connection_state == ESP_HF_CONNECTION_STATE_SLC_CONNECTED))) { return TRUE; } return FALSE; @@ -196,9 +196,9 @@ static int btc_hf_latest_connected_idx(void) conn_time_delta.tv_sec = now.tv_sec; for (int i = 0; i < btc_max_hf_clients; i++) { - if (hf_local_param[i].btc_hf_cb.connection_state == ESP_HF_CONNECTION_STATE_SLC_CONNECTED) { - if ((now.tv_sec - hf_local_param[i].btc_hf_cb.connected_timestamp.tv_sec) < conn_time_delta.tv_sec) { - conn_time_delta.tv_sec = now.tv_sec - hf_local_param[i].btc_hf_cb.connected_timestamp.tv_sec; + if (hf_local_param.btc_hf_cb[i].connection_state == ESP_HF_CONNECTION_STATE_SLC_CONNECTED) { + if ((now.tv_sec - hf_local_param.btc_hf_cb[i].connected_timestamp.tv_sec) < conn_time_delta.tv_sec) { + conn_time_delta.tv_sec = now.tv_sec - hf_local_param.btc_hf_cb[i].connected_timestamp.tv_sec; latest_conn_idx = i; } } @@ -264,24 +264,24 @@ static void bte_hf_evt(tBTA_AG_EVT event, tBTA_AG *param) ************************************************************************************/ void btc_hf_reg_data_cb(esp_hf_incoming_data_cb_t recv, esp_hf_outgoing_data_cb_t send) { - hf_local_param[0].btc_hf_incoming_data_cb = recv; - hf_local_param[0].btc_hf_outgoing_data_cb = send; + hf_local_param.btc_hf_incoming_data_cb = recv; + hf_local_param.btc_hf_outgoing_data_cb = send; } void btc_hf_reg_audio_data_cb(esp_hf_ag_audio_data_cb_t callback) { - hf_local_param[0].btc_hf_audio_data_cb = callback; + hf_local_param.btc_hf_audio_data_cb = callback; } void btc_hf_audio_data_cb_to_app(uint8_t *buf, uint8_t *data, uint16_t len, bool is_bad_frame) { - if (hf_local_param[0].btc_hf_audio_data_cb) { + if (hf_local_param.btc_hf_audio_data_cb) { /* we always have sizeof(BT_HDR) bytes free space before data, it is enough for esp_hf_audio_buff_t */ esp_hf_audio_buff_t *audio_buff = (esp_hf_audio_buff_t *)buf; audio_buff->buff_size = len; audio_buff->data_len = len; audio_buff->data = data; - hf_local_param[0].btc_hf_audio_data_cb(hf_local_param[0].btc_hf_cb.sync_conn_hdl, audio_buff, is_bad_frame); + hf_local_param.btc_hf_audio_data_cb(hf_local_param.btc_hf_cb[0].sync_conn_hdl, audio_buff, is_bad_frame); } else { osi_free(buf); @@ -290,19 +290,17 @@ void btc_hf_audio_data_cb_to_app(uint8_t *buf, uint8_t *data, uint16_t len, bool void btc_hf_incoming_data_cb_to_app(const uint8_t *data, uint32_t len) { - int idx = 0; // todo: critical section protection - if (hf_local_param[idx].btc_hf_incoming_data_cb) { - hf_local_param[idx].btc_hf_incoming_data_cb(data, len); + if (hf_local_param.btc_hf_incoming_data_cb) { + hf_local_param.btc_hf_incoming_data_cb(data, len); } } uint32_t btc_hf_outgoing_data_cb_to_app(uint8_t *data, uint32_t len) { - int idx = 0; // todo: critical section protection - if (hf_local_param[idx].btc_hf_outgoing_data_cb) { - return hf_local_param[idx].btc_hf_outgoing_data_cb(data, len); + if (hf_local_param.btc_hf_outgoing_data_cb) { + return hf_local_param.btc_hf_outgoing_data_cb(data, len); } else { return 0; } @@ -321,7 +319,7 @@ bt_status_t btc_hf_execute_service(BOOLEAN b_enable) } else { /* De-register AG */ for (idx = 0; idx < btc_max_hf_clients; idx++) { - BTA_AgDeregister(hf_local_param[idx].btc_hf_cb.handle); + BTA_AgDeregister(hf_local_param.btc_hf_cb[idx].handle); } /* Disable AG */ BTA_AgDisable(); @@ -339,30 +337,29 @@ bt_status_t btc_hf_init(void) { int idx = 0; -#if HFP_DYNAMIC_MEMORY == TRUE - if (hf_local_param) -#endif - { - if (hf_local_param[idx].btc_hf_cb.initialized) { - esp_hf_cb_param_t param = { - .prof_stat.state = ESP_HF_INIT_ALREADY, - }; - btc_hf_cb_to_app(ESP_HF_PROF_STATE_EVT, ¶m); - return BT_STATUS_SUCCESS; - } + if (hf_local_param.initialized) { + esp_hf_cb_param_t param = { + .prof_stat.state = ESP_HF_INIT_ALREADY, + }; + btc_hf_cb_to_app(ESP_HF_PROF_STATE_EVT, ¶m); + return BT_STATUS_SUCCESS; } BTC_TRACE_DEBUG("%s - max_hf_clients=%d", __func__, btc_max_hf_clients); -#if HFP_DYNAMIC_MEMORY == TRUE - if (hf_local_param == NULL) { - if ((hf_local_param = (hf_local_param_t *)osi_malloc(BTC_HF_NUM_CB * sizeof(hf_local_param_t))) == NULL) { + if (hf_local_param.btc_hf_cb == NULL) { + hf_local_param.btc_hf_cb = (btc_hf_cb_t *)osi_malloc(BTC_HF_NUM_CB * sizeof(btc_hf_cb_t)); + if (hf_local_param.btc_hf_cb == NULL) { BTC_TRACE_ERROR("%s malloc failed!", __func__); return BT_STATUS_NOMEM; } } - memset((void *)hf_local_param, 0, BTC_HF_NUM_CB * sizeof(hf_local_param_t)); -#endif + + memset(hf_local_param.btc_hf_cb, 0, BTC_HF_NUM_CB * sizeof(btc_hf_cb_t)); + for (int i = 0; i < BTC_HF_NUM_CB; i++) { + hf_local_param.btc_hf_cb[i].sync_conn_hdl = ESP_INVALID_CONN_HANDLE; + } + hf_local_param.hf_idx = BTC_HF_INVALID_IDX; /* Invoke the enable service API to the core to set the appropriate service_id * Internally, the HSP_SERVICE_ID shall also be enabled if HFP is enabled (phone) @@ -373,10 +370,7 @@ bt_status_t btc_hf_init(void) btc_dm_enable_service(BTA_HSP_SERVICE_ID); #endif clear_phone_state(); - memset(&hf_local_param[idx].btc_hf_cb, 0, sizeof(btc_hf_cb_t)); - for (int i = 0; i < BTC_HF_NUM_CB; i++) { - hf_local_param[i].btc_hf_cb.sync_conn_hdl = ESP_INVALID_CONN_HANDLE; - } + // set audio path #if (BT_CONTROLLER_INCLUDED == TRUE) #if BTM_SCO_HCI_INCLUDED @@ -394,19 +388,12 @@ void btc_hf_deinit(void) { BTC_TRACE_EVENT("%s", __FUNCTION__); - int idx = 0; - -#if HFP_DYNAMIC_MEMORY == TRUE - if (hf_local_param) -#endif - { - if (!hf_local_param[idx].btc_hf_cb.initialized) { - esp_hf_cb_param_t param = { - .prof_stat.state = ESP_HF_DEINIT_ALREADY, - }; - btc_hf_cb_to_app(ESP_HF_PROF_STATE_EVT, ¶m); - return; - } + if (!hf_local_param.initialized) { + esp_hf_cb_param_t param = { + .prof_stat.state = ESP_HF_DEINIT_ALREADY, + }; + btc_hf_cb_to_app(ESP_HF_PROF_STATE_EVT, ¶m); + return; } btc_dm_disable_service(BTA_HFP_SERVICE_ID); @@ -414,12 +401,8 @@ void btc_hf_deinit(void) static void btc_hf_cb_release(void) { -#if HFP_DYNAMIC_MEMORY == TRUE - if (hf_local_param) { - osi_free(hf_local_param); - hf_local_param = NULL; - } -#endif + osi_free(hf_local_param.btc_hf_cb); + hf_local_param.btc_hf_cb = NULL; } static bt_status_t connect_init(bt_bdaddr_t *bd_addr, uint16_t uuid) @@ -431,9 +414,9 @@ static bt_status_t connect_init(bt_bdaddr_t *bd_addr, uint16_t uuid) } if (!is_connected(idx, bd_addr)) { - hf_local_param[idx].btc_hf_cb.connection_state = ESP_HF_CONNECTION_STATE_CONNECTING; - bdcpy(hf_local_param[idx].btc_hf_cb.connected_bda.address, bd_addr->address); - BTA_AgOpen(hf_local_param[idx].btc_hf_cb.handle, hf_local_param[idx].btc_hf_cb.connected_bda.address, BTC_HF_SECURITY, BTC_HF_SERVICES); + hf_local_param.btc_hf_cb[idx].connection_state = ESP_HF_CONNECTION_STATE_CONNECTING; + bdcpy(hf_local_param.btc_hf_cb[idx].connected_bda.address, bd_addr->address); + BTA_AgOpen(hf_local_param.btc_hf_cb[idx].handle, hf_local_param.btc_hf_cb[idx].connected_bda.address, BTC_HF_SECURITY, BTC_HF_SERVICES); return BT_STATUS_SUCCESS; } return BT_STATUS_BUSY; @@ -453,7 +436,7 @@ bt_status_t btc_hf_disconnect(bt_bdaddr_t *bd_addr) } if (is_connected(idx, bd_addr)) { - BTA_AgClose(hf_local_param[idx].btc_hf_cb.handle); + BTA_AgClose(hf_local_param.btc_hf_cb[idx].handle); return BT_STATUS_SUCCESS; } return BT_STATUS_FAIL; @@ -465,13 +448,13 @@ bt_status_t btc_hf_connect_audio(bt_bdaddr_t *bd_addr) CHECK_HF_SLC_CONNECTED(idx); if (is_connected(idx, bd_addr)) { - BTA_AgAudioOpen(hf_local_param[idx].btc_hf_cb.handle); + BTA_AgAudioOpen(hf_local_param.btc_hf_cb[idx].handle); /* Inform the application that the audio connection has been initiated successfully */ do { esp_hf_cb_param_t param; memset(¶m, 0, sizeof(esp_hf_cb_param_t)); param.audio_stat.state = ESP_HF_AUDIO_STATE_CONNECTING; - memcpy(param.audio_stat.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda, sizeof(esp_bd_addr_t)); + memcpy(param.audio_stat.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda, sizeof(esp_bd_addr_t)); btc_hf_cb_to_app(ESP_HF_AUDIO_STATE_EVT, ¶m); } while (0); return BT_STATUS_SUCCESS; @@ -485,7 +468,7 @@ bt_status_t btc_hf_disconnect_audio(bt_bdaddr_t *bd_addr) CHECK_HF_SLC_CONNECTED(idx); if (is_connected(idx, bd_addr)) { - BTA_AgAudioClose(hf_local_param[idx].btc_hf_cb.handle); + BTA_AgAudioClose(hf_local_param.btc_hf_cb[idx].handle); return BT_STATUS_SUCCESS; } return BT_STATUS_FAIL; @@ -499,7 +482,7 @@ static bt_status_t btc_hf_pkt_stat_nums_get(UINT16 sync_conn_handle) CHECK_HF_SLC_CONNECTED(idx); if (idx != BTC_HF_INVALID_IDX) { - BTA_AgPktStatsNumsGet(hf_local_param[idx].btc_hf_cb.handle, sync_conn_handle); + BTA_AgPktStatsNumsGet(hf_local_param.btc_hf_cb[idx].handle, sync_conn_handle); status = BT_STATUS_SUCCESS; } #endif /*#if (BTM_SCO_HCI_INCLUDED == TRUE) */ @@ -516,11 +499,11 @@ static bt_status_t btc_hf_vra(bt_bdaddr_t *bd_addr, esp_hf_vr_state_t value) CHECK_HF_SLC_CONNECTED(idx); if (is_connected(idx, bd_addr)) { - if (hf_local_param[idx].btc_hf_cb.peer_feat & BTA_AG_PEER_FEAT_VREC) { + if (hf_local_param.btc_hf_cb[idx].peer_feat & BTA_AG_PEER_FEAT_VREC) { tBTA_AG_RES_DATA ag_res; memset(&ag_res, 0, sizeof(ag_res)); ag_res.state = value; - BTA_AgResult(hf_local_param[idx].btc_hf_cb.handle, BTA_AG_BVRA_RES, &ag_res); + BTA_AgResult(hf_local_param.btc_hf_cb[idx].handle, BTA_AG_BVRA_RES, &ag_res); return BT_STATUS_SUCCESS; } else { return BT_STATUS_UNSUPPORTED; @@ -538,7 +521,7 @@ static bt_status_t btc_hf_volume_control(bt_bdaddr_t *bd_addr, esp_hf_volume_typ if (is_connected(idx, bd_addr)) { ag_res.num = volume; - BTA_AgResult(hf_local_param[idx].btc_hf_cb.handle, (type == ESP_HF_VOLUME_TYPE_SPK) ? BTA_AG_SPK_RES : BTA_AG_MIC_RES, &ag_res); + BTA_AgResult(hf_local_param.btc_hf_cb[idx].handle, (type == ESP_HF_VOLUME_TYPE_SPK) ? BTA_AG_SPK_RES : BTA_AG_MIC_RES, &ag_res); return BT_STATUS_SUCCESS; } return BT_STATUS_FAIL; @@ -562,7 +545,7 @@ static bt_status_t btc_hf_unat_response(bt_bdaddr_t *bd_addr, const char *unat) ag_res.errcode = BTA_AG_ERR_OP_NOT_SUPPORTED; } - BTA_AgResult(hf_local_param[idx].btc_hf_cb.handle, BTA_AG_UNAT_RES, &ag_res); + BTA_AgResult(hf_local_param.btc_hf_cb[idx].handle, BTA_AG_UNAT_RES, &ag_res); return BT_STATUS_SUCCESS; } return BT_STATUS_FAIL; @@ -583,7 +566,7 @@ static bt_status_t btc_hf_cmee_response(bt_bdaddr_t *bd_addr, esp_hf_at_response ag_res.ok_flag = BTA_AG_OK_ERROR; ag_res.errcode = error_code; } - BTA_AgResult(hf_local_param[idx].btc_hf_cb.handle, BTA_AG_UNAT_RES, &ag_res); + BTA_AgResult(hf_local_param.btc_hf_cb[idx].handle, BTA_AG_UNAT_RES, &ag_res); return BT_STATUS_SUCCESS; } return BT_STATUS_FAIL; @@ -644,7 +627,7 @@ static bt_status_t btc_hf_cind_response(bt_bdaddr_t *bd_addr, batt_lev, /* Battery level */ call_held_status /* Callheld state */ ); - BTA_AgResult(hf_local_param[idx].btc_hf_cb.handle, BTA_AG_CIND_RES, &ag_res); + BTA_AgResult(hf_local_param.btc_hf_cb[idx].handle, BTA_AG_CIND_RES, &ag_res); return BT_STATUS_SUCCESS; } return BT_STATUS_FAIL; @@ -662,7 +645,7 @@ static bt_status_t btc_hf_cops_response(bt_bdaddr_t *bd_addr, const char *name) /* Format the response */ sprintf(ag_res.str, "0,0,\"%s\"", name); ag_res.ok_flag = BTA_AG_OK_DONE; - BTA_AgResult(hf_local_param[idx].btc_hf_cb.handle, BTA_AG_COPS_RES, &ag_res); + BTA_AgResult(hf_local_param.btc_hf_cb[idx].handle, BTA_AG_COPS_RES, &ag_res); return BT_STATUS_SUCCESS; } return BT_STATUS_FAIL; @@ -694,7 +677,7 @@ static bt_status_t btc_hf_clcc_response(bt_bdaddr_t *bd_addr, int index, esp_hf_ } } } - BTA_AgResult(hf_local_param[idx].btc_hf_cb.handle, BTA_AG_CLCC_RES, &ag_res); + BTA_AgResult(hf_local_param.btc_hf_cb[idx].handle, BTA_AG_CLCC_RES, &ag_res); return BT_STATUS_SUCCESS; } return BT_STATUS_FAIL; @@ -716,7 +699,7 @@ static bt_status_t btc_hf_cnum_response(bt_bdaddr_t *bd_addr, const char *number sprintf(ag_res.str, ",\"%s\",%d,,",number, number_type); } ag_res.ok_flag = BTA_AG_OK_DONE; - BTA_AgResult(hf_local_param[idx].btc_hf_cb.handle, BTA_AG_CNUM_RES, &ag_res); + BTA_AgResult(hf_local_param.btc_hf_cb[idx].handle, BTA_AG_CNUM_RES, &ag_res); return BT_STATUS_SUCCESS; } return BT_STATUS_FAIL; @@ -732,7 +715,7 @@ static bt_status_t btc_hf_inband_ring(bt_bdaddr_t *bd_addr, esp_hf_in_band_ring_ tBTA_AG_RES_DATA ag_res; memset (&ag_res, 0, sizeof (ag_res)); ag_res.state = state; - BTA_AgResult(hf_local_param[idx].btc_hf_cb.handle, BTA_AG_INBAND_RING_RES, &ag_res); + BTA_AgResult(hf_local_param.btc_hf_cb[idx].handle, BTA_AG_INBAND_RING_RES, &ag_res); return BT_STATUS_SUCCESS; } return BT_STATUS_FAIL; @@ -750,8 +733,8 @@ static bt_status_t btc_hf_phone_state_update(bt_bdaddr_t *bd_addr,int num_active int idx = btc_hf_idx_by_bdaddr(bd_addr), i; /* hf_idx is index of connected HS that sent ATA/BLDN, otherwise index of latest connected HS */ - if (hf_local_param->hf_idx != BTC_HF_INVALID_IDX) { - idx = hf_local_param->hf_idx; + if (hf_local_param.hf_idx != BTC_HF_INVALID_IDX) { + idx = hf_local_param.hf_idx; } else { idx = btc_hf_latest_connected_idx(); } @@ -759,28 +742,28 @@ static bt_status_t btc_hf_phone_state_update(bt_bdaddr_t *bd_addr,int num_active BTC_TRACE_DEBUG("phone_state_change: idx = %d", idx); CHECK_HF_SLC_CONNECTED(idx); BTC_TRACE_DEBUG("phone_state_change: num_active=%d [prev: %d] num_held=%d[prev: %d] call =%s [prev: %s] call_setup=%s [prev: %s]", - num_active, hf_local_param[idx].btc_hf_cb.num_active, - num_held, hf_local_param[idx].btc_hf_cb.num_held, - dump_hf_call_state(call_state), dump_hf_call_state(hf_local_param[idx].btc_hf_cb.call_state), - dump_hf_call_setup_state(call_setup_state), dump_hf_call_setup_state(hf_local_param[idx].btc_hf_cb.call_setup_state)); + num_active, hf_local_param.btc_hf_cb[idx].num_active, + num_held, hf_local_param.btc_hf_cb[idx].num_held, + dump_hf_call_state(call_state), dump_hf_call_state(hf_local_param.btc_hf_cb[idx].call_state), + dump_hf_call_setup_state(call_setup_state), dump_hf_call_setup_state(hf_local_param.btc_hf_cb[idx].call_setup_state)); /* If all indicators are 0, send end call and return */ if (num_active == 0 && num_held == 0 && call_state == ESP_HF_CALL_STATUS_NO_CALLS && call_setup_state == ESP_HF_CALL_SETUP_STATUS_IDLE) { BTC_TRACE_DEBUG("%s: Phone on hook", __FUNCTION__); /* Record call termination timestamp if there was an active/held call or call_setup_state > ESP_HF_CALL_SETUP_STATUS_IDLE */ - if ((hf_local_param[idx].btc_hf_cb.call_state != ESP_HF_CALL_STATUS_NO_CALLS) || - (hf_local_param[idx].btc_hf_cb.call_setup_state != ESP_HF_CALL_SETUP_STATUS_IDLE) || - (hf_local_param[idx].btc_hf_cb.num_active) || - (hf_local_param[idx].btc_hf_cb.num_held)) { + if ((hf_local_param.btc_hf_cb[idx].call_state != ESP_HF_CALL_STATUS_NO_CALLS) || + (hf_local_param.btc_hf_cb[idx].call_setup_state != ESP_HF_CALL_SETUP_STATUS_IDLE) || + (hf_local_param.btc_hf_cb[idx].num_active) || + (hf_local_param.btc_hf_cb[idx].num_held)) { BTC_TRACE_DEBUG("%s: Record call termination timestamp", __FUNCTION__); - clock_gettime(CLOCK_MONOTONIC, &hf_local_param[0].btc_hf_cb.call_end_timestamp); + clock_gettime(CLOCK_MONOTONIC, &hf_local_param.btc_hf_cb[idx].call_end_timestamp); } BTA_AgResult(BTA_AG_HANDLE_ALL, BTA_AG_END_CALL_RES, NULL); - hf_local_param->hf_idx = BTC_HF_INVALID_IDX; + hf_local_param.hf_idx = BTC_HF_INVALID_IDX; /* If held call was present, reset that as well. */ - if (hf_local_param[idx].btc_hf_cb.num_held) { + if (hf_local_param.btc_hf_cb[idx].num_held) { send_indicator_update(BTA_AG_IND_CALLHELD, 0); } goto update_call_states; @@ -794,13 +777,13 @@ static bt_status_t btc_hf_phone_state_update(bt_bdaddr_t *bd_addr,int num_active /* Handle case(3) here prior to call setup handling.*/ if (((num_active + num_held) > 0) && - (hf_local_param[idx].btc_hf_cb.num_active == 0) && - (hf_local_param[idx].btc_hf_cb.num_held == 0) && - (hf_local_param[idx].btc_hf_cb.call_setup_state == ESP_HF_CALL_SETUP_STATUS_IDLE)) { + (hf_local_param.btc_hf_cb[idx].num_active == 0) && + (hf_local_param.btc_hf_cb[idx].num_held == 0) && + (hf_local_param.btc_hf_cb[idx].call_setup_state == ESP_HF_CALL_SETUP_STATUS_IDLE)) { BTC_TRACE_DEBUG("%s: Active/Held call notification received without call setup update", __FUNCTION__); memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA)); - ag_res.audio_handle = hf_local_param[idx].btc_hf_cb.handle; + ag_res.audio_handle = hf_local_param.btc_hf_cb[idx].handle; /* Addition callsetup with the Active call. */ if (call_setup_state != ESP_HF_CALL_SETUP_STATUS_IDLE) { @@ -816,9 +799,9 @@ static bt_status_t btc_hf_phone_state_update(bt_bdaddr_t *bd_addr,int num_active } /* Handle call_setup indicator change. */ - if (call_setup_state != hf_local_param[idx].btc_hf_cb.call_setup_state) { + if (call_setup_state != hf_local_param.btc_hf_cb[idx].call_setup_state) { BTC_TRACE_DEBUG("%s: Call setup states changed. old: %s new: %s", __FUNCTION__, - dump_hf_call_setup_state(hf_local_param[idx].btc_hf_cb.call_setup_state), + dump_hf_call_setup_state(hf_local_param.btc_hf_cb[idx].call_setup_state), dump_hf_call_setup_state(call_setup_state)); memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA)); @@ -826,14 +809,14 @@ static bt_status_t btc_hf_phone_state_update(bt_bdaddr_t *bd_addr,int num_active { case ESP_HF_CALL_SETUP_STATUS_IDLE: { - switch(hf_local_param[idx].btc_hf_cb.call_setup_state) + switch(hf_local_param.btc_hf_cb[idx].call_setup_state) { case ESP_HF_CALL_SETUP_STATUS_INCOMING: { - if (num_active > hf_local_param[idx].btc_hf_cb.num_active) { + if (num_active > hf_local_param.btc_hf_cb[idx].num_active) { res = BTA_AG_IN_CALL_CONN_RES; - ag_res.audio_handle = hf_local_param[idx].btc_hf_cb.handle; - } else if (num_held > hf_local_param[idx].btc_hf_cb.num_held) { + ag_res.audio_handle = hf_local_param.btc_hf_cb[idx].handle; + } else if (num_held > hf_local_param.btc_hf_cb[idx].num_held) { res = BTA_AG_IN_CALL_HELD_RES; } else { res = BTA_AG_CALL_CANCEL_RES; @@ -844,7 +827,7 @@ static bt_status_t btc_hf_phone_state_update(bt_bdaddr_t *bd_addr,int num_active case ESP_HF_CALL_SETUP_STATUS_OUTGOING_DIALING: case ESP_HF_CALL_SETUP_STATUS_OUTGOING_ALERTING: { - if (num_active > hf_local_param[idx].btc_hf_cb.num_active) { + if (num_active > hf_local_param.btc_hf_cb[idx].num_active) { res = BTA_AG_OUT_CALL_CONN_RES; ag_res.audio_handle = BTA_AG_HANDLE_SCO_NO_CHANGE; } else { @@ -887,7 +870,7 @@ static bt_status_t btc_hf_phone_state_update(bt_bdaddr_t *bd_addr,int num_active case ESP_HF_CALL_SETUP_STATUS_OUTGOING_DIALING: { if (!(num_active + num_held)) { - ag_res.audio_handle = hf_local_param[idx].btc_hf_cb.handle; + ag_res.audio_handle = hf_local_param.btc_hf_cb[idx].handle; } res = BTA_AG_OUT_CALL_ORIG_RES; break; @@ -895,9 +878,9 @@ static bt_status_t btc_hf_phone_state_update(bt_bdaddr_t *bd_addr,int num_active case ESP_HF_CALL_SETUP_STATUS_OUTGOING_ALERTING: { - if ((hf_local_param[idx].btc_hf_cb.call_setup_state == ESP_HF_CALL_SETUP_STATUS_IDLE) && + if ((hf_local_param.btc_hf_cb[idx].call_setup_state == ESP_HF_CALL_SETUP_STATUS_IDLE) && !(num_active + num_held)) { - ag_res.audio_handle = hf_local_param[idx].btc_hf_cb.handle; + ag_res.audio_handle = hf_local_param.btc_hf_cb[idx].handle; /* Force SCO setup here.*/ BTA_AgAudioOpen(ag_res.audio_handle); } @@ -927,34 +910,34 @@ static bt_status_t btc_hf_phone_state_update(bt_bdaddr_t *bd_addr,int num_active /* Handle call_state indicator change. */ if (!activeCallUpdated && - ((num_active + num_held) != (hf_local_param[idx].btc_hf_cb.num_active + hf_local_param[idx].btc_hf_cb.num_held))) { - BTC_TRACE_DEBUG("%s: Active call states changed. old: %d new: %d", __FUNCTION__, hf_local_param[idx].btc_hf_cb.num_active, num_active); + ((num_active + num_held) != (hf_local_param.btc_hf_cb[idx].num_active + hf_local_param.btc_hf_cb[idx].num_held))) { + BTC_TRACE_DEBUG("%s: Active call states changed. old: %d new: %d", __FUNCTION__, hf_local_param.btc_hf_cb[idx].num_active, num_active); send_indicator_update(BTA_AG_IND_CALL, ((num_active + num_held) > 0) ? 1 : 0); } /* Handle call_held_state indicator change. */ - if (num_held != hf_local_param[idx].btc_hf_cb.num_held || - ((num_active == 0) && ((num_held + hf_local_param[idx].btc_hf_cb.num_held) > 1))) { - BTC_TRACE_DEBUG("%s: Held call states changed. old: %d new: %d", __FUNCTION__, hf_local_param[idx].btc_hf_cb.num_held, num_held); + if (num_held != hf_local_param.btc_hf_cb[idx].num_held || + ((num_active == 0) && ((num_held + hf_local_param.btc_hf_cb[idx].num_held) > 1))) { + BTC_TRACE_DEBUG("%s: Held call states changed. old: %d new: %d", __FUNCTION__, hf_local_param.btc_hf_cb[idx].num_held, num_held); send_indicator_update(BTA_AG_IND_CALLHELD, ((num_held == 0) ? 0 : ((num_active == 0) ? 2 : 1))); } /* Handle Call Active/Held Swap indicator update.*/ - if ((call_setup_state == hf_local_param[idx].btc_hf_cb.call_setup_state) && + if ((call_setup_state == hf_local_param.btc_hf_cb[idx].call_setup_state) && (num_active) && (num_held) && - (num_active == hf_local_param[idx].btc_hf_cb.num_active) && - (num_held == hf_local_param[idx].btc_hf_cb.num_held)) { + (num_active == hf_local_param.btc_hf_cb[idx].num_active) && + (num_held == hf_local_param.btc_hf_cb[idx].num_held)) { BTC_TRACE_DEBUG("%s: Calls swapped", __FUNCTION__); send_indicator_update(BTA_AG_IND_CALLHELD, 1); } update_call_states: for (i = 0; i < btc_max_hf_clients; i++) { - hf_local_param[i].btc_hf_cb.num_active = num_active; - hf_local_param[i].btc_hf_cb.num_held = num_held; - hf_local_param[i].btc_hf_cb.call_state = call_state; - hf_local_param[i].btc_hf_cb.call_setup_state = call_setup_state; + hf_local_param.btc_hf_cb[i].num_active = num_active; + hf_local_param.btc_hf_cb[i].num_held = num_held; + hf_local_param.btc_hf_cb[i].call_state = call_state; + hf_local_param.btc_hf_cb[i].call_setup_state = call_setup_state; } return status; } @@ -967,7 +950,7 @@ bt_status_t btc_hf_ci_sco_data(void) CHECK_HF_SLC_CONNECTED(idx); if (idx != BTC_HF_INVALID_IDX) { - BTA_AgCiData(hf_local_param[idx].btc_hf_cb.handle); + BTA_AgCiData(hf_local_param.btc_hf_cb[idx].handle); return status; } status = BT_STATUS_FAIL; @@ -982,7 +965,7 @@ bool btc_hf_ag_audio_data_send(uint16_t sync_conn_hdl, uint8_t *p_buff_start, ui int idx = btc_hf_latest_connected_idx(); CHECK_HF_SLC_CONNECTED(idx); if (idx != BTC_HF_INVALID_IDX) { - BTA_AgAudioDataSend(hf_local_param[idx].btc_hf_cb.handle, p_buff_start, p_data, data_len); + BTA_AgAudioDataSend(hf_local_param.btc_hf_cb[idx].handle, p_buff_start, p_data, data_len); return true; } #endif @@ -1342,17 +1325,11 @@ void btc_hf_cb_handler(btc_msg_t *msg) break; case BTA_AG_DISABLE_EVT: { - idx = 0; -#if HFP_DYNAMIC_MEMORY == TRUE - if (hf_local_param) -#endif - { - if (hf_local_param[idx].btc_hf_cb.initialized) { - hf_local_param[idx].btc_hf_cb.initialized = false; - btc_hf_cb_release(); - param.prof_stat.state = ESP_HF_DEINIT_SUCCESS; - btc_hf_cb_to_app(ESP_HF_PROF_STATE_EVT, ¶m); - } + if (hf_local_param.initialized) { + hf_local_param.initialized = false; + btc_hf_cb_release(); + param.prof_stat.state = ESP_HF_DEINIT_SUCCESS; + btc_hf_cb_to_app(ESP_HF_PROF_STATE_EVT, ¶m); } break; } @@ -1360,14 +1337,14 @@ void btc_hf_cb_handler(btc_msg_t *msg) { idx = p_data->hdr.handle - 1; CHECK_HF_IDX(idx); - hf_local_param[idx].btc_hf_cb.handle = p_data->reg.hdr.handle; - BTC_TRACE_DEBUG("%s: BTA_AG_REGISTER_EVT," "hf_local_param[%d].btc_hf_cb.handle = %d", - __FUNCTION__, idx, hf_local_param[idx].btc_hf_cb.handle); - if (!hf_local_param[idx].btc_hf_cb.initialized) { + hf_local_param.btc_hf_cb[idx].handle = p_data->reg.hdr.handle; + BTC_TRACE_DEBUG("%s: BTA_AG_REGISTER_EVT," "hf_hf_cb[%d].btc_hf_cb.handle = %d", + __FUNCTION__, idx, hf_local_param.btc_hf_cb[idx].handle); + if (!hf_local_param.initialized) { param.prof_stat.state = ESP_HF_INIT_SUCCESS; btc_hf_cb_to_app(ESP_HF_PROF_STATE_EVT, ¶m); } - hf_local_param[idx].btc_hf_cb.initialized = true; + hf_local_param.initialized = true; break; } @@ -1377,30 +1354,30 @@ void btc_hf_cb_handler(btc_msg_t *msg) CHECK_HF_IDX(idx); if (p_data->open.hdr.status == BTA_AG_SUCCESS) { - bdcpy(hf_local_param[idx].btc_hf_cb.connected_bda.address, p_data->open.bd_addr); - hf_local_param[idx].btc_hf_cb.connection_state = ESP_HF_CONNECTION_STATE_CONNECTED; - hf_local_param[idx].btc_hf_cb.peer_feat = 0; - hf_local_param[idx].btc_hf_cb.chld_feat = 0; + bdcpy(hf_local_param.btc_hf_cb[idx].connected_bda.address, p_data->open.bd_addr); + hf_local_param.btc_hf_cb[idx].connection_state = ESP_HF_CONNECTION_STATE_CONNECTED; + hf_local_param.btc_hf_cb[idx].peer_feat = 0; + hf_local_param.btc_hf_cb[idx].chld_feat = 0; //clear_phone_state(); - } else if (hf_local_param[idx].btc_hf_cb.connection_state == ESP_HF_CONNECTION_STATE_CONNECTING) { - hf_local_param[idx].btc_hf_cb.connection_state = ESP_HF_CONNECTION_STATE_DISCONNECTED; + } else if (hf_local_param.btc_hf_cb[idx].connection_state == ESP_HF_CONNECTION_STATE_CONNECTING) { + hf_local_param.btc_hf_cb[idx].connection_state = ESP_HF_CONNECTION_STATE_DISCONNECTED; } else { BTC_TRACE_WARNING("%s: AG open failed, but another device connected. status=%d state=%d connected device=%s", __FUNCTION__, - p_data->open.hdr.status, hf_local_param[idx].btc_hf_cb.connection_state, - bdaddr_to_string(&hf_local_param[idx].btc_hf_cb.connected_bda, bdstr, sizeof(bdstr))); + p_data->open.hdr.status, hf_local_param.btc_hf_cb[idx].connection_state, + bdaddr_to_string(&hf_local_param.btc_hf_cb[idx].connected_bda, bdstr, sizeof(bdstr))); break; } do { - memcpy(param.conn_stat.remote_bda, &hf_local_param[idx].btc_hf_cb.connected_bda, sizeof(esp_bd_addr_t)); - param.conn_stat.state = hf_local_param[idx].btc_hf_cb.connection_state; + memcpy(param.conn_stat.remote_bda, &hf_local_param.btc_hf_cb[idx].connected_bda, sizeof(esp_bd_addr_t)); + param.conn_stat.state = hf_local_param.btc_hf_cb[idx].connection_state; param.conn_stat.peer_feat = 0; param.conn_stat.chld_feat = 0; btc_hf_cb_to_app(ESP_HF_CONNECTION_STATE_EVT, ¶m); } while (0); - if (hf_local_param[idx].btc_hf_cb.connection_state == ESP_HF_CONNECTION_STATE_DISCONNECTED) - bdsetany(hf_local_param[idx].btc_hf_cb.connected_bda.address); + if (hf_local_param.btc_hf_cb[idx].connection_state == ESP_HF_CONNECTION_STATE_DISCONNECTED) + bdsetany(hf_local_param.btc_hf_cb[idx].connected_bda.address); if (p_data->open.hdr.status != BTA_AG_SUCCESS) btc_queue_advance(); @@ -1411,20 +1388,20 @@ void btc_hf_cb_handler(btc_msg_t *msg) { idx = p_data->hdr.handle - 1; CHECK_HF_IDX(idx); - clock_gettime(CLOCK_MONOTONIC, &(hf_local_param[idx].btc_hf_cb.connected_timestamp)); + clock_gettime(CLOCK_MONOTONIC, &(hf_local_param.btc_hf_cb[idx].connected_timestamp)); BTC_TRACE_DEBUG("%s: BTA_AG_CONN_EVT, idx = %d ", __FUNCTION__, idx); - hf_local_param[idx].btc_hf_cb.peer_feat = p_data->conn.peer_feat; - hf_local_param[idx].btc_hf_cb.chld_feat = p_data->conn.chld_feat; - hf_local_param[idx].btc_hf_cb.connection_state = ESP_HF_CONNECTION_STATE_SLC_CONNECTED; + hf_local_param.btc_hf_cb[idx].peer_feat = p_data->conn.peer_feat; + hf_local_param.btc_hf_cb[idx].chld_feat = p_data->conn.chld_feat; + hf_local_param.btc_hf_cb[idx].connection_state = ESP_HF_CONNECTION_STATE_SLC_CONNECTED; do { - param.conn_stat.state = hf_local_param[idx].btc_hf_cb.connection_state; - param.conn_stat.peer_feat = hf_local_param[idx].btc_hf_cb.peer_feat; - param.conn_stat.chld_feat = hf_local_param[idx].btc_hf_cb.chld_feat; - memcpy(param.conn_stat.remote_bda, &hf_local_param[idx].btc_hf_cb.connected_bda, sizeof(esp_bd_addr_t)); + param.conn_stat.state = hf_local_param.btc_hf_cb[idx].connection_state; + param.conn_stat.peer_feat = hf_local_param.btc_hf_cb[idx].peer_feat; + param.conn_stat.chld_feat = hf_local_param.btc_hf_cb[idx].chld_feat; + memcpy(param.conn_stat.remote_bda, &hf_local_param.btc_hf_cb[idx].connected_bda, sizeof(esp_bd_addr_t)); btc_hf_cb_to_app(ESP_HF_CONNECTION_STATE_EVT, ¶m); } while(0); - hf_local_param[idx].hf_idx = btc_hf_latest_connected_idx(); + hf_local_param.hf_idx = btc_hf_latest_connected_idx(); btc_queue_advance(); break; } @@ -1433,20 +1410,20 @@ void btc_hf_cb_handler(btc_msg_t *msg) { idx = p_data->hdr.handle - 1; CHECK_HF_IDX(idx); - hf_local_param[idx].btc_hf_cb.connected_timestamp.tv_sec = 0; - hf_local_param[idx].btc_hf_cb.connection_state = ESP_HF_CONNECTION_STATE_DISCONNECTED; - BTC_TRACE_DEBUG("%s: BTA_AG_CLOSE_EVT," "hf_local_param[%d].btc_hf_cb.handle = %d", __FUNCTION__, - idx, hf_local_param[idx].btc_hf_cb.handle); + hf_local_param.btc_hf_cb[idx].connected_timestamp.tv_sec = 0; + hf_local_param.btc_hf_cb[idx].connection_state = ESP_HF_CONNECTION_STATE_DISCONNECTED; + BTC_TRACE_DEBUG("%s: BTA_AG_CLOSE_EVT," "hf_local_param.btc_hf_cb[%d].handle = %d", __FUNCTION__, + idx, hf_local_param.btc_hf_cb[idx].handle); do { param.conn_stat.state = ESP_HF_CONNECTION_STATE_DISCONNECTED; param.conn_stat.peer_feat = 0; param.conn_stat.chld_feat = 0; - memcpy(param.conn_stat.remote_bda, &hf_local_param[idx].btc_hf_cb.connected_bda, sizeof(esp_bd_addr_t)); + memcpy(param.conn_stat.remote_bda, &hf_local_param.btc_hf_cb[idx].connected_bda, sizeof(esp_bd_addr_t)); btc_hf_cb_to_app(ESP_HF_CONNECTION_STATE_EVT, ¶m); } while(0); - bdsetany(hf_local_param[idx].btc_hf_cb.connected_bda.address); + bdsetany(hf_local_param.btc_hf_cb[idx].connected_bda.address); clear_phone_state(); - hf_local_param[idx].hf_idx = btc_hf_latest_connected_idx(); + hf_local_param.hf_idx = btc_hf_latest_connected_idx(); btc_queue_advance(); break; } @@ -1457,8 +1434,8 @@ void btc_hf_cb_handler(btc_msg_t *msg) CHECK_HF_IDX(idx); do { param.audio_stat.state = ESP_HF_AUDIO_STATE_CONNECTED; - memcpy(param.audio_stat.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda,sizeof(esp_bd_addr_t)); - hf_local_param[idx].btc_hf_cb.sync_conn_hdl = p_data->hdr.sync_conn_handle; + memcpy(param.audio_stat.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t)); + hf_local_param.btc_hf_cb[idx].sync_conn_hdl = p_data->hdr.sync_conn_handle; param.audio_stat.sync_conn_handle = p_data->hdr.sync_conn_handle; param.audio_stat.preferred_frame_size = p_data->audio_stat.preferred_frame_size; btc_hf_cb_to_app(ESP_HF_AUDIO_STATE_EVT, ¶m); @@ -1472,8 +1449,8 @@ void btc_hf_cb_handler(btc_msg_t *msg) CHECK_HF_IDX(idx); do { param.audio_stat.state = ESP_HF_AUDIO_STATE_CONNECTED_MSBC; - memcpy(param.audio_stat.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda,sizeof(esp_bd_addr_t)); - hf_local_param[idx].btc_hf_cb.sync_conn_hdl = p_data->hdr.sync_conn_handle; + memcpy(param.audio_stat.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t)); + hf_local_param.btc_hf_cb[idx].sync_conn_hdl = p_data->hdr.sync_conn_handle; param.audio_stat.sync_conn_handle = p_data->hdr.sync_conn_handle; param.audio_stat.preferred_frame_size = p_data->audio_stat.preferred_frame_size; btc_hf_cb_to_app(ESP_HF_AUDIO_STATE_EVT, ¶m); @@ -1486,8 +1463,8 @@ void btc_hf_cb_handler(btc_msg_t *msg) CHECK_HF_IDX(idx); do { param.audio_stat.state = ESP_HF_AUDIO_STATE_DISCONNECTED; - hf_local_param[idx].btc_hf_cb.sync_conn_hdl = ESP_INVALID_CONN_HANDLE; - memcpy(param.audio_stat.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda, sizeof(esp_bd_addr_t)); + hf_local_param.btc_hf_cb[idx].sync_conn_hdl = ESP_INVALID_CONN_HANDLE; + memcpy(param.audio_stat.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda, sizeof(esp_bd_addr_t)); param.audio_stat.sync_conn_handle = p_data->hdr.sync_conn_handle; btc_hf_cb_to_app(ESP_HF_AUDIO_STATE_EVT, ¶m); } while(0); @@ -1500,12 +1477,12 @@ void btc_hf_cb_handler(btc_msg_t *msg) CHECK_HF_IDX(idx); do { param.vra_rep.value = p_data->val.num; - memcpy(param.vra_rep.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda,sizeof(esp_bd_addr_t)); + memcpy(param.vra_rep.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t)); btc_hf_cb_to_app(ESP_HF_BVRA_RESPONSE_EVT, ¶m); if (p_data->val.num) { - btc_hf_connect_audio(&hf_local_param[idx].btc_hf_cb.connected_bda); + btc_hf_connect_audio(&hf_local_param.btc_hf_cb[idx].connected_bda); } else { - btc_hf_disconnect_audio(&hf_local_param[idx].btc_hf_cb.connected_bda); + btc_hf_disconnect_audio(&hf_local_param.btc_hf_cb[idx].connected_bda); } } while (0); break; @@ -1517,7 +1494,7 @@ void btc_hf_cb_handler(btc_msg_t *msg) idx = p_data->hdr.handle - 1; CHECK_HF_IDX(idx); do { - memcpy(param.volume_control.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda,sizeof(esp_bd_addr_t)); + memcpy(param.volume_control.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t)); param.volume_control.type = (event == BTA_AG_SPK_EVT) ? ESP_HF_VOLUME_CONTROL_TARGET_SPK : ESP_HF_VOLUME_CONTROL_TARGET_MIC; param.volume_control.volume = p_data->val.num; btc_hf_cb_to_app(ESP_HF_VOLUME_CONTROL_EVT, ¶m); @@ -1530,7 +1507,7 @@ void btc_hf_cb_handler(btc_msg_t *msg) idx = p_data->hdr.handle - 1; CHECK_HF_IDX(idx); do { - memcpy(param.unat_rep.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda,sizeof(esp_bd_addr_t)); + memcpy(param.unat_rep.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t)); param.unat_rep.unat = p_data->val.str; btc_hf_cb_to_app(ESP_HF_UNAT_RESPONSE_EVT, ¶m); } while (0); @@ -1541,7 +1518,7 @@ void btc_hf_cb_handler(btc_msg_t *msg) { idx = p_data->hdr.handle - 1; CHECK_HF_IDX(idx); - memcpy(param.ind_upd.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda,sizeof(esp_bd_addr_t)); + memcpy(param.ind_upd.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t)); btc_hf_cb_to_app(ESP_HF_IND_UPDATE_EVT, ¶m); break; } @@ -1550,7 +1527,7 @@ void btc_hf_cb_handler(btc_msg_t *msg) { idx = p_data->hdr.handle - 1; CHECK_HF_IDX(idx); - memcpy(param.cind_rep.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda,sizeof(esp_bd_addr_t)); + memcpy(param.cind_rep.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t)); btc_hf_cb_to_app(ESP_HF_CIND_RESPONSE_EVT, ¶m); break; } @@ -1559,7 +1536,7 @@ void btc_hf_cb_handler(btc_msg_t *msg) { idx = p_data->hdr.handle - 1; CHECK_HF_IDX(idx); - memcpy(param.cops_rep.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda,sizeof(esp_bd_addr_t)); + memcpy(param.cops_rep.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t)); btc_hf_cb_to_app(ESP_HF_COPS_RESPONSE_EVT, ¶m); break; } @@ -1568,7 +1545,7 @@ void btc_hf_cb_handler(btc_msg_t *msg) { idx = p_data->hdr.handle - 1; CHECK_HF_IDX(idx); - memcpy(param.clcc_rep.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda,sizeof(esp_bd_addr_t)); + memcpy(param.clcc_rep.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t)); btc_hf_cb_to_app(ESP_HF_CLCC_RESPONSE_EVT, ¶m); break; } @@ -1577,7 +1554,7 @@ void btc_hf_cb_handler(btc_msg_t *msg) { idx = p_data->hdr.handle - 1; CHECK_HF_IDX(idx); - memcpy(param.cnum_rep.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda,sizeof(esp_bd_addr_t)); + memcpy(param.cnum_rep.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t)); btc_hf_cb_to_app(ESP_HF_CNUM_RESPONSE_EVT, ¶m); break; } @@ -1587,7 +1564,7 @@ void btc_hf_cb_handler(btc_msg_t *msg) idx = p_data->hdr.handle - 1; CHECK_HF_IDX(idx); do { - memcpy(param.vts_rep.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda,sizeof(esp_bd_addr_t)); + memcpy(param.vts_rep.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t)); param.vts_rep.code = p_data->val.str; btc_hf_cb_to_app(ESP_HF_VTS_RESPONSE_EVT, ¶m); } while(0); @@ -1599,7 +1576,7 @@ void btc_hf_cb_handler(btc_msg_t *msg) idx = p_data->hdr.handle - 1; CHECK_HF_IDX(idx); do { - memcpy(param.nrec.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda,sizeof(esp_bd_addr_t)); + memcpy(param.nrec.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t)); param.nrec.state = p_data->val.num; btc_hf_cb_to_app(ESP_HF_NREC_RESPONSE_EVT, ¶m); } while(0); @@ -1610,7 +1587,7 @@ void btc_hf_cb_handler(btc_msg_t *msg) { idx = p_data->hdr.handle - 1; CHECK_HF_IDX(idx); - memcpy(param.ata_rep.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda,sizeof(esp_bd_addr_t)); + memcpy(param.ata_rep.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t)); btc_hf_cb_to_app(ESP_HF_ATA_RESPONSE_EVT, ¶m); break; } @@ -1619,7 +1596,7 @@ void btc_hf_cb_handler(btc_msg_t *msg) { idx = p_data->hdr.handle - 1; CHECK_HF_IDX(idx); - memcpy(param.chup_rep.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda,sizeof(esp_bd_addr_t)); + memcpy(param.chup_rep.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t)); btc_hf_cb_to_app(ESP_HF_CHUP_RESPONSE_EVT, ¶m); break; } @@ -1631,14 +1608,14 @@ void btc_hf_cb_handler(btc_msg_t *msg) CHECK_HF_IDX(idx); do { if (event == BTA_AG_AT_D_EVT) { // dial_number_or_memory - memcpy(param.out_call.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda,sizeof(esp_bd_addr_t)); + memcpy(param.out_call.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t)); param.out_call.type = p_data->val.value; param.out_call.num_or_loc = osi_malloc((strlen(p_data->val.str) + 1) * sizeof(char)); sprintf(param.out_call.num_or_loc, "%s", p_data->val.str); btc_hf_cb_to_app(ESP_HF_DIAL_EVT, ¶m); osi_free(param.out_call.num_or_loc); } else if (event == BTA_AG_AT_BLDN_EVT) { //dial_last - memcpy(param.out_call.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda,sizeof(esp_bd_addr_t)); + memcpy(param.out_call.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t)); param.out_call.num_or_loc = NULL; btc_hf_cb_to_app(ESP_HF_DIAL_EVT, ¶m); } @@ -1655,7 +1632,7 @@ void btc_hf_cb_handler(btc_msg_t *msg) memset(&ag_res, 0, sizeof(ag_res)); ag_res.ok_flag = BTA_AG_OK_ERROR; ag_res.errcode = BTA_AG_ERR_OP_NOT_SUPPORTED; - BTA_AgResult(hf_local_param[idx].btc_hf_cb.handle, BTA_AG_UNAT_RES, &ag_res); + BTA_AgResult(hf_local_param.btc_hf_cb[idx].handle, BTA_AG_UNAT_RES, &ag_res); break; } @@ -1670,11 +1647,11 @@ void btc_hf_cb_handler(btc_msg_t *msg) ** of SCO connection establishment */ if ((btc_conf_hf_force_wbs == TRUE) && (p_data->val.num & BTA_AG_CODEC_MSBC)) { BTC_TRACE_DEBUG("%s btc_hf override-Preferred Codec to MSBC", __FUNCTION__); - BTA_AgSetCodec(hf_local_param[idx].btc_hf_cb.handle,BTA_AG_CODEC_MSBC); + BTA_AgSetCodec(hf_local_param.btc_hf_cb[idx].handle,BTA_AG_CODEC_MSBC); } else { BTC_TRACE_DEBUG("%s btc_hf override-Preferred Codec to CVSD", __FUNCTION__); - BTA_AgSetCodec(hf_local_param[idx].btc_hf_cb.handle,BTA_AG_CODEC_CVSD); + BTA_AgSetCodec(hf_local_param.btc_hf_cb[idx].handle,BTA_AG_CODEC_CVSD); } #endif break; @@ -1686,7 +1663,7 @@ void btc_hf_cb_handler(btc_msg_t *msg) CHECK_HF_IDX(idx); do { BTC_TRACE_DEBUG("Set codec status %d codec %d 1=CVSD 2=MSBC", p_data->val.hdr.status, p_data->val.num); - memcpy(param.wbs_rep.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda,sizeof(esp_bd_addr_t)); + memcpy(param.wbs_rep.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t)); param.wbs_rep.codec = p_data->val.num; btc_hf_cb_to_app(ESP_HF_WBS_RESPONSE_EVT, ¶m); } while (0); @@ -1699,7 +1676,7 @@ void btc_hf_cb_handler(btc_msg_t *msg) CHECK_HF_IDX(idx); do { BTC_TRACE_DEBUG("AG final seleded codec is %d 1=CVSD 2=MSBC", p_data->val.num); - memcpy(param.bcs_rep.remote_addr, &hf_local_param[idx].btc_hf_cb.connected_bda,sizeof(esp_bd_addr_t)); + memcpy(param.bcs_rep.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t)); param.bcs_rep.mode = p_data->val.num; /* No ESP_HF_WBS_NONE case, because HFP 1.6 supported device can send BCS */ btc_hf_cb_to_app(ESP_HF_BCS_RESPONSE_EVT, ¶m); @@ -1723,18 +1700,16 @@ void btc_hf_get_profile_status(esp_hf_profile_status_t *param) { param->hfp_ag_inited = false; // Not initialized by default -#if HFP_DYNAMIC_MEMORY == TRUE - if (hf_local_param) -#endif - { + if (hf_local_param.initialized) { + param->hfp_ag_inited = true; + } + + if (hf_local_param.btc_hf_cb != NULL) { for (int idx = 0; idx < BTC_HF_NUM_CB; idx++) { - if (hf_local_param[idx].btc_hf_cb.initialized) { - param->hfp_ag_inited = true; - if (hf_local_param[idx].btc_hf_cb.connection_state == ESP_HF_CONNECTION_STATE_SLC_CONNECTED) { - param->slc_conn_num++; - if (hf_local_param[idx].btc_hf_cb.sync_conn_hdl != ESP_INVALID_CONN_HANDLE) { - param->sync_conn_num++; - } + if (hf_local_param.btc_hf_cb[idx].connection_state == ESP_HF_CONNECTION_STATE_SLC_CONNECTED) { + param->slc_conn_num++; + if (hf_local_param.btc_hf_cb[idx].sync_conn_hdl != ESP_INVALID_CONN_HANDLE) { + param->sync_conn_num++; } } } diff --git a/components/bt/host/bluedroid/btc/profile/std/include/btc_hf_ag.h b/components/bt/host/bluedroid/btc/profile/std/include/btc_hf_ag.h index e2706193d0..763b631411 100644 --- a/components/bt/host/bluedroid/btc/profile/std/include/btc_hf_ag.h +++ b/components/bt/host/bluedroid/btc/profile/std/include/btc_hf_ag.h @@ -215,7 +215,6 @@ typedef union /* BTC-AG control block to map bdaddr to BTA handle */ typedef struct { - bool initialized; UINT16 handle; UINT16 sync_conn_hdl; bt_bdaddr_t connected_bda; @@ -233,9 +232,9 @@ typedef struct typedef struct { + bool initialized; int hf_idx; - UINT32 btc_hf_features; - btc_hf_cb_t btc_hf_cb; + btc_hf_cb_t *btc_hf_cb; esp_hf_incoming_data_cb_t btc_hf_incoming_data_cb; esp_hf_outgoing_data_cb_t btc_hf_outgoing_data_cb; esp_hf_ag_audio_data_cb_t btc_hf_audio_data_cb; @@ -243,7 +242,7 @@ typedef struct #if HFP_DYNAMIC_MEMORY == TRUE extern hf_local_param_t *hf_local_param_ptr; -#define hf_local_param (hf_local_param_ptr) +#define hf_local_param (*hf_local_param_ptr) #endif /*******************************************************************************