Chapter 53: Bluetooth A2DP Sink Implementation

#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <stdio.h> // For sprintf

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "esp_bt.h"
#include "esp_bt_main.h"
#include "esp_bt_device.h"
#include "esp_gap_bt_api.h"
#include "esp_a2dp_api.h"
#include "esp_avrc_api.h" // For AVRCP Target (receiving remote control commands)
#include "driver/i2s.h"

static const char *TAG = "A2DP_SINK_DEMO";

// I2S Configuration
// IMPORTANT: Modify these pins based on your hardware setup (ESP32 board and external DAC)
#define I2S_NUM         (I2S_NUM_0)
#define I2S_BCK_PIN     (GPIO_NUM_26) // Bit Clock
#define I2S_WS_PIN      (GPIO_NUM_25) // Word Select (Left/Right Clock)
#define I2S_DO_PIN      (GPIO_NUM_22) // Data Out
// Data In pin is not used for A2DP Sink (TX mode)
#define I2S_DI_PIN      (I2S_PIN_NO_CHANGE)

// A2DP application state machine
typedef enum {
    APP_AV_STATE_IDLE,
    APP_AV_STATE_UNCONNECTED,
    APP_AV_STATE_CONNECTING,
    APP_AV_STATE_CONNECTED,
    APP_AV_STATE_DISCONNECTING,
} app_av_state_t;

// Forward declarations of callback functions and handlers
static void bt_app_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *param);
static void bt_app_a2d_cb(esp_a2d_sink_cb_event_t event, esp_a2d_sink_cb_param_t *param);
static void bt_app_a2d_data_cb(const uint8_t *data, uint32_t len);
static void bt_app_rc_tg_cb(esp_avrc_tg_cb_event_t event, esp_avrc_tg_cb_param_t *param);
static void bt_app_av_sm_handler(uint16_t event, void *param);

// Global variables for A2DP Sink state
static esp_a2d_audio_state_t s_audio_state = ESP_A2D_AUDIO_STATE_STOPPED;
static app_av_state_t s_app_av_state = APP_AV_STATE_IDLE;
static esp_bd_addr_t s_peer_bda = {0}; // Stores the Bluetooth Device Address of the connected peer
static char s_local_bda_str[18];     // Stores local BDA as string

// Helper function to convert Bluetooth Device Address (BDA) to string
static char *bda_to_str(const esp_bd_addr_t bda, char *str, size_t size) {
    if (bda == NULL || str == NULL || size < 18) {
        return NULL;
    }
    sprintf(str, "%02X:%02X:%02X:%02X:%02X:%02X",
            bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
    return str;
}

// I2S peripheral initialization
static void i2s_init(void) {
    ESP_LOGI(TAG, "Initializing I2S interface...");
    i2s_config_t i2s_config = {
        .mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX), // Set as I2S master and transmitter
        .sample_rate = 44100, // Default sample rate, will be updated by A2DP audio config
        .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT, // Default bits per sample
        .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT, // Stereo
        .communication_format = I2S_COMM_FORMAT_STAND_I2S, // Standard I2S protocol
        .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1, // Interrupt priority
        .dma_buf_count = 6, // Number of DMA buffers
        .dma_buf_len = 1024, // Size of each DMA buffer in samples (increased for stability)
        .use_apll = true, // Use APLL as clock source for better accuracy
        .tx_desc_auto_clear = true, // Auto clear TX descriptors
        .fixed_mclk = 0 // No MCLK output needed for most DACs
    };

    esp_err_t err = i2s_driver_install(I2S_NUM, &i2s_config, 0, NULL);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "I2S driver install failed: %s", esp_err_to_name(err));
        return;
    }

    i2s_pin_config_t pin_config = {
        .bck_io_num = I2S_BCK_PIN,
        .ws_io_num = I2S_WS_PIN,
        .data_out_num = I2S_DO_PIN,
        .data_in_num = I2S_DI_PIN // Not used for TX mode
    };

    err = i2s_set_pin(I2S_NUM, &pin_config);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "I2S set pin failed: %s", esp_err_to_name(err));
        i2s_driver_uninstall(I2S_NUM); // Clean up if pin setting fails
        return;
    }

    // Set initial clock rate (will be updated by A2DP callback)
    err = i2s_set_clk(I2S_NUM, i2s_config.sample_rate, i2s_config.bits_per_sample, I2S_CHANNEL_STEREO);
     if (err != ESP_OK) {
        ESP_LOGE(TAG, "I2S set clock failed: %s", esp_err_to_name(err));
    }

    ESP_LOGI(TAG, "I2S initialized successfully (BCK:%d, WS:%d, DO:%d)", I2S_BCK_PIN, I2S_WS_PIN, I2S_DO_PIN);
    i2s_stop(I2S_NUM); // Ensure I2S is stopped initially
}

