feat(bt/bluedroid): Add events to indicate the initialization states of AVRCP

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

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
+    do {
-    s_rc_ct_init = BTC_RC_CT_INIT_MAGIC;
 
-    /// initialize CT-TG shared resources
+        if (s_rc_ct_init == BTC_RC_CT_INIT_MAGIC) {
-    if (s_rc_tg_init != BTC_RC_TG_INIT_MAGIC) {
+            BTC_TRACE_WARNING("%s already initialized", __FUNCTION__);
-        memset (&btc_rc_cb, 0, sizeof(btc_rc_cb_t));
+            state = ESP_AVRC_INIT_ALREADY;
-
+            break;
-        if (!g_av_with_rc) {
-            g_av_with_rc = true;
         }
 
-        if (g_a2dp_on_init) {
+        /// initialize CT-TG shared resources
-            BTC_TRACE_WARNING("AVRC Controller is expected to be initialized in advance of A2DP !!!");
+        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, &param);
 }
 
 
@@ -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) {
+    do {
-        BTC_TRACE_WARNING("A2DP already deinit, AVRC CT should deinit in advance of A2DP !!!");
+        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;
         }
-    }
 
-    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, &param);
 }
 
 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
+    do {
-    memcpy(s_psth_supported_cmd, cs_psth_dft_supported_cmd, sizeof(s_psth_supported_cmd));
+        if (s_rc_tg_init == BTC_RC_TG_INIT_MAGIC) {
-    s_rn_supported_evt = cs_rn_dft_supported_evt;
+            BTC_TRACE_WARNING("%s already initialized", __FUNCTION__);
-
+            state = ESP_AVRC_INIT_ALREADY;
-    /// initialize CT-TG shared resources
+            break;
-    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;
         }
 
-        if (g_a2dp_on_init) {
+        /// initialize CT-TG shared resources
-            BTC_TRACE_WARNING("AVRC Target is expected to be initialized in advance of A2DP !!!");
+        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, &param);
 }
 
 
@@ -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) {
+    do {
-        BTC_TRACE_WARNING("A2DP already deinit, AVRC TG should deinit in advance of A2DP !!!");
+        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;
         }
-    }
 
-    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, &param);
 }
 
 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)

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:

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 */