diff --git a/components/bt/host/bluedroid/api/include/api/esp_avrc_api.h b/components/bt/host/bluedroid/api/include/api/esp_avrc_api.h index 562de18706..15fd2c72ec 100644 --- a/components/bt/host/bluedroid/api/include/api/esp_avrc_api.h +++ b/components/bt/host/bluedroid/api/include/api/esp_avrc_api.h @@ -135,6 +135,7 @@ typedef enum { ESP_AVRC_CT_REMOTE_FEATURES_EVT = 5, /*!< feature of remote device indication event */ ESP_AVRC_CT_GET_RN_CAPABILITIES_RSP_EVT = 6, /*!< supported notification events capability of peer device */ ESP_AVRC_CT_SET_ABSOLUTE_VOLUME_RSP_EVT = 7, /*!< set absolute volume response event */ + ESP_AVRC_CT_PROF_STATE_EVT = 8, /*!< Indicate AVRCP controller init or deinit complete */ } esp_avrc_ct_cb_event_t; /// AVRC Target callback events @@ -145,6 +146,7 @@ typedef enum { ESP_AVRC_TG_SET_ABSOLUTE_VOLUME_CMD_EVT = 3, /*!< set absolute volume command from remote device */ ESP_AVRC_TG_REGISTER_NOTIFICATION_EVT = 4, /*!< register notification event */ ESP_AVRC_TG_SET_PLAYER_APP_VALUE_EVT = 5, /*!< set application attribute value, attribute refer to esp_avrc_ps_attr_ids_t */ + ESP_AVRC_TG_PROF_STATE_EVT = 6, /*!< Indicate AVRCP target init or deinit complete */ } esp_avrc_tg_cb_event_t; /// AVRC metadata attribute mask @@ -285,6 +287,18 @@ typedef struct { bool avrc_tg_inited; /*!< AVRCP TG initialization */ } esp_avrc_profile_status_t; +/** + * @brief Bluetooth AVRCP Initiation states + */ +typedef enum { + ESP_AVRC_INIT_SUCCESS = 0, /*!< Indicate init successful */ + ESP_AVRC_INIT_ALREADY, /*!< Indicate init repeated */ + ESP_AVRC_INIT_FAIL, /*!< Indicate init fail */ + ESP_AVRC_DEINIT_SUCCESS, /*!< Indicate deinit successful */ + ESP_AVRC_DEINIT_ALREADY, /*!< Indicate deinit repeated */ + ESP_AVRC_DEINIT_FAIL, /*!< Indicate deinit fail */ +} esp_avrc_init_state_t; + /// AVRC controller callback parameters typedef union { /** @@ -345,6 +359,13 @@ typedef union { struct avrc_ct_set_volume_rsp_param { uint8_t volume; /*!< the volume which has actually been set, range is 0 to 0x7f, means 0% to 100% */ } set_volume_rsp; /*!< set absolute volume response event */ + + /** + * @brief ESP_AVRC_CT_PROF_STATE_EVT + */ + struct avrc_ct_init_stat_param { + esp_avrc_init_state_t state; /*!< avrc ct initialization param */ + } avrc_ct_init_stat; /*!< status to indicate avrcp ct init or deinit */ } esp_avrc_ct_cb_param_t; /// AVRC target callback parameters @@ -397,6 +418,13 @@ typedef union { esp_avrc_set_app_value_param_t *p_vals; /*!< point to the id and value of player application attribute */ } set_app_value; /*!< set player application value */ + /** + * @brief ESP_AVRC_TG_PROF_STATE_EVT + */ + struct avrc_tg_init_stat_param { + esp_avrc_init_state_t state; /*!< avrc tg initialization param */ + } avrc_tg_init_stat; /*!< status to indicate avrcp tg init or deinit */ + } esp_avrc_tg_cb_param_t; /** @@ -437,6 +465,7 @@ esp_err_t esp_avrc_ct_register_callback(esp_avrc_ct_cb_t callback); * @brief Initialize the bluetooth AVRCP controller module, This function should be called * after esp_bluedroid_enable() completes successfully. Note: AVRC cannot work independently, * AVRC should be used along with A2DP and AVRC should be initialized before A2DP. + * ESP_AVRC_CT_PROF_STATE_EVT with ESP_AVRC_INIT_SUCCESS will reported to the APP layer. * * @return * - ESP_OK: success @@ -451,6 +480,7 @@ esp_err_t esp_avrc_ct_init(void); * @brief De-initialize AVRCP controller module. This function should be called after * after esp_bluedroid_enable() completes successfully. Note: AVRC cannot work independently, * AVRC should be used along with A2DP and AVRC should be deinitialized before A2DP. + * ESP_AVRC_CT_PROF_STATE_EVT with ESP_AVRC_DEINIT_SUCCESS will reported to the APP layer. * * @return * - ESP_OK: success @@ -579,6 +609,7 @@ esp_err_t esp_avrc_tg_register_callback(esp_avrc_tg_cb_t callback); * @brief Initialize the bluetooth AVRCP target module, This function should be called * after esp_bluedroid_enable() completes successfully. Note: AVRC cannot work independently, * AVRC should be used along with A2DP and AVRC should be initialized before A2DP. + * ESP_AVRC_TG_PROF_STATE_EVT with ESP_AVRC_INIT_SUCCESS will reported to the APP layer. * * @return * - ESP_OK: success @@ -593,6 +624,7 @@ esp_err_t esp_avrc_tg_init(void); * @brief De-initialize AVRCP target module. This function should be called after * after esp_bluedroid_enable() completes successfully. Note: AVRC cannot work independently, * AVRC should be used along with A2DP and AVRC should be deinitialized before A2DP. + * ESP_AVRC_TG_PROF_STATE_EVT with ESP_AVRC_DEINIT_SUCCESS will reported to the APP layer. * * @return * - ESP_OK: success diff --git a/components/bt/host/bluedroid/btc/profile/std/avrc/btc_avrc.c b/components/bt/host/bluedroid/btc/profile/std/avrc/btc_avrc.c index f3574f6471..6bc28c32c1 100644 --- a/components/bt/host/bluedroid/btc/profile/std/avrc/btc_avrc.c +++ b/components/bt/host/bluedroid/btc/profile/std/avrc/btc_avrc.c @@ -252,10 +252,6 @@ static bool btc_avrc_tg_set_rn_supported_evt(uint16_t evt_set) static inline void btc_avrc_ct_cb_to_app(esp_avrc_ct_cb_event_t event, esp_avrc_ct_cb_param_t *param) { - if (s_rc_ct_init != BTC_RC_CT_INIT_MAGIC) { - return; - } - esp_avrc_ct_cb_t btc_avrc_ct_cb = (esp_avrc_ct_cb_t)btc_profile_cb_get(BTC_PID_AVRC_CT); if (btc_avrc_ct_cb) { btc_avrc_ct_cb(event, param); @@ -264,10 +260,6 @@ static inline void btc_avrc_ct_cb_to_app(esp_avrc_ct_cb_event_t event, esp_avrc_ static inline void btc_avrc_tg_cb_to_app(esp_avrc_tg_cb_event_t event, esp_avrc_tg_cb_param_t *param) { - if (s_rc_tg_init != BTC_RC_TG_INIT_MAGIC) { - return; - } - esp_avrc_tg_cb_t btc_avrc_tg_cb = (esp_avrc_tg_cb_t)btc_profile_cb_get(BTC_PID_AVRC_TG); if (btc_avrc_tg_cb) { btc_avrc_tg_cb(event, param); @@ -998,27 +990,39 @@ BOOLEAN btc_rc_get_connected_peer(BD_ADDR peer_addr) *******************************************************************************/ static void btc_avrc_ct_init(void) { + esp_avrc_init_state_t state = ESP_AVRC_INIT_SUCCESS; + BTC_TRACE_DEBUG("## %s ##", __FUNCTION__); - if (s_rc_ct_init == BTC_RC_CT_INIT_MAGIC) { - BTC_TRACE_WARNING("%s already initialized", __FUNCTION__); - return; - } - /// initialize CT-specific resources - s_rc_ct_init = BTC_RC_CT_INIT_MAGIC; + do { - /// initialize CT-TG shared resources - if (s_rc_tg_init != BTC_RC_TG_INIT_MAGIC) { - memset (&btc_rc_cb, 0, sizeof(btc_rc_cb_t)); - - if (!g_av_with_rc) { - g_av_with_rc = true; + if (s_rc_ct_init == BTC_RC_CT_INIT_MAGIC) { + BTC_TRACE_WARNING("%s already initialized", __FUNCTION__); + state = ESP_AVRC_INIT_ALREADY; + break; } - if (g_a2dp_on_init) { - BTC_TRACE_WARNING("AVRC Controller is expected to be initialized in advance of A2DP !!!"); + /// initialize CT-TG shared resources + if (s_rc_tg_init != BTC_RC_TG_INIT_MAGIC) { + if (g_a2dp_on_init) { + BTC_TRACE_WARNING("AVRC Controller is expected to be initialized in advance of A2DP !!!"); + state = ESP_AVRC_INIT_FAIL; + break; + } + memset (&btc_rc_cb, 0, sizeof(btc_rc_cb_t)); + + if (!g_av_with_rc) { + g_av_with_rc = true; + } } - } + + /// initialize CT-specific resources + s_rc_ct_init = BTC_RC_CT_INIT_MAGIC; + } while (0); + + esp_avrc_ct_cb_param_t param = {0}; + param.avrc_ct_init_stat.state = state; + btc_avrc_ct_cb_to_app(ESP_AVRC_CT_PROF_STATE_EVT, ¶m); } @@ -1033,29 +1037,37 @@ static void btc_avrc_ct_init(void) ***************************************************************************/ static void btc_avrc_ct_deinit(void) { + esp_avrc_init_state_t state = ESP_AVRC_DEINIT_SUCCESS; + BTC_TRACE_API("## %s ##", __FUNCTION__); - if (g_a2dp_on_deinit) { - BTC_TRACE_WARNING("A2DP already deinit, AVRC CT should deinit in advance of A2DP !!!"); - } - - if (s_rc_ct_init != BTC_RC_CT_INIT_MAGIC) { - BTC_TRACE_WARNING("%s not initialized", __FUNCTION__); - return; - } - - /// deinit CT-specific resources - s_rc_ct_init = 0; - - /// deinit CT-TG shared resources - if (s_rc_tg_init != BTC_RC_TG_INIT_MAGIC) { - memset (&btc_rc_cb, 0, sizeof(btc_rc_cb_t)); - if (g_av_with_rc) { - g_av_with_rc = false; + do { + if (g_a2dp_on_deinit) { + BTC_TRACE_WARNING("A2DP already deinit, AVRC CT should deinit in advance of A2DP !!!"); } - } - BTC_TRACE_API("## %s ## completed", __FUNCTION__); + if (s_rc_ct_init != BTC_RC_CT_INIT_MAGIC) { + BTC_TRACE_WARNING("%s not initialized", __FUNCTION__); + state = ESP_AVRC_DEINIT_ALREADY; + break; + } + + /// deinit CT-specific resources + s_rc_ct_init = 0; + + /// deinit CT-TG shared resources + if (s_rc_tg_init != BTC_RC_TG_INIT_MAGIC) { + memset (&btc_rc_cb, 0, sizeof(btc_rc_cb_t)); + if (g_av_with_rc) { + g_av_with_rc = false; + } + } + BTC_TRACE_API("## %s ## completed", __FUNCTION__); + } while (0); + + esp_avrc_ct_cb_param_t param = {0}; + param.avrc_ct_init_stat.state = state; + btc_avrc_ct_cb_to_app(ESP_AVRC_CT_PROF_STATE_EVT, ¶m); } static bt_status_t btc_avrc_ct_send_set_player_value_cmd(uint8_t tl, uint8_t attr_id, uint8_t value_id) @@ -1274,30 +1286,42 @@ static bt_status_t btc_avrc_ct_send_passthrough_cmd(uint8_t tl, uint8_t key_code *******************************************************************************/ static void btc_avrc_tg_init(void) { + esp_avrc_init_state_t state = ESP_AVRC_INIT_SUCCESS; + BTC_TRACE_DEBUG("## %s ##", __FUNCTION__); - if (s_rc_tg_init == BTC_RC_TG_INIT_MAGIC) { - BTC_TRACE_WARNING("%s already initialized", __FUNCTION__); - return; - } - /// initialize TG-specific resources - memcpy(s_psth_supported_cmd, cs_psth_dft_supported_cmd, sizeof(s_psth_supported_cmd)); - s_rn_supported_evt = cs_rn_dft_supported_evt; - - /// initialize CT-TG shared resources - if (s_rc_ct_init != BTC_RC_CT_INIT_MAGIC) { - memset (&btc_rc_cb, 0, sizeof(btc_rc_cb)); - - if (!g_av_with_rc) { - g_av_with_rc = true; + do { + if (s_rc_tg_init == BTC_RC_TG_INIT_MAGIC) { + BTC_TRACE_WARNING("%s already initialized", __FUNCTION__); + state = ESP_AVRC_INIT_ALREADY; + break; } - if (g_a2dp_on_init) { - BTC_TRACE_WARNING("AVRC Target is expected to be initialized in advance of A2DP !!!"); - } - } + /// initialize CT-TG shared resources + if (s_rc_ct_init != BTC_RC_CT_INIT_MAGIC) { + if (g_a2dp_on_init) { + BTC_TRACE_WARNING("AVRC Target is expected to be initialized in advance of A2DP !!!"); + state = ESP_AVRC_INIT_FAIL; + break; + } - s_rc_tg_init = BTC_RC_TG_INIT_MAGIC; + memset (&btc_rc_cb, 0, sizeof(btc_rc_cb)); + + if (!g_av_with_rc) { + g_av_with_rc = true; + } + } + + /// initialize TG-specific resources + memcpy(s_psth_supported_cmd, cs_psth_dft_supported_cmd, sizeof(s_psth_supported_cmd)); + s_rn_supported_evt = cs_rn_dft_supported_evt; + + s_rc_tg_init = BTC_RC_TG_INIT_MAGIC; + } while (0); + + esp_avrc_tg_cb_param_t param = {0}; + param.avrc_tg_init_stat.state = state; + btc_avrc_tg_cb_to_app(ESP_AVRC_TG_PROF_STATE_EVT, ¶m); } @@ -1312,31 +1336,40 @@ static void btc_avrc_tg_init(void) ***************************************************************************/ static void btc_avrc_tg_deinit(void) { + esp_avrc_init_state_t state = ESP_AVRC_DEINIT_SUCCESS; + BTC_TRACE_API("## %s ##", __FUNCTION__); - if (g_a2dp_on_deinit) { - BTC_TRACE_WARNING("A2DP already deinit, AVRC TG should deinit in advance of A2DP !!!"); - } - - if (s_rc_tg_init != BTC_RC_TG_INIT_MAGIC) { - BTC_TRACE_WARNING("%s not initialized", __FUNCTION__); - return; - } - - /// deinit TG-specific resources - memset(s_psth_supported_cmd, 0, sizeof(s_psth_supported_cmd)); - s_rn_supported_evt = 0; - s_rc_tg_init = 0; - - /// deinit CT-TG shared resources - if (s_rc_ct_init != BTC_RC_CT_INIT_MAGIC) { - memset (&btc_rc_cb, 0, sizeof(btc_rc_cb)); - if (g_av_with_rc) { - g_av_with_rc = false; + do { + if (g_a2dp_on_deinit) { + BTC_TRACE_WARNING("A2DP already deinit, AVRC TG should deinit in advance of A2DP !!!"); } - } - BTC_TRACE_API("## %s ## completed", __FUNCTION__); + if (s_rc_tg_init != BTC_RC_TG_INIT_MAGIC) { + BTC_TRACE_WARNING("%s not initialized", __FUNCTION__); + state = ESP_AVRC_DEINIT_ALREADY; + break; + } + + /// deinit TG-specific resources + memset(s_psth_supported_cmd, 0, sizeof(s_psth_supported_cmd)); + s_rn_supported_evt = 0; + s_rc_tg_init = 0; + + /// deinit CT-TG shared resources + if (s_rc_ct_init != BTC_RC_CT_INIT_MAGIC) { + memset (&btc_rc_cb, 0, sizeof(btc_rc_cb)); + if (g_av_with_rc) { + g_av_with_rc = false; + } + } + + BTC_TRACE_API("## %s ## completed", __FUNCTION__); + } while (0); + + esp_avrc_tg_cb_param_t param = {0}; + param.avrc_tg_init_stat.state = state; + btc_avrc_tg_cb_to_app(ESP_AVRC_TG_PROF_STATE_EVT, ¶m); } static void btc_avrc_tg_send_rn_rsp(esp_avrc_rn_event_ids_t event_id, esp_avrc_rn_rsp_t rsp, const esp_avrc_rn_param_t *param) diff --git a/examples/bluetooth/bluedroid/classic_bt/a2dp_sink/main/bt_app_av.c b/examples/bluetooth/bluedroid/classic_bt/a2dp_sink/main/bt_app_av.c index ceb10b3b6f..36517b2b97 100644 --- a/examples/bluetooth/bluedroid/classic_bt/a2dp_sink/main/bt_app_av.c +++ b/examples/bluetooth/bluedroid/classic_bt/a2dp_sink/main/bt_app_av.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Unlicense OR CC0-1.0 */ @@ -364,7 +364,7 @@ static void bt_av_hdl_a2d_evt(uint16_t event, void *p_param) if (a2d->a2d_psc_cfg_stat.psc_mask & ESP_A2D_PSC_DELAY_RPT) { ESP_LOGI(BT_AV_TAG, "Peer device support delay reporting"); } else { - ESP_LOGI(BT_AV_TAG, "Peer device unsupport delay reporting"); + ESP_LOGI(BT_AV_TAG, "Peer device unsupported delay reporting"); } break; } @@ -415,13 +415,13 @@ static void bt_av_hdl_avrc_ct_evt(uint16_t event, void *p_param) } break; } - /* when passthrough responsed, this event comes */ + /* when passthrough responded, this event comes */ case ESP_AVRC_CT_PASSTHROUGH_RSP_EVT: { ESP_LOGI(BT_RC_CT_TAG, "AVRC passthrough rsp: key_code 0x%x, key_state %d, rsp_code %d", rc->psth_rsp.key_code, rc->psth_rsp.key_state, rc->psth_rsp.rsp_code); break; } - /* when metadata responsed, this event comes */ + /* when metadata responded, this event comes */ case ESP_AVRC_CT_METADATA_RSP_EVT: { ESP_LOGI(BT_RC_CT_TAG, "AVRC metadata rsp: attribute id 0x%x, %s", rc->meta_rsp.attr_id, rc->meta_rsp.attr_text); free(rc->meta_rsp.attr_text); @@ -448,6 +448,17 @@ static void bt_av_hdl_avrc_ct_evt(uint16_t event, void *p_param) bt_av_play_pos_changed(); break; } + /* when avrcp controller init or deinit completed, this event comes */ + case ESP_AVRC_CT_PROF_STATE_EVT: { + if (ESP_AVRC_INIT_SUCCESS == rc->avrc_ct_init_stat.state) { + ESP_LOGI(BT_RC_CT_TAG, "AVRCP CT STATE: Init Complete"); + } else if (ESP_AVRC_DEINIT_SUCCESS == rc->avrc_ct_init_stat.state) { + ESP_LOGI(BT_RC_CT_TAG, "AVRCP CT STATE: Deinit Complete"); + } else { + ESP_LOGE(BT_RC_CT_TAG, "AVRCP CT STATE error: %d", rc->avrc_ct_init_stat.state); + } + break; + } /* others */ default: ESP_LOGE(BT_RC_CT_TAG, "%s unhandled event: %d", __func__, event); @@ -503,6 +514,17 @@ static void bt_av_hdl_avrc_tg_evt(uint16_t event, void *p_param) ESP_LOGI(BT_RC_TG_TAG, "AVRC remote features: %"PRIx32", CT features: %x", rc->rmt_feats.feat_mask, rc->rmt_feats.ct_feat_flag); break; } + /* when avrcp target init or deinit completed, this event comes */ + case ESP_AVRC_TG_PROF_STATE_EVT: { + if (ESP_AVRC_INIT_SUCCESS == rc->avrc_tg_init_stat.state) { + ESP_LOGI(BT_RC_CT_TAG, "AVRCP TG STATE: Init Complete"); + } else if (ESP_AVRC_DEINIT_SUCCESS == rc->avrc_tg_init_stat.state) { + ESP_LOGI(BT_RC_CT_TAG, "AVRCP TG STATE: Deinit Complete"); + } else { + ESP_LOGE(BT_RC_CT_TAG, "AVRCP TG STATE error: %d", rc->avrc_tg_init_stat.state); + } + break; + } /* others */ default: ESP_LOGE(BT_RC_TG_TAG, "%s unhandled event: %d", __func__, event); @@ -553,7 +575,8 @@ void bt_app_rc_ct_cb(esp_avrc_ct_cb_event_t event, esp_avrc_ct_cb_param_t *param case ESP_AVRC_CT_PASSTHROUGH_RSP_EVT: case ESP_AVRC_CT_CHANGE_NOTIFY_EVT: case ESP_AVRC_CT_REMOTE_FEATURES_EVT: - case ESP_AVRC_CT_GET_RN_CAPABILITIES_RSP_EVT: { + case ESP_AVRC_CT_GET_RN_CAPABILITIES_RSP_EVT: + case ESP_AVRC_CT_PROF_STATE_EVT: { bt_app_work_dispatch(bt_av_hdl_avrc_ct_evt, event, param, sizeof(esp_avrc_ct_cb_param_t), NULL); break; } @@ -572,6 +595,7 @@ void bt_app_rc_tg_cb(esp_avrc_tg_cb_event_t event, esp_avrc_tg_cb_param_t *param case ESP_AVRC_TG_SET_ABSOLUTE_VOLUME_CMD_EVT: case ESP_AVRC_TG_REGISTER_NOTIFICATION_EVT: case ESP_AVRC_TG_SET_PLAYER_APP_VALUE_EVT: + case ESP_AVRC_TG_PROF_STATE_EVT: bt_app_work_dispatch(bt_av_hdl_avrc_tg_evt, event, param, sizeof(esp_avrc_tg_cb_param_t), NULL); break; default: diff --git a/examples/bluetooth/bluedroid/classic_bt/a2dp_sink/main/main.c b/examples/bluetooth/bluedroid/classic_bt/a2dp_sink/main/main.c index 59db6f4c93..539e19f45d 100644 --- a/examples/bluetooth/bluedroid/classic_bt/a2dp_sink/main/main.c +++ b/examples/bluetooth/bluedroid/classic_bt/a2dp_sink/main/main.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD + * SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Unlicense OR CC0-1.0 */ @@ -132,17 +132,17 @@ static void bt_av_hdl_stack_evt(uint16_t event, void *p_param) esp_bt_gap_set_device_name(local_device_name); esp_bt_gap_register_callback(bt_app_gap_cb); - assert(esp_avrc_ct_init() == ESP_OK); esp_avrc_ct_register_callback(bt_app_rc_ct_cb); - assert(esp_avrc_tg_init() == ESP_OK); + assert(esp_avrc_ct_init() == ESP_OK); esp_avrc_tg_register_callback(bt_app_rc_tg_cb); + assert(esp_avrc_tg_init() == ESP_OK); esp_avrc_rn_evt_cap_mask_t evt_set = {0}; esp_avrc_rn_evt_bit_mask_operation(ESP_AVRC_BIT_MASK_OP_SET, &evt_set, ESP_AVRC_RN_VOLUME_CHANGE); assert(esp_avrc_tg_set_rn_evt_cap(&evt_set) == ESP_OK); - assert(esp_a2d_sink_init() == ESP_OK); esp_a2d_register_callback(&bt_app_a2d_cb); + assert(esp_a2d_sink_init() == ESP_OK); esp_a2d_sink_register_data_callback(bt_app_a2d_data_cb); /* Get the default value of the delay value */