// Main application entry point
void app_main(void) {
    esp_err_t ret;

    // Initialize NVS (Non-Volatile Storage) - required for Bluetooth
    ESP_LOGI(TAG, "Initializing NVS...");
    ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        ESP_ERROR_CHECK(nvs_flash_erase());
        ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK(ret);
    ESP_LOGI(TAG, "NVS initialized.");

    // Release Bluetooth controller memory if it was allocated for BLE
    ESP_LOGI(TAG, "Releasing BT controller memory for BLE mode...");
    ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_BLE));

    // Initialize Bluetooth Controller
    ESP_LOGI(TAG, "Initializing Bluetooth controller...");
    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
    ret = esp_bt_controller_init(&bt_cfg);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Initialize controller failed: %s", esp_err_to_name(ret));
        return;
    }
    ESP_LOGI(TAG, "Bluetooth controller initialized.");

    // Enable Bluetooth Controller in Classic Bluetooth mode
    ESP_LOGI(TAG, "Enabling Bluetooth controller in Classic BT mode...");
    ret = esp_bt_controller_enable(ESP_BT_MODE_CLASSIC_BT);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Enable controller failed: %s", esp_err_to_name(ret));
        return;
    }
    ESP_LOGI(TAG, "Bluetooth controller enabled in Classic BT mode.");

    // Initialize Bluedroid Host Stack
    ESP_LOGI(TAG, "Initializing Bluedroid host stack...");
    ret = esp_bluedroid_init();
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Initialize Bluedroid failed: %s", esp_err_to_name(ret));
        return;
    }
    ESP_LOGI(TAG, "Bluedroid host stack initialized.");

    // Enable Bluedroid Host Stack
    ESP_LOGI(TAG, "Enabling Bluedroid host stack...");
    ret = esp_bluedroid_enable();
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Enable Bluedroid failed: %s", esp_err_to_name(ret));
        return;
    }
    ESP_LOGI(TAG, "Bluedroid host stack enabled.");

    // Register GAP callback function
    ESP_LOGI(TAG, "Registering GAP callback...");
    ret = esp_bt_gap_register_callback(bt_app_gap_cb);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "GAP callback register failed: %s", esp_err_to_name(ret));
        return;
    }
    ESP_LOGI(TAG, "GAP callback registered.");

    // Register A2DP Sink event callback function
    ESP_LOGI(TAG, "Registering A2DP Sink event callback...");
    ret = esp_a2d_sink_register_callback(bt_app_a2d_cb);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "A2DP Sink event callback register failed: %s", esp_err_to_name(ret));
        return;
    }
    ESP_LOGI(TAG, "A2DP Sink event callback registered.");

    // Register A2DP Sink data callback function (for receiving audio data)
    ESP_LOGI(TAG, "Registering A2DP Sink data callback...");
    ret = esp_a2d_sink_register_data_callback(bt_app_a2d_data_cb);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "A2DP Sink data callback register failed: %s", esp_err_to_name(ret));
        return;
    }
    ESP_LOGI(TAG, "A2DP Sink data callback registered.");

    // Initialize A2DP Sink profile
    ESP_LOGI(TAG, "Initializing A2DP Sink profile...");
    ret = esp_a2d_sink_init();
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "A2DP Sink init failed: %s", esp_err_to_name(ret));
        return;
    }
    ESP_LOGI(TAG, "A2DP Sink profile initialized.");

    // Initialize AVRCP Target profile (for remote control commands)
    ESP_LOGI(TAG, "Initializing AVRCP Target profile...");
    ret = esp_avrc_tg_init();
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "AVRCP Target init failed: %s", esp_err_to_name(ret));
    } else {
        ESP_LOGI(TAG, "Registering AVRCP Target callback...");
        ret = esp_avrc_tg_register_callback(bt_app_rc_tg_cb); // Corrected: register AVRCP Target callback
        if (ret != ESP_OK) {
            ESP_LOGE(TAG, "AVRCP Target callback register failed: %s", esp_err_to_name(ret));
        }
    }
    ESP_LOGI(TAG, "AVRCP Target profile initialized and callback registered.");


    // Set device name (as configured in menuconfig or sdkconfig.defaults)
    // This name will be visible to other Bluetooth devices during scanning.
    const char * configured_device_name;
    esp_bt_dev_get_device_name(&configured_device_name); // Get name set by menuconfig
    ESP_LOGI(TAG, "Setting device name to '%s'...", configured_device_name);
    // Note: esp_bt_dev_set_device_name() can override menuconfig if called after bluedroid_init.
    // We rely on the menuconfig name here.

    // Set discoverability and connectability mode
    ESP_LOGI(TAG, "Setting device to connectable and discoverable...");
    ret = esp_bt_gap_set_scan_mode(ESP_BT_CONNECTABLE, ESP_BT_GENERAL_DISCOVERABLE);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Set scan mode failed: %s", esp_err_to_name(ret));
    } else {
        ESP_LOGI(TAG, "Device set to connectable and discoverable.");
    }

    // Initialize I2S for audio output
    i2s_init();

    ESP_LOGI(TAG, "A2DP Sink Demo Initialized. Waiting for connections...");

    // Get and log local Bluetooth device address
    const uint8_t *bda = esp_bt_dev_get_address();
    if (bda) {
        bda_to_str(bda, s_local_bda_str, sizeof(s_local_bda_str));
        ESP_LOGI(TAG, "Local Bluetooth Address: %s", s_local_bda_str);
    } else {
        ESP_LOGE(TAG, "Failed to get local Bluetooth address.");
    }
}

// Bluetooth GAP (Generic Access Profile) callback function
static void bt_app_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *param) {
    char peer_bda_str[18]; // Buffer for peer BDA string

    switch (event) {
        case ESP_BT_GAP_AUTH_CMPL_EVT: { // Authentication complete event
            if (param->auth_cmpl.stat == ESP_BT_STATUS_SUCCESS) {
                ESP_LOGI(TAG, "GAP Authentication success. Device: %s, BDA: %s",
                         param->auth_cmpl.device_name,
                         bda_to_str(param->auth_cmpl.bda, peer_bda_str, sizeof(peer_bda_str)));
                memcpy(s_peer_bda, param->auth_cmpl.bda, ESP_BD_ADDR_LEN); // Store peer BDA
            } else {
                ESP_LOGE(TAG, "GAP Authentication failed. Status: %d, BDA: %s", param->auth_cmpl.stat,
                         bda_to_str(param->auth_cmpl.bda, peer_bda_str, sizeof(peer_bda_str)));
            }
            break;
        }
#if (CONFIG_BT_SSP_ENABLED == true)
        case ESP_BT_GAP_CFM_REQ_EVT: // SSP (Secure Simple Pairing) User Confirmation Request
            ESP_LOGI(TAG, "GAP SSP Confirmation request. BDA: %s. Numeric value: %d",
                     bda_to_str(param->cfm_req.bda, peer_bda_str, sizeof(peer_bda_str)),
                     param->cfm_req.num_val);
            // For simplicity, auto-confirm. In a real product, display num_val to user.
            esp_bt_gap_ssp_confirm_reply(param->cfm_req.bda, true);
            break;
        case ESP_BT_GAP_KEY_NOTIF_EVT: // SSP Passkey Notification (display this passkey to the user)
            ESP_LOGI(TAG, "GAP SSP Passkey notification. BDA: %s, Passkey: %d",
                     bda_to_str(param->key_notif.bda, peer_bda_str, sizeof(peer_bda_str)),
                     param->key_notif.passkey);
            break;
        case ESP_BT_GAP_KEY_REQ_EVT: // SSP Passkey Request (user enters passkey)
            ESP_LOGI(TAG, "GAP SSP Passkey request. BDA: %s",
                     bda_to_str(param->key_req.bda, peer_bda_str, sizeof(peer_bda_str)));
            // For simplicity, we don't handle passkey input.
            // In a real app, prompt user: esp_bt_gap_ssp_passkey_reply(param->key_req.bda, true, 123456);
            ESP_LOGW(TAG, "SSP Passkey request not handled in this example.");
            break;
#endif // CONFIG_BT_SSP_ENABLED
        case ESP_BT_GAP_MODE_CHG_EVT: // GAP Mode Change Event
             ESP_LOGI(TAG, "GAP Mode Changed: mode: %d, BDA: %s", param->mode_chg.mode,
                      bda_to_str(param->mode_chg.bda, peer_bda_str, sizeof(peer_bda_str)));
            break;
        default: {
            ESP_LOGD(TAG, "Unhandled GAP Event: %d", event);
            break;
        }
    }
}

// A2DP Sink event callback function
// This function is called by the Bluedroid stack when A2DP Sink events occur.
static void bt_app_a2d_cb(esp_a2d_sink_cb_event_t event, esp_a2d_sink_cb_param_t *param) {
    // Pass the event to the application state machine handler
    bt_app_av_sm_handler(event, param);
}

// A2DP Sink audio data callback function
// This function is called when decoded PCM audio data is received from the A2DP Source.
static void bt_app_a2d_data_cb(const uint8_t *data, uint32_t len) {
    if (len == 0 || data == NULL) {
        return; // No data to process
    }

    size_t bytes_written = 0;
    // Write the received PCM data to the I2S peripheral for playback
    // The timeout (pdMS_TO_TICKS(100)) prevents indefinite blocking if I2S buffer is full.
    esp_err_t err = i2s_write(I2S_NUM, data, len, &bytes_written, pdMS_TO_TICKS(100));

    if (err != ESP_OK) {
        ESP_LOGE(TAG, "I2S write failed: %s", esp_err_to_name(err));
    }
    if (bytes_written < len) {
        // This indicates that the I2S buffer was full and not all data could be written.
        // This might lead to audio glitches (underrun at the DAC).
        ESP_LOGW(TAG, "I2S write underrun: wrote %u of %u bytes. Audio may be choppy.", (unsigned int)bytes_written, (unsigned int)len);
    }
}

// AVRCP Target (TG) callback function
// This function handles events related to remote control commands (e.g., play, pause, volume).
static void bt_app_rc_tg_cb(esp_avrc_tg_cb_event_t event, esp_avrc_tg_cb_param_t *param) {
    char peer_bda_str[18];
    switch (event) {
        case ESP_AVRC_TG_CONNECTION_STATE_EVT:
            ESP_LOGI(TAG, "AVRCP Target Connection State: %s, BDA: %s",
                     param->conn_stat.connected ? "Connected" : "Disconnected",
                     bda_to_str(param->conn_stat.remote_bda, peer_bda_str, sizeof(peer_bda_str)));
            // If disconnected, you might want to re-initialize or await new connection
            break;
        case ESP_AVRC_TG_PASSTHROUGH_CMD_EVT: // Received a passthrough command (e.g. play, pause)
            ESP_LOGI(TAG, "AVRCP Passthrough CMD: ID 0x%x, State %s",
                     param->pt_cmd.key_code,
                     (param->pt_cmd.key_state == ESP_AVRC_PT_CMD_STATE_PRESSED) ? "Pressed" : "Released");
            // Example: Handle PLAY command
            if (param->pt_cmd.key_code == ESP_AVRC_PT_CMD_PLAY && param->pt_cmd.key_state == ESP_AVRC_PT_CMD_STATE_PRESSED) {
                ESP_LOGI(TAG, "AVRCP PLAY command received.");
                // Application logic to resume audio if it was paused locally,
                // or inform the A2DP source if it's controlling the stream.
                // Note: A2DP audio start/stop is often controlled by ESP_A2D_AUDIO_STATE_EVT.
            }
            // Add handlers for other commands like PAUSE, STOP, NEXT, PREVIOUS, VOL_UP, VOL_DOWN
            break;
        case ESP_AVRC_TG_SET_ABSOLUTE_VOLUME_CMD_EVT: // Received an absolute volume command
            ESP_LOGI(TAG, "AVRCP Set Absolute Volume CMD: Volume %d (0-127)", param->set_abs_vol.volume);
            // Here, you would typically adjust the actual audio output volume.
            // This might involve software volume control on the PCM data or controlling an external amplifier.
            // For this example, we just log it.
            // Respond to the source that the volume command was processed.
            esp_avrc_tg_send_set_absolute_volume_rsp(param->set_abs_vol.idx, param->set_abs_vol.trans_label, param->set_abs_vol.volume);
            break;
        case ESP_AVRC_TG_REGISTER_NOTIFICATION_EVT: // Source registered for notifications
            ESP_LOGI(TAG, "AVRCP Register Notification: Event ID 0x%x, Param %d",
                     param->reg_ntf.event_id, param->reg_ntf.event_parameter);
            // Example: Handle playback status notification registration
            if (param->reg_ntf.event_id == ESP_AVRC_NID_PLAY_STATUS) {
                // Send initial response for playback status
                esp_avrc_playback_stat_t playback_status = (s_audio_state == ESP_A2D_AUDIO_STATE_STARTED) ? ESP_AVRC_PLAYBACK_PLAYING : ESP_AVRC_PLAYBACK_STOPPED;
                esp_avrc_tg_send_register_notification_rsp(param->reg_ntf.idx, ESP_AVRC_RSP_INTERIM, param->reg_ntf.trans_label,
                                                           param->reg_ntf.event_id, &playback_status);
            }
            break;
        // Add other AVRCP Target event handlers as needed (e.g., metadata requests)
        default:
            ESP_LOGD(TAG, "Unhandled AVRCP TG Event: %d", event);
            break;
    }
}

// Application state machine handler for A2DP and related events
static void bt_app_av_sm_handler(uint16_t event, void *param) {
    ESP_LOGD(TAG, "%s: Event 0x%x, Current AV State: %d, Audio State: %d",
             __func__, event, s_app_av_state, s_audio_state);

    char peer_bda_str[18]; // Buffer for peer BDA string

    switch (s_app_av_state) {
        case APP_AV_STATE_IDLE: // Initial state, typically transitions on stack up
        case APP_AV_STATE_UNCONNECTED:
            if (event == ESP_A2D_SINK_INIT_EVT) { // A2DP Sink profile initialized
                 if (((esp_a2d_sink_cb_param_t *)(param))->init_stat.status == ESP_A2D_INIT_SUCCESS) {
                    ESP_LOGI(TAG, "A2DP Sink initialized successfully.");
                    s_app_av_state = APP_AV_STATE_UNCONNECTED;
                    // Already set to discoverable/connectable in app_main
                } else {
                    ESP_LOGE(TAG, "A2DP Sink initialization failed, status: %d", ((esp_a2d_sink_cb_param_t *)(param))->init_stat.status);
                }
            } else if (event == ESP_A2D_CONNECTION_STATE_EVT) {
                esp_a2d_sink_cb_param_t *a2d_param = (esp_a2d_sink_cb_param_t *)(param);
                ESP_LOGI(TAG, "A2DP Connection State: %s, BDA: %s",
                         a2d_param->conn_stat.state == ESP_A2D_CONNECTION_STATE_CONNECTED ? "Connected" :
                         a2d_param->conn_stat.state == ESP_A2D_CONNECTION_STATE_CONNECTING ? "Connecting" :
                         a2d_param->conn_stat.state == ESP_A2D_CONNECTION_STATE_DISCONNECTED ? "Disconnected" : "Unknown",
                         bda_to_str(a2d_param->conn_stat.remote_bda, peer_bda_str, sizeof(peer_bda_str)));

                if (a2d_param->conn_stat.state == ESP_A2D_CONNECTION_STATE_CONNECTING) {
                    s_app_av_state = APP_AV_STATE_CONNECTING;
                    memcpy(s_peer_bda, a2d_param->conn_stat.remote_bda, ESP_BD_ADDR_LEN);
                } else if (a2d_param->conn_stat.state == ESP_A2D_CONNECTION_STATE_CONNECTED) {
                    s_app_av_state = APP_AV_STATE_CONNECTED;
                    memcpy(s_peer_bda, a2d_param->conn_stat.remote_bda, ESP_BD_ADDR_LEN);
                    ESP_LOGI(TAG, "Connected to: %s. Disabling GAP discoverability.", peer_bda_str);
                    esp_bt_gap_set_scan_mode(ESP_BT_NON_CONNECTABLE, ESP_BT_NON_DISCOVERABLE); // Optional: save power
                } else if (a2d_param->conn_stat.state == ESP_A2D_CONNECTION_STATE_DISCONNECTED) {
                    s_app_av_state = APP_AV_STATE_UNCONNECTED;
                    memset(s_peer_bda, 0, ESP_BD_ADDR_LEN); // Clear peer BDA
                    ESP_LOGI(TAG, "Disconnected. Setting GAP to connectable and discoverable.");
                    esp_bt_gap_set_scan_mode(ESP_BT_CONNECTABLE, ESP_BT_GENERAL_DISCOVERABLE);
                    if (s_audio_state == ESP_A2D_AUDIO_STATE_STARTED) { // If audio was playing, stop I2S
                        ESP_LOGI(TAG, "Audio was playing, stopping I2S due to disconnect.");
                        i2s_stop(I2S_NUM);
                        i2s_zero_dma_buffer(I2S_NUM);
                        s_audio_state = ESP_A2D_AUDIO_STATE_STOPPED;
                    }
                }
            }
            break;

        case APP_AV_STATE_CONNECTING:
            if (event == ESP_A2D_CONNECTION_STATE_EVT) {
                esp_a2d_sink_cb_param_t *a2d_param = (esp_a2d_sink_cb_param_t *)(param);
                ESP_LOGI(TAG, "A2DP Connection State (from connecting): %s, BDA: %s",
                         a2d_param->conn_stat.state == ESP_A2D_CONNECTION_STATE_CONNECTED ? "Connected" : "Disconnected",
                         bda_to_str(a2d_param->conn_stat.remote_bda, peer_bda_str, sizeof(peer_bda_str)));

                if (a2d_param->conn_stat.state == ESP_A2D_CONNECTION_STATE_CONNECTED) {
                    s_app_av_state = APP_AV_STATE_CONNECTED;
                    ESP_LOGI(TAG, "Connected to: %s. Disabling GAP discoverability.", peer_bda_str);
                    esp_bt_gap_set_scan_mode(ESP_BT_NON_CONNECTABLE, ESP_BT_NON_DISCOVERABLE);
                } else if (a2d_param->conn_stat.state == ESP_A2D_CONNECTION_STATE_DISCONNECTED) {
                    s_app_av_state = APP_AV_STATE_UNCONNECTED;
                    memset(s_peer_bda, 0, ESP_BD_ADDR_LEN);
                    ESP_LOGI(TAG, "Connection failed. Setting GAP to connectable and discoverable.");
                    esp_bt_gap_set_scan_mode(ESP_BT_CONNECTABLE, ESP_BT_GENERAL_DISCOVERABLE);
                }
            }
            break;

        case APP_AV_STATE_CONNECTED:
            if (event == ESP_A2D_CONNECTION_STATE_EVT) {
                esp_a2d_sink_cb_param_t *a2d_param = (esp_a2d_sink_cb_param_t *)(param);
                ESP_LOGI(TAG, "A2DP Connection State (from connected): %s",
                         a2d_param->conn_stat.state == ESP_A2D_CONNECTION_STATE_DISCONNECTED ? "Disconnected" : "Other");

                if (a2d_param->conn_stat.state == ESP_A2D_CONNECTION_STATE_DISCONNECTED) {
                    s_app_av_state = APP_AV_STATE_UNCONNECTED;
                    memset(s_peer_bda, 0, ESP_BD_ADDR_LEN);
                    ESP_LOGI(TAG, "Disconnected. Setting GAP to connectable and discoverable.");
                    esp_bt_gap_set_scan_mode(ESP_BT_CONNECTABLE, ESP_BT_GENERAL_DISCOVERABLE);
                    if (s_audio_state == ESP_A2D_AUDIO_STATE_STARTED) {
                        ESP_LOGI(TAG, "Audio was playing, stopping I2S due to disconnect.");
                        i2s_stop(I2S_NUM);
                        i2s_zero_dma_buffer(I2S_NUM);
                        s_audio_state = ESP_A2D_AUDIO_STATE_STOPPED;
                    }
                }
            } else if (event == ESP_A2D_AUDIO_STATE_EVT) {
                esp_a2d_sink_cb_param_t *a2d_param = (esp_a2d_sink_cb_param_t *)(param);
                ESP_LOGI(TAG, "A2DP Audio State: %s",
                         a2d_param->audio_stat.state == ESP_A2D_AUDIO_STATE_STARTED ? "Started" :
                         a2d_param->audio_stat.state == ESP_A2D_AUDIO_STATE_STOPPED ? "Stopped" :
                         a2d_param->audio_stat.state == ESP_A2D_AUDIO_STATE_REMOTE_SUSPEND ? "Remote Suspend" : "Unknown");
                s_audio_state = a2d_param->audio_stat.state;

                if (s_audio_state == ESP_A2D_AUDIO_STATE_STARTED) {
                    ESP_LOGI(TAG, "Audio streaming started. Starting I2S playback.");
                    i2s_start(I2S_NUM); // Start I2S DMA to play audio
                } else if (s_audio_state == ESP_A2D_AUDIO_STATE_STOPPED ||
                           s_audio_state == ESP_A2D_AUDIO_STATE_REMOTE_SUSPEND) {
                    ESP_LOGI(TAG, "Audio streaming stopped/suspended. Stopping I2S playback.");
                    i2s_stop(I2S_NUM);
                    i2s_zero_dma_buffer(I2S_NUM); // Clear any pending data in I2S buffer
                }
            } else if (event == ESP_A2D_AUDIO_CFG_EVT) {
                esp_a2d_sink_cb_param_t *a2d_param = (esp_a2d_sink_cb_param_t *)(param);
                ESP_LOGI(TAG, "A2DP Audio Configured: Codec: %s, Sample Rate: %d Hz, Channels: %d, Bits/Sample: %d",
                         (a2d_param->audio_cfg.mcc.type == ESP_A2D_MCT_SBC) ? "SBC" : "Other",
                         a2d_param->audio_cfg.mcc.sample_freq,
                         a2d_param->audio_cfg.mcc.channels,
                         a2d_param->audio_cfg.mcc.bits_per_sample);

                // Stop I2S if it was running with old config
                if (s_audio_state == ESP_A2D_AUDIO_STATE_STARTED) {
                    i2s_stop(I2S_NUM);
                    i2s_zero_dma_buffer(I2S_NUM);
                }
                
                // Reconfigure I2S clock based on the negotiated audio parameters
                uint32_t sample_rate = a2d_param->audio_cfg.mcc.sample_freq;
                uint8_t bits_per_sample_val = a2d_param->audio_cfg.mcc.bits_per_sample;
                uint8_t channels_val = a2d_param->audio_cfg.mcc.channels;

                // ESP-IDF A2DP sink decodes SBC to 16-bit PCM.
                // The bits_per_sample from mcc might be for SBC, not PCM.
                // For I2S, we typically use 16-bit.
                i2s_bits_per_sample_t i2s_bps = I2S_BITS_PER_SAMPLE_16BIT;
                if (bits_per_sample_val == ESP_A2D_BITS_PER_SAMPLE_24) {
                     // i2s_bps = I2S_BITS_PER_SAMPLE_24BIT; // If stack provides 24-bit PCM
                } else if (bits_per_sample_val == ESP_A2D_BITS_PER_SAMPLE_32) {
                     // i2s_bps = I2S_BITS_PER_SAMPLE_32BIT; // If stack provides 32-bit PCM
                }


                i2s_channel_t i2s_channels = (channels_val == ESP_A2D_CHANNEL_MODE_MONO) ? I2S_CHANNEL_MONO : I2S_CHANNEL_STEREO;

                esp_err_t clk_ret = i2s_set_clk(I2S_NUM, sample_rate, i2s_bps, i2s_channels);
                if (clk_ret == ESP_OK) {
                    ESP_LOGI(TAG, "I2S clock reconfigured to %d Hz, %d BPS, %s",
                             (int)sample_rate, (int)i2s_bps, (i2s_channels == I2S_CHANNEL_MONO) ? "Mono" : "Stereo");
                } else {
                    ESP_LOGE(TAG, "Failed to reconfigure I2S clock: %s", esp_err_to_name(clk_ret));
                }

                // If audio was playing, the source might send a START event again after reconfig.
                // Or, if it was suspended, it might remain so.
                // The ESP_A2D_AUDIO_STATE_EVT will handle restarting I2S if needed.
            }
            break;

        case APP_AV_STATE_DISCONNECTING: // Not explicitly used, handled by transitions from CONNECTED
            break;

        default:
            ESP_LOGE(TAG, "%s: Unhandled AV State %d with Event 0x%x", __func__, s_app_av_state, event);
            break;
    }
}