espressif/esp-idf
1
0
Fork 1
mirror of https://github.com/espressif/esp-idf.git synced 2025-07-30 18:57:19 +02:00
Code Issues Packages Projects Releases Wiki Activity

fix(bt): Fixed HFP AG data callback cleared after profile is re-initialized

Browse Source
This commit is contained in:
Wang Mengyang
2025-06-11 14:12:16 +08:00
parent d38621e95a
commit 0190ba0390
3 changed files with 189 additions and 215 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
components/bt/common/btc/core/btc_task.c
View File

@ -490,10 +490,10 @@ static bt_status_t btc_init_mem(void) {
#endif #endif
#if BTC_HF_INCLUDED == TRUE && HFP_DYNAMIC_MEMORY == TRUE #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; 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 #endif
#if BTC_HF_CLIENT_INCLUDED == TRUE && HFP_DYNAMIC_MEMORY == TRUE #if BTC_HF_CLIENT_INCLUDED == TRUE && HFP_DYNAMIC_MEMORY == TRUE

393
components/bt/host/bluedroid/btc/profile/std/hf_ag/btc_hf_ag.c
View File

@ -66,7 +66,7 @@
static UINT16 btc_max_hf_clients = BTC_HF_NUM_CB; static UINT16 btc_max_hf_clients = BTC_HF_NUM_CB;
/* HF Param Definition */ /* HF Param Definition */
#if HFP_DYNAMIC_MEMORY == FALSE #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 #else
hf_local_param_t *hf_local_param_ptr = NULL; hf_local_param_t *hf_local_param_ptr = NULL;
#endif #endif
@ -117,7 +117,7 @@ do {
if ((idx < 0) || (idx >= BTC_HF_NUM_CB)) { \ if ((idx < 0) || (idx >= BTC_HF_NUM_CB)) { \
return BT_STATUS_FAIL; \ 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__); \ BTIF_TRACE_WARNING("CHECK_HF_INIT: %s: HF AG not initialized", __FUNCTION__); \
return BT_STATUS_NOT_READY; \ return BT_STATUS_NOT_READY; \
} else { \ } else { \
@ -130,8 +130,8 @@ do {
if ((idx < 0) || (idx >= BTC_HF_NUM_CB)) { \ if ((idx < 0) || (idx >= BTC_HF_NUM_CB)) { \
return BT_STATUS_FAIL; \ return BT_STATUS_FAIL; \
} \ } \
if (!hf_local_param[idx].btc_hf_cb.initialized || \ if (!hf_local_param.initialized || \
hf_local_param[idx].btc_hf_cb.connection_state != ESP_HF_CONNECTION_STATE_SLC_CONNECTED) { \ 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__); \ BTIF_TRACE_WARNING("CHECK_HF_SLC_CONNECTED: %s: HF AG SLC not connected", __FUNCTION__); \
return BT_STATUS_NOT_READY; \ return BT_STATUS_NOT_READY; \
} else { \ } else { \
@ -141,10 +141,10 @@ do {
#define clear_phone_state() \ #define clear_phone_state() \
hf_local_param[idx].btc_hf_cb.call_state = ESP_HF_CALL_STATUS_NO_CALLS; \ hf_local_param.btc_hf_cb[idx].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.btc_hf_cb[idx].call_setup_state = ESP_HF_CALL_SETUP_STATUS_IDLE;\
hf_local_param[idx].btc_hf_cb.num_active = 0; \ hf_local_param.btc_hf_cb[idx].num_active = 0; \
hf_local_param[idx].btc_hf_cb.num_held = 0; hf_local_param.btc_hf_cb[idx].num_held = 0;
#define CHECK_HF_IDX(idx) \ #define CHECK_HF_IDX(idx) \
do { \ do { \
@ -160,7 +160,7 @@ do {
static int btc_hf_idx_by_bdaddr(bt_bdaddr_t *bd_addr) static int btc_hf_idx_by_bdaddr(bt_bdaddr_t *bd_addr)
{ {
for (int i = 0; i < btc_max_hf_clients; ++i) { 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; 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) static int btc_hf_find_free_idx(void)
{ {
for (int idx = 0; idx < btc_max_hf_clients; ++idx) { for (int idx = 0; idx < btc_max_hf_clients; ++idx) {
if (hf_local_param[idx].btc_hf_cb.initialized && if (hf_local_param.initialized &&
hf_local_param[idx].btc_hf_cb.connection_state == ESP_HF_CONNECTION_STATE_DISCONNECTED) { hf_local_param.btc_hf_cb[idx].connection_state == ESP_HF_CONNECTION_STATE_DISCONNECTED) {
return idx; 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) 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) && if ((bdcmp(bd_addr->address,hf_local_param.btc_hf_cb[idx].connected_bda.address) == 0) &&
((hf_local_param[idx].btc_hf_cb.connection_state == ESP_HF_CONNECTION_STATE_CONNECTED) || ((hf_local_param.btc_hf_cb[idx].connection_state == ESP_HF_CONNECTION_STATE_CONNECTED) ||
(hf_local_param[idx].btc_hf_cb.connection_state == ESP_HF_CONNECTION_STATE_SLC_CONNECTED))) { (hf_local_param.btc_hf_cb[idx].connection_state == ESP_HF_CONNECTION_STATE_SLC_CONNECTED))) {
return TRUE; return TRUE;
} }
return FALSE; return FALSE;
@ -196,9 +196,9 @@ static int btc_hf_latest_connected_idx(void)
conn_time_delta.tv_sec = now.tv_sec; conn_time_delta.tv_sec = now.tv_sec;
for (int i = 0; i < btc_max_hf_clients; i++) { 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 (hf_local_param.btc_hf_cb[i].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) { 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[i].btc_hf_cb.connected_timestamp.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; 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) 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.btc_hf_incoming_data_cb = recv;
hf_local_param[0].btc_hf_outgoing_data_cb = send; hf_local_param.btc_hf_outgoing_data_cb = send;
} }
void btc_hf_reg_audio_data_cb(esp_hf_ag_audio_data_cb_t callback) 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) 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 */ /* 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; esp_hf_audio_buff_t *audio_buff = (esp_hf_audio_buff_t *)buf;
audio_buff->buff_size = len; audio_buff->buff_size = len;
audio_buff->data_len = len; audio_buff->data_len = len;
audio_buff->data = data; 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 { else {
osi_free(buf); 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) void btc_hf_incoming_data_cb_to_app(const uint8_t *data, uint32_t len)
{ {
int idx = 0;
// todo: critical section protection // todo: critical section protection
if (hf_local_param[idx].btc_hf_incoming_data_cb) { if (hf_local_param.btc_hf_incoming_data_cb) {
hf_local_param[idx].btc_hf_incoming_data_cb(data, len); 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) uint32_t btc_hf_outgoing_data_cb_to_app(uint8_t *data, uint32_t len)
{ {
int idx = 0;
// todo: critical section protection // todo: critical section protection
if (hf_local_param[idx].btc_hf_outgoing_data_cb) { if (hf_local_param.btc_hf_outgoing_data_cb) {
return hf_local_param[idx].btc_hf_outgoing_data_cb(data, len); return hf_local_param.btc_hf_outgoing_data_cb(data, len);
} else { } else {
return 0; return 0;
} }
@ -321,7 +319,7 @@ bt_status_t btc_hf_execute_service(BOOLEAN b_enable)
} else { } else {
/* De-register AG */ /* De-register AG */
for (idx = 0; idx < btc_max_hf_clients; idx++) { 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 */ /* Disable AG */
BTA_AgDisable(); BTA_AgDisable();
@ -339,30 +337,29 @@ bt_status_t btc_hf_init(void)
{ {
int idx = 0; int idx = 0;
#if HFP_DYNAMIC_MEMORY == TRUE if (hf_local_param.initialized) {
if (hf_local_param) esp_hf_cb_param_t param = {
#endif .prof_stat.state = ESP_HF_INIT_ALREADY,
{ };
if (hf_local_param[idx].btc_hf_cb.initialized) { btc_hf_cb_to_app(ESP_HF_PROF_STATE_EVT, &param);
esp_hf_cb_param_t param = { return BT_STATUS_SUCCESS;
.prof_stat.state = ESP_HF_INIT_ALREADY,
};
btc_hf_cb_to_app(ESP_HF_PROF_STATE_EVT, &param);
return BT_STATUS_SUCCESS;
}
} }
BTC_TRACE_DEBUG("%s - max_hf_clients=%d", __func__, btc_max_hf_clients); BTC_TRACE_DEBUG("%s - max_hf_clients=%d", __func__, btc_max_hf_clients);
#if HFP_DYNAMIC_MEMORY == TRUE if (hf_local_param.btc_hf_cb == NULL) {
if (hf_local_param == 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 = (hf_local_param_t *)osi_malloc(BTC_HF_NUM_CB * sizeof(hf_local_param_t))) == NULL) { if (hf_local_param.btc_hf_cb == NULL) {
BTC_TRACE_ERROR("%s malloc failed!", __func__); BTC_TRACE_ERROR("%s malloc failed!", __func__);
return BT_STATUS_NOMEM; 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 /* 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) * 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); btc_dm_enable_service(BTA_HSP_SERVICE_ID);
#endif #endif
clear_phone_state(); 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 // set audio path
#if (BT_CONTROLLER_INCLUDED == TRUE) #if (BT_CONTROLLER_INCLUDED == TRUE)
#if BTM_SCO_HCI_INCLUDED #if BTM_SCO_HCI_INCLUDED
@ -394,19 +388,12 @@ void btc_hf_deinit(void)
{ {
BTC_TRACE_EVENT("%s", __FUNCTION__); BTC_TRACE_EVENT("%s", __FUNCTION__);
int idx = 0; if (!hf_local_param.initialized) {
esp_hf_cb_param_t param = {
#if HFP_DYNAMIC_MEMORY == TRUE .prof_stat.state = ESP_HF_DEINIT_ALREADY,
if (hf_local_param) };
#endif btc_hf_cb_to_app(ESP_HF_PROF_STATE_EVT, &param);
{ return;
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, &param);
return;
}
} }
btc_dm_disable_service(BTA_HFP_SERVICE_ID); btc_dm_disable_service(BTA_HFP_SERVICE_ID);
@ -414,12 +401,8 @@ void btc_hf_deinit(void)
static void btc_hf_cb_release(void) static void btc_hf_cb_release(void)
{ {
#if HFP_DYNAMIC_MEMORY == TRUE osi_free(hf_local_param.btc_hf_cb);
if (hf_local_param) { hf_local_param.btc_hf_cb = NULL;
osi_free(hf_local_param);
hf_local_param = NULL;
}
#endif
} }
static bt_status_t connect_init(bt_bdaddr_t *bd_addr, uint16_t uuid) 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)) { if (!is_connected(idx, bd_addr)) {
hf_local_param[idx].btc_hf_cb.connection_state = ESP_HF_CONNECTION_STATE_CONNECTING; hf_local_param.btc_hf_cb[idx].connection_state = ESP_HF_CONNECTION_STATE_CONNECTING;
bdcpy(hf_local_param[idx].btc_hf_cb.connected_bda.address, bd_addr->address); bdcpy(hf_local_param.btc_hf_cb[idx].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); 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_SUCCESS;
} }
return BT_STATUS_BUSY; 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)) { 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_SUCCESS;
} }
return BT_STATUS_FAIL; 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); CHECK_HF_SLC_CONNECTED(idx);
if (is_connected(idx, bd_addr)) { 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 */ /* Inform the application that the audio connection has been initiated successfully */
do { do {
esp_hf_cb_param_t param; esp_hf_cb_param_t param;
memset(&param, 0, sizeof(esp_hf_cb_param_t)); memset(&param, 0, sizeof(esp_hf_cb_param_t));
param.audio_stat.state = ESP_HF_AUDIO_STATE_CONNECTING; 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, &param); btc_hf_cb_to_app(ESP_HF_AUDIO_STATE_EVT, &param);
} while (0); } while (0);
return BT_STATUS_SUCCESS; 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); CHECK_HF_SLC_CONNECTED(idx);
if (is_connected(idx, bd_addr)) { 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_SUCCESS;
} }
return BT_STATUS_FAIL; 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); CHECK_HF_SLC_CONNECTED(idx);
if (idx != BTC_HF_INVALID_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; status = BT_STATUS_SUCCESS;
} }
#endif /*#if (BTM_SCO_HCI_INCLUDED == TRUE) */ #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); CHECK_HF_SLC_CONNECTED(idx);
if (is_connected(idx, bd_addr)) { 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; tBTA_AG_RES_DATA ag_res;
memset(&ag_res, 0, sizeof(ag_res)); memset(&ag_res, 0, sizeof(ag_res));
ag_res.state = value; 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; return BT_STATUS_SUCCESS;
} else { } else {
return BT_STATUS_UNSUPPORTED; 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)) { if (is_connected(idx, bd_addr)) {
ag_res.num = volume; 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_SUCCESS;
} }
return BT_STATUS_FAIL; 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; 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_SUCCESS;
} }
return BT_STATUS_FAIL; 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.ok_flag = BTA_AG_OK_ERROR;
ag_res.errcode = error_code; 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_SUCCESS;
} }
return BT_STATUS_FAIL; 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 */ batt_lev, /* Battery level */
call_held_status /* Callheld state */ 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_SUCCESS;
} }
return BT_STATUS_FAIL; 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 */ /* Format the response */
sprintf(ag_res.str, "0,0,\"%s\"", name); sprintf(ag_res.str, "0,0,\"%s\"", name);
ag_res.ok_flag = BTA_AG_OK_DONE; 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_SUCCESS;
} }
return BT_STATUS_FAIL; 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_SUCCESS;
} }
return BT_STATUS_FAIL; 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); sprintf(ag_res.str, ",\"%s\",%d,,",number, number_type);
} }
ag_res.ok_flag = BTA_AG_OK_DONE; 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_SUCCESS;
} }
return BT_STATUS_FAIL; 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; tBTA_AG_RES_DATA ag_res;
memset (&ag_res, 0, sizeof (ag_res)); memset (&ag_res, 0, sizeof (ag_res));
ag_res.state = state; 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_SUCCESS;
} }
return BT_STATUS_FAIL; 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; 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 */ /* 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) { if (hf_local_param.hf_idx != BTC_HF_INVALID_IDX) {
idx = hf_local_param->hf_idx; idx = hf_local_param.hf_idx;
} else { } else {
idx = btc_hf_latest_connected_idx(); 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); BTC_TRACE_DEBUG("phone_state_change: idx = %d", idx);
CHECK_HF_SLC_CONNECTED(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]", 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_active, hf_local_param.btc_hf_cb[idx].num_active,
num_held, hf_local_param[idx].btc_hf_cb.num_held, num_held, hf_local_param.btc_hf_cb[idx].num_held,
dump_hf_call_state(call_state), dump_hf_call_state(hf_local_param[idx].btc_hf_cb.call_state), 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[idx].btc_hf_cb.call_setup_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 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) { 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__); 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 */ /* 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) || if ((hf_local_param.btc_hf_cb[idx].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.btc_hf_cb[idx].call_setup_state != ESP_HF_CALL_SETUP_STATUS_IDLE) ||
(hf_local_param[idx].btc_hf_cb.num_active) || (hf_local_param.btc_hf_cb[idx].num_active) ||
(hf_local_param[idx].btc_hf_cb.num_held)) { (hf_local_param.btc_hf_cb[idx].num_held)) {
BTC_TRACE_DEBUG("%s: Record call termination timestamp", __FUNCTION__); 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); 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 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); send_indicator_update(BTA_AG_IND_CALLHELD, 0);
} }
goto update_call_states; 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.*/ /* Handle case(3) here prior to call setup handling.*/
if (((num_active + num_held) > 0) && if (((num_active + num_held) > 0) &&
(hf_local_param[idx].btc_hf_cb.num_active == 0) && (hf_local_param.btc_hf_cb[idx].num_active == 0) &&
(hf_local_param[idx].btc_hf_cb.num_held == 0) && (hf_local_param.btc_hf_cb[idx].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].call_setup_state == ESP_HF_CALL_SETUP_STATUS_IDLE)) {
BTC_TRACE_DEBUG("%s: Active/Held call notification received without call setup update", __FUNCTION__); BTC_TRACE_DEBUG("%s: Active/Held call notification received without call setup update", __FUNCTION__);
memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA)); 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. */ /* Addition callsetup with the Active call. */
if (call_setup_state != ESP_HF_CALL_SETUP_STATUS_IDLE) { 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. */ /* 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__, 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)); dump_hf_call_setup_state(call_setup_state));
memset(&ag_res, 0, sizeof(tBTA_AG_RES_DATA)); 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: 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: 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; res = BTA_AG_IN_CALL_CONN_RES;
ag_res.audio_handle = hf_local_param[idx].btc_hf_cb.handle; ag_res.audio_handle = hf_local_param.btc_hf_cb[idx].handle;
} else if (num_held > hf_local_param[idx].btc_hf_cb.num_held) { } else if (num_held > hf_local_param.btc_hf_cb[idx].num_held) {
res = BTA_AG_IN_CALL_HELD_RES; res = BTA_AG_IN_CALL_HELD_RES;
} else { } else {
res = BTA_AG_CALL_CANCEL_RES; 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_DIALING:
case ESP_HF_CALL_SETUP_STATUS_OUTGOING_ALERTING: 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; res = BTA_AG_OUT_CALL_CONN_RES;
ag_res.audio_handle = BTA_AG_HANDLE_SCO_NO_CHANGE; ag_res.audio_handle = BTA_AG_HANDLE_SCO_NO_CHANGE;
} else { } 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: case ESP_HF_CALL_SETUP_STATUS_OUTGOING_DIALING:
{ {
if (!(num_active + num_held)) { 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; res = BTA_AG_OUT_CALL_ORIG_RES;
break; 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: 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)) { !(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.*/ /* Force SCO setup here.*/
BTA_AgAudioOpen(ag_res.audio_handle); 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. */ /* Handle call_state indicator change. */
if (!activeCallUpdated && if (!activeCallUpdated &&
((num_active + num_held) != (hf_local_param[idx].btc_hf_cb.num_active + hf_local_param[idx].btc_hf_cb.num_held))) { ((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[idx].btc_hf_cb.num_active, num_active); 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); send_indicator_update(BTA_AG_IND_CALL, ((num_active + num_held) > 0) ? 1 : 0);
} }
/* Handle call_held_state indicator change. */ /* Handle call_held_state indicator change. */
if (num_held != hf_local_param[idx].btc_hf_cb.num_held || if (num_held != hf_local_param.btc_hf_cb[idx].num_held ||
((num_active == 0) && ((num_held + hf_local_param[idx].btc_hf_cb.num_held) > 1))) { ((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[idx].btc_hf_cb.num_held, num_held); 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))); send_indicator_update(BTA_AG_IND_CALLHELD, ((num_held == 0) ? 0 : ((num_active == 0) ? 2 : 1)));
} }
/* Handle Call Active/Held Swap indicator update.*/ /* 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_active) &&
(num_held) && (num_held) &&
(num_active == hf_local_param[idx].btc_hf_cb.num_active) && (num_active == hf_local_param.btc_hf_cb[idx].num_active) &&
(num_held == hf_local_param[idx].btc_hf_cb.num_held)) { (num_held == hf_local_param.btc_hf_cb[idx].num_held)) {
BTC_TRACE_DEBUG("%s: Calls swapped", __FUNCTION__); BTC_TRACE_DEBUG("%s: Calls swapped", __FUNCTION__);
send_indicator_update(BTA_AG_IND_CALLHELD, 1); send_indicator_update(BTA_AG_IND_CALLHELD, 1);
} }
update_call_states: update_call_states:
for (i = 0; i < btc_max_hf_clients; i++) { for (i = 0; i < btc_max_hf_clients; i++) {
hf_local_param[i].btc_hf_cb.num_active = num_active; hf_local_param.btc_hf_cb[i].num_active = num_active;
hf_local_param[i].btc_hf_cb.num_held = num_held; hf_local_param.btc_hf_cb[i].num_held = num_held;
hf_local_param[i].btc_hf_cb.call_state = call_state; hf_local_param.btc_hf_cb[i].call_state = call_state;
hf_local_param[i].btc_hf_cb.call_setup_state = call_setup_state; hf_local_param.btc_hf_cb[i].call_setup_state = call_setup_state;
} }
return status; return status;
} }
@ -967,7 +950,7 @@ bt_status_t btc_hf_ci_sco_data(void)
CHECK_HF_SLC_CONNECTED(idx); CHECK_HF_SLC_CONNECTED(idx);
if (idx != BTC_HF_INVALID_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; return status;
} }
status = BT_STATUS_FAIL; 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(); int idx = btc_hf_latest_connected_idx();
CHECK_HF_SLC_CONNECTED(idx); CHECK_HF_SLC_CONNECTED(idx);
if (idx != BTC_HF_INVALID_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; return true;
} }
#endif #endif
@ -1342,17 +1325,11 @@ void btc_hf_cb_handler(btc_msg_t *msg)
break; break;
case BTA_AG_DISABLE_EVT: case BTA_AG_DISABLE_EVT:
{ {
idx = 0; if (hf_local_param.initialized) {
#if HFP_DYNAMIC_MEMORY == TRUE hf_local_param.initialized = false;
if (hf_local_param) btc_hf_cb_release();
#endif param.prof_stat.state = ESP_HF_DEINIT_SUCCESS;
{ btc_hf_cb_to_app(ESP_HF_PROF_STATE_EVT, &param);
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, &param);
}
} }
break; break;
} }
@ -1360,14 +1337,14 @@ void btc_hf_cb_handler(btc_msg_t *msg)
{ {
idx = p_data->hdr.handle - 1; idx = p_data->hdr.handle - 1;
CHECK_HF_IDX(idx); CHECK_HF_IDX(idx);
hf_local_param[idx].btc_hf_cb.handle = p_data->reg.hdr.handle; hf_local_param.btc_hf_cb[idx].handle = p_data->reg.hdr.handle;
BTC_TRACE_DEBUG("%s: BTA_AG_REGISTER_EVT," "hf_local_param[%d].btc_hf_cb.handle = %d", BTC_TRACE_DEBUG("%s: BTA_AG_REGISTER_EVT," "hf_hf_cb[%d].btc_hf_cb.handle = %d",
__FUNCTION__, idx, hf_local_param[idx].btc_hf_cb.handle); __FUNCTION__, idx, hf_local_param.btc_hf_cb[idx].handle);
if (!hf_local_param[idx].btc_hf_cb.initialized) { if (!hf_local_param.initialized) {
param.prof_stat.state = ESP_HF_INIT_SUCCESS; param.prof_stat.state = ESP_HF_INIT_SUCCESS;
btc_hf_cb_to_app(ESP_HF_PROF_STATE_EVT, &param); btc_hf_cb_to_app(ESP_HF_PROF_STATE_EVT, &param);
} }
hf_local_param[idx].btc_hf_cb.initialized = true; hf_local_param.initialized = true;
break; break;
} }
@ -1377,30 +1354,30 @@ void btc_hf_cb_handler(btc_msg_t *msg)
CHECK_HF_IDX(idx); CHECK_HF_IDX(idx);
if (p_data->open.hdr.status == BTA_AG_SUCCESS) 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); bdcpy(hf_local_param.btc_hf_cb[idx].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.btc_hf_cb[idx].connection_state = ESP_HF_CONNECTION_STATE_CONNECTED;
hf_local_param[idx].btc_hf_cb.peer_feat = 0; hf_local_param.btc_hf_cb[idx].peer_feat = 0;
hf_local_param[idx].btc_hf_cb.chld_feat = 0; hf_local_param.btc_hf_cb[idx].chld_feat = 0;
//clear_phone_state(); //clear_phone_state();
} else if (hf_local_param[idx].btc_hf_cb.connection_state == ESP_HF_CONNECTION_STATE_CONNECTING) { } else if (hf_local_param.btc_hf_cb[idx].connection_state == ESP_HF_CONNECTION_STATE_CONNECTING) {
hf_local_param[idx].btc_hf_cb.connection_state = ESP_HF_CONNECTION_STATE_DISCONNECTED; hf_local_param.btc_hf_cb[idx].connection_state = ESP_HF_CONNECTION_STATE_DISCONNECTED;
} else { } else {
BTC_TRACE_WARNING("%s: AG open failed, but another device connected. status=%d state=%d connected device=%s", __FUNCTION__, 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, p_data->open.hdr.status, hf_local_param.btc_hf_cb[idx].connection_state,
bdaddr_to_string(&hf_local_param[idx].btc_hf_cb.connected_bda, bdstr, sizeof(bdstr))); bdaddr_to_string(&hf_local_param.btc_hf_cb[idx].connected_bda, bdstr, sizeof(bdstr)));
break; break;
} }
do { do {
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));
param.conn_stat.state = hf_local_param[idx].btc_hf_cb.connection_state; param.conn_stat.state = hf_local_param.btc_hf_cb[idx].connection_state;
param.conn_stat.peer_feat = 0; param.conn_stat.peer_feat = 0;
param.conn_stat.chld_feat = 0; param.conn_stat.chld_feat = 0;
btc_hf_cb_to_app(ESP_HF_CONNECTION_STATE_EVT, &param); btc_hf_cb_to_app(ESP_HF_CONNECTION_STATE_EVT, &param);
} while (0); } while (0);
if (hf_local_param[idx].btc_hf_cb.connection_state == ESP_HF_CONNECTION_STATE_DISCONNECTED) if (hf_local_param.btc_hf_cb[idx].connection_state == ESP_HF_CONNECTION_STATE_DISCONNECTED)
bdsetany(hf_local_param[idx].btc_hf_cb.connected_bda.address); bdsetany(hf_local_param.btc_hf_cb[idx].connected_bda.address);
if (p_data->open.hdr.status != BTA_AG_SUCCESS) if (p_data->open.hdr.status != BTA_AG_SUCCESS)
btc_queue_advance(); btc_queue_advance();
@ -1411,20 +1388,20 @@ void btc_hf_cb_handler(btc_msg_t *msg)
{ {
idx = p_data->hdr.handle - 1; idx = p_data->hdr.handle - 1;
CHECK_HF_IDX(idx); 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); 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.btc_hf_cb[idx].peer_feat = p_data->conn.peer_feat;
hf_local_param[idx].btc_hf_cb.chld_feat = p_data->conn.chld_feat; hf_local_param.btc_hf_cb[idx].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].connection_state = ESP_HF_CONNECTION_STATE_SLC_CONNECTED;
do { do {
param.conn_stat.state = hf_local_param[idx].btc_hf_cb.connection_state; param.conn_stat.state = hf_local_param.btc_hf_cb[idx].connection_state;
param.conn_stat.peer_feat = hf_local_param[idx].btc_hf_cb.peer_feat; param.conn_stat.peer_feat = hf_local_param.btc_hf_cb[idx].peer_feat;
param.conn_stat.chld_feat = hf_local_param[idx].btc_hf_cb.chld_feat; param.conn_stat.chld_feat = hf_local_param.btc_hf_cb[idx].chld_feat;
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, &param); btc_hf_cb_to_app(ESP_HF_CONNECTION_STATE_EVT, &param);
} while(0); } 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(); btc_queue_advance();
break; break;
} }
@ -1433,20 +1410,20 @@ void btc_hf_cb_handler(btc_msg_t *msg)
{ {
idx = p_data->hdr.handle - 1; idx = p_data->hdr.handle - 1;
CHECK_HF_IDX(idx); CHECK_HF_IDX(idx);
hf_local_param[idx].btc_hf_cb.connected_timestamp.tv_sec = 0; hf_local_param.btc_hf_cb[idx].connected_timestamp.tv_sec = 0;
hf_local_param[idx].btc_hf_cb.connection_state = ESP_HF_CONNECTION_STATE_DISCONNECTED; 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[%d].btc_hf_cb.handle = %d", __FUNCTION__, BTC_TRACE_DEBUG("%s: BTA_AG_CLOSE_EVT," "hf_local_param.btc_hf_cb[%d].handle = %d", __FUNCTION__,
idx, hf_local_param[idx].btc_hf_cb.handle); idx, hf_local_param.btc_hf_cb[idx].handle);
do { do {
param.conn_stat.state = ESP_HF_CONNECTION_STATE_DISCONNECTED; param.conn_stat.state = ESP_HF_CONNECTION_STATE_DISCONNECTED;
param.conn_stat.peer_feat = 0; param.conn_stat.peer_feat = 0;
param.conn_stat.chld_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, &param); btc_hf_cb_to_app(ESP_HF_CONNECTION_STATE_EVT, &param);
} while(0); } 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(); 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(); btc_queue_advance();
break; break;
} }
@ -1457,8 +1434,8 @@ void btc_hf_cb_handler(btc_msg_t *msg)
CHECK_HF_IDX(idx); CHECK_HF_IDX(idx);
do { do {
param.audio_stat.state = ESP_HF_AUDIO_STATE_CONNECTED; 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)); memcpy(param.audio_stat.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t));
hf_local_param[idx].btc_hf_cb.sync_conn_hdl = p_data->hdr.sync_conn_handle; 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.sync_conn_handle = p_data->hdr.sync_conn_handle;
param.audio_stat.preferred_frame_size = p_data->audio_stat.preferred_frame_size; param.audio_stat.preferred_frame_size = p_data->audio_stat.preferred_frame_size;
btc_hf_cb_to_app(ESP_HF_AUDIO_STATE_EVT, &param); btc_hf_cb_to_app(ESP_HF_AUDIO_STATE_EVT, &param);
@ -1472,8 +1449,8 @@ void btc_hf_cb_handler(btc_msg_t *msg)
CHECK_HF_IDX(idx); CHECK_HF_IDX(idx);
do { do {
param.audio_stat.state = ESP_HF_AUDIO_STATE_CONNECTED_MSBC; 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)); memcpy(param.audio_stat.remote_addr, &hf_local_param.btc_hf_cb[idx].connected_bda,sizeof(esp_bd_addr_t));
hf_local_param[idx].btc_hf_cb.sync_conn_hdl = p_data->hdr.sync_conn_handle; 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.sync_conn_handle = p_data->hdr.sync_conn_handle;
param.audio_stat.preferred_frame_size = p_data->audio_stat.preferred_frame_size; param.audio_stat.preferred_frame_size = p_data->audio_stat.preferred_frame_size;
btc_hf_cb_to_app(ESP_HF_AUDIO_STATE_EVT, &param); btc_hf_cb_to_app(ESP_HF_AUDIO_STATE_EVT, &param);
@ -1486,8 +1463,8 @@ void btc_hf_cb_handler(btc_msg_t *msg)
CHECK_HF_IDX(idx); CHECK_HF_IDX(idx);
do { do {
param.audio_stat.state = ESP_HF_AUDIO_STATE_DISCONNECTED; param.audio_stat.state = ESP_HF_AUDIO_STATE_DISCONNECTED;
hf_local_param[idx].btc_hf_cb.sync_conn_hdl = ESP_INVALID_CONN_HANDLE; hf_local_param.btc_hf_cb[idx].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)); 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; param.audio_stat.sync_conn_handle = p_data->hdr.sync_conn_handle;
btc_hf_cb_to_app(ESP_HF_AUDIO_STATE_EVT, &param); btc_hf_cb_to_app(ESP_HF_AUDIO_STATE_EVT, &param);
} while(0); } while(0);
@ -1500,12 +1477,12 @@ void btc_hf_cb_handler(btc_msg_t *msg)
CHECK_HF_IDX(idx); CHECK_HF_IDX(idx);
do { do {
param.vra_rep.value = p_data->val.num; 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, &param); btc_hf_cb_to_app(ESP_HF_BVRA_RESPONSE_EVT, &param);
if (p_data->val.num) { 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 { } 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); } while (0);
break; break;
@ -1517,7 +1494,7 @@ void btc_hf_cb_handler(btc_msg_t *msg)
idx = p_data->hdr.handle - 1; idx = p_data->hdr.handle - 1;
CHECK_HF_IDX(idx); CHECK_HF_IDX(idx);
do { 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.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; param.volume_control.volume = p_data->val.num;
btc_hf_cb_to_app(ESP_HF_VOLUME_CONTROL_EVT, &param); btc_hf_cb_to_app(ESP_HF_VOLUME_CONTROL_EVT, &param);
@ -1530,7 +1507,7 @@ void btc_hf_cb_handler(btc_msg_t *msg)
idx = p_data->hdr.handle - 1; idx = p_data->hdr.handle - 1;
CHECK_HF_IDX(idx); CHECK_HF_IDX(idx);
do { 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; param.unat_rep.unat = p_data->val.str;
btc_hf_cb_to_app(ESP_HF_UNAT_RESPONSE_EVT, &param); btc_hf_cb_to_app(ESP_HF_UNAT_RESPONSE_EVT, &param);
} while (0); } while (0);
@ -1541,7 +1518,7 @@ void btc_hf_cb_handler(btc_msg_t *msg)
{ {
idx = p_data->hdr.handle - 1; idx = p_data->hdr.handle - 1;
CHECK_HF_IDX(idx); 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, &param); btc_hf_cb_to_app(ESP_HF_IND_UPDATE_EVT, &param);
break; break;
} }
@ -1550,7 +1527,7 @@ void btc_hf_cb_handler(btc_msg_t *msg)
{ {
idx = p_data->hdr.handle - 1; idx = p_data->hdr.handle - 1;
CHECK_HF_IDX(idx); 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, &param); btc_hf_cb_to_app(ESP_HF_CIND_RESPONSE_EVT, &param);
break; break;
} }
@ -1559,7 +1536,7 @@ void btc_hf_cb_handler(btc_msg_t *msg)
{ {
idx = p_data->hdr.handle - 1; idx = p_data->hdr.handle - 1;
CHECK_HF_IDX(idx); 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, &param); btc_hf_cb_to_app(ESP_HF_COPS_RESPONSE_EVT, &param);
break; break;
} }
@ -1568,7 +1545,7 @@ void btc_hf_cb_handler(btc_msg_t *msg)
{ {
idx = p_data->hdr.handle - 1; idx = p_data->hdr.handle - 1;
CHECK_HF_IDX(idx); 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, &param); btc_hf_cb_to_app(ESP_HF_CLCC_RESPONSE_EVT, &param);
break; break;
} }
@ -1577,7 +1554,7 @@ void btc_hf_cb_handler(btc_msg_t *msg)
{ {
idx = p_data->hdr.handle - 1; idx = p_data->hdr.handle - 1;
CHECK_HF_IDX(idx); 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, &param); btc_hf_cb_to_app(ESP_HF_CNUM_RESPONSE_EVT, &param);
break; break;
} }
@ -1587,7 +1564,7 @@ void btc_hf_cb_handler(btc_msg_t *msg)
idx = p_data->hdr.handle - 1; idx = p_data->hdr.handle - 1;
CHECK_HF_IDX(idx); CHECK_HF_IDX(idx);
do { 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; param.vts_rep.code = p_data->val.str;
btc_hf_cb_to_app(ESP_HF_VTS_RESPONSE_EVT, &param); btc_hf_cb_to_app(ESP_HF_VTS_RESPONSE_EVT, &param);
} while(0); } while(0);
@ -1599,7 +1576,7 @@ void btc_hf_cb_handler(btc_msg_t *msg)
idx = p_data->hdr.handle - 1; idx = p_data->hdr.handle - 1;
CHECK_HF_IDX(idx); CHECK_HF_IDX(idx);
do { 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; param.nrec.state = p_data->val.num;
btc_hf_cb_to_app(ESP_HF_NREC_RESPONSE_EVT, &param); btc_hf_cb_to_app(ESP_HF_NREC_RESPONSE_EVT, &param);
} while(0); } while(0);
@ -1610,7 +1587,7 @@ void btc_hf_cb_handler(btc_msg_t *msg)
{ {
idx = p_data->hdr.handle - 1; idx = p_data->hdr.handle - 1;
CHECK_HF_IDX(idx); 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, &param); btc_hf_cb_to_app(ESP_HF_ATA_RESPONSE_EVT, &param);
break; break;
} }
@ -1619,7 +1596,7 @@ void btc_hf_cb_handler(btc_msg_t *msg)
{ {
idx = p_data->hdr.handle - 1; idx = p_data->hdr.handle - 1;
CHECK_HF_IDX(idx); 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, &param); btc_hf_cb_to_app(ESP_HF_CHUP_RESPONSE_EVT, &param);
break; break;
} }
@ -1631,14 +1608,14 @@ void btc_hf_cb_handler(btc_msg_t *msg)
CHECK_HF_IDX(idx); CHECK_HF_IDX(idx);
do { do {
if (event == BTA_AG_AT_D_EVT) { // dial_number_or_memory 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.type = p_data->val.value;
param.out_call.num_or_loc = osi_malloc((strlen(p_data->val.str) + 1) * sizeof(char)); 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); sprintf(param.out_call.num_or_loc, "%s", p_data->val.str);
btc_hf_cb_to_app(ESP_HF_DIAL_EVT, &param); btc_hf_cb_to_app(ESP_HF_DIAL_EVT, &param);
osi_free(param.out_call.num_or_loc); osi_free(param.out_call.num_or_loc);
} else if (event == BTA_AG_AT_BLDN_EVT) { //dial_last } 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; param.out_call.num_or_loc = NULL;
btc_hf_cb_to_app(ESP_HF_DIAL_EVT, &param); btc_hf_cb_to_app(ESP_HF_DIAL_EVT, &param);
} }
@ -1655,7 +1632,7 @@ void btc_hf_cb_handler(btc_msg_t *msg)
memset(&ag_res, 0, sizeof(ag_res)); memset(&ag_res, 0, sizeof(ag_res));
ag_res.ok_flag = BTA_AG_OK_ERROR; ag_res.ok_flag = BTA_AG_OK_ERROR;
ag_res.errcode = BTA_AG_ERR_OP_NOT_SUPPORTED; 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; break;
} }
@ -1670,11 +1647,11 @@ void btc_hf_cb_handler(btc_msg_t *msg)
** of SCO connection establishment */ ** of SCO connection establishment */
if ((btc_conf_hf_force_wbs == TRUE) && (p_data->val.num & BTA_AG_CODEC_MSBC)) { 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__); 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 { else {
BTC_TRACE_DEBUG("%s btc_hf override-Preferred Codec to CVSD", __FUNCTION__); 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 #endif
break; break;
@ -1686,7 +1663,7 @@ void btc_hf_cb_handler(btc_msg_t *msg)
CHECK_HF_IDX(idx); CHECK_HF_IDX(idx);
do { do {
BTC_TRACE_DEBUG("Set codec status %d codec %d 1=CVSD 2=MSBC", p_data->val.hdr.status, p_data->val.num); 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; param.wbs_rep.codec = p_data->val.num;
btc_hf_cb_to_app(ESP_HF_WBS_RESPONSE_EVT, &param); btc_hf_cb_to_app(ESP_HF_WBS_RESPONSE_EVT, &param);
} while (0); } while (0);
@ -1699,7 +1676,7 @@ void btc_hf_cb_handler(btc_msg_t *msg)
CHECK_HF_IDX(idx); CHECK_HF_IDX(idx);
do { do {
BTC_TRACE_DEBUG("AG final seleded codec is %d 1=CVSD 2=MSBC", p_data->val.num); 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; param.bcs_rep.mode = p_data->val.num;
/* No ESP_HF_WBS_NONE case, because HFP 1.6 supported device can send BCS */ /* 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, &param); btc_hf_cb_to_app(ESP_HF_BCS_RESPONSE_EVT, &param);
@ -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 param->hfp_ag_inited = false; // Not initialized by default
#if HFP_DYNAMIC_MEMORY == TRUE if (hf_local_param.initialized) {
if (hf_local_param) param->hfp_ag_inited = true;
#endif }
{
if (hf_local_param.btc_hf_cb != NULL) {
for (int idx = 0; idx < BTC_HF_NUM_CB; idx++) { for (int idx = 0; idx < BTC_HF_NUM_CB; idx++) {
if (hf_local_param[idx].btc_hf_cb.initialized) { if (hf_local_param.btc_hf_cb[idx].connection_state == ESP_HF_CONNECTION_STATE_SLC_CONNECTED) {
param->hfp_ag_inited = true; param->slc_conn_num++;
if (hf_local_param[idx].btc_hf_cb.connection_state == ESP_HF_CONNECTION_STATE_SLC_CONNECTED) { if (hf_local_param.btc_hf_cb[idx].sync_conn_hdl != ESP_INVALID_CONN_HANDLE) {
param->slc_conn_num++; param->sync_conn_num++;
if (hf_local_param[idx].btc_hf_cb.sync_conn_hdl != ESP_INVALID_CONN_HANDLE) {
param->sync_conn_num++;
}
} }
} }
} }

7
components/bt/host/bluedroid/btc/profile/std/include/btc_hf_ag.h
View File

@ -215,7 +215,6 @@ typedef union
/* BTC-AG control block to map bdaddr to BTA handle */ /* BTC-AG control block to map bdaddr to BTA handle */
typedef struct typedef struct
{ {
bool initialized;
UINT16 handle; UINT16 handle;
UINT16 sync_conn_hdl; UINT16 sync_conn_hdl;
bt_bdaddr_t connected_bda; bt_bdaddr_t connected_bda;
@ -233,9 +232,9 @@ typedef struct
typedef struct typedef struct
{ {
bool initialized;
int hf_idx; 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_incoming_data_cb_t btc_hf_incoming_data_cb;
esp_hf_outgoing_data_cb_t btc_hf_outgoing_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; esp_hf_ag_audio_data_cb_t btc_hf_audio_data_cb;
@ -243,7 +242,7 @@ typedef struct
#if HFP_DYNAMIC_MEMORY == TRUE #if HFP_DYNAMIC_MEMORY == TRUE
extern hf_local_param_t *hf_local_param_ptr; 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 #endif
/******************************************************************************* /*******************************************************************************