Mirror/squeezelite-esp32
1
0
Fork 0
mirror of https://github.com/sle118/squeezelite-esp32.git synced 2025-12-11 22:17:17 +03:00
Code Issues Packages Projects Releases Wiki Activity

Start of 5.X work

Browse Source
This commit is contained in:
Sebastien L
2025-03-18 17:38:34 -04:00
parent c0ddf0a997
commit 73bd096f37
442 changed files with 227862 additions and 21075 deletions
Download Patch File Download Diff File Expand all files Collapse all files

113
components/driver_bt/bt_app_core.c
View File

@@ -6,31 +6,31 @@
CONDITIONS OF ANY KIND, either express or implied.
*/
#include <stdint.h>
#include <string.h>
#include <stdbool.h>
#include "bt_app_core.h"
#include "esp_bt.h"
#include "esp_bt_main.h"
#include "esp_gap_bt_api.h"
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "freertos/task.h"
#include "esp_bt.h"
#include "esp_bt_main.h"
#include "esp_gap_bt_api.h"
#include "bt_app_core.h"
#include "tools.h"
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
static const char *TAG = "btappcore";
static const char* TAG = "btappcore";
static void bt_app_task_handler(void *arg);
static bool bt_app_send_msg(bt_app_msg_t *msg);
static void bt_app_work_dispatched(bt_app_msg_t *msg);
static void bt_app_task_handler(void* arg);
static bool bt_app_send_msg(bt_app_msg_t* msg);
static void bt_app_work_dispatched(bt_app_msg_t* msg);
static xQueueHandle s_bt_app_task_queue;
static bool running;
bool bt_app_work_dispatch(bt_app_cb_t p_cback, uint16_t event, void *p_params, int param_len, bt_app_copy_cb_t p_copy_cback)
{
ESP_LOGV(TAG,"%s event 0x%x, param len %d", __func__, event, param_len);
bool bt_app_work_dispatch(bt_app_cb_t p_cback, uint16_t event, void* p_params, int param_len,
bt_app_copy_cb_t p_copy_cback) {
ESP_LOGV(TAG, "%s event 0x%x, param len %d", __func__, event, param_len);
bt_app_msg_t msg;
memset(&msg, 0, sizeof(bt_app_msg_t));
@@ -54,36 +54,33 @@ bool bt_app_work_dispatch(bt_app_cb_t p_cback, uint16_t event, void *p_params, i
return false;
}
static bool bt_app_send_msg(bt_app_msg_t *msg)
{
static bool bt_app_send_msg(bt_app_msg_t* msg) {
if (msg == NULL) {
return false;
}
if (xQueueSend(s_bt_app_task_queue, msg, 10 / portTICK_RATE_MS) != pdTRUE) {
ESP_LOGE(TAG,"%s xQueue send failed", __func__);
ESP_LOGE(TAG, "%s xQueue send failed", __func__);
return false;
}
return true;
}
static void bt_app_work_dispatched(bt_app_msg_t *msg)
{
static void bt_app_work_dispatched(bt_app_msg_t* msg) {
if (msg->cb) {
msg->cb(msg->event, msg->param);
}
}
static void bt_app_task_handler(void *arg)
{
static void bt_app_task_handler(void* arg) {
bt_app_msg_t msg;
esp_err_t err;
s_bt_app_task_queue = xQueueCreate(10, sizeof(bt_app_msg_t));
esp_bt_controller_mem_release(ESP_BT_MODE_BLE);
esp_err_t err;
s_bt_app_task_queue = xQueueCreate(10, sizeof(bt_app_msg_t));
esp_bt_controller_mem_release(ESP_BT_MODE_BLE);
esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
if (esp_bt_controller_get_status() == ESP_BT_CONTROLLER_STATUS_IDLE ) {
if (esp_bt_controller_get_status() == ESP_BT_CONTROLLER_STATUS_IDLE) {
if ((err = esp_bt_controller_init(&bt_cfg)) != ESP_OK) {
ESP_LOGE(TAG, "%s initialize controller failed: %s\n", __func__, esp_err_to_name(err));
goto exit;
@@ -104,17 +101,16 @@ static void bt_app_task_handler(void *arg)
goto exit;
}
}
/* Bluetooth device name, connection mode and profile set up */
bt_app_work_dispatch((bt_av_hdl_stack_evt_t*) arg, BT_APP_EVT_STACK_UP, NULL, 0, NULL);
/* Bluetooth device name, connection mode and profile set up */
bt_app_work_dispatch((bt_av_hdl_stack_evt_t*)arg, BT_APP_EVT_STACK_UP, NULL, 0, NULL);
#if (CONFIG_BT_SSP_ENABLED)
/* Set default parameters for Secure Simple Pairing */
esp_bt_sp_param_t param_type = ESP_BT_SP_IOCAP_MODE;
esp_bt_io_cap_t iocap = ESP_BT_IO_CAP_IO;
esp_bt_gap_set_security_param(param_type, &iocap, sizeof(uint8_t));
#endif
/*
* Set default parameters for Legacy Pairing
* Use variable pin, input pin code when pairing
@@ -122,19 +118,19 @@ static void bt_app_task_handler(void *arg)
esp_bt_pin_type_t pin_type = ESP_BT_PIN_TYPE_VARIABLE;
esp_bt_pin_code_t pin_code;
esp_bt_gap_set_pin(pin_type, 0, pin_code);
running = true;
while (running) {
running = true;
while (running) {
if (pdTRUE == xQueueReceive(s_bt_app_task_queue, &msg, (portTickType)portMAX_DELAY)) {
ESP_LOGV(TAG,"%s, sig 0x%x, 0x%x", __func__, msg.sig, msg.event);
ESP_LOGV(TAG, "%s, sig 0x%x, 0x%x", __func__, msg.sig, msg.event);
switch (msg.sig) {
case BT_APP_SIG_WORK_DISPATCH:
bt_app_work_dispatched(&msg);
break;
default:
ESP_LOGW(TAG,"%s, unhandled sig: %d", __func__, msg.sig);
ESP_LOGW(TAG, "%s, unhandled sig: %d", __func__, msg.sig);
break;
}
@@ -142,40 +138,37 @@ static void bt_app_task_handler(void *arg)
free(msg.param);
}
} else {
ESP_LOGW(TAG,"No messaged received from queue.");
ESP_LOGW(TAG, "No messaged received from queue.");
}
}
ESP_LOGD(TAG, "bt_app_task shutting down");
if (esp_bluedroid_disable() != ESP_OK) goto exit;
// this disable has a sleep timer BTA_DISABLE_DELAY in bt_target.h and
// if we don't wait for it then disable crashes... don't know why
vTaskDelay(2*200 / portTICK_PERIOD_MS);
ESP_LOGD(TAG, "bt_app_task shutting down");
if (esp_bluedroid_disable() != ESP_OK) goto exit;
// this disable has a sleep timer BTA_DISABLE_DELAY in bt_target.h and
// if we don't wait for it then disable crashes... don't know why
vTaskDelay(2 * 200 / portTICK_PERIOD_MS);
ESP_LOGD(TAG, "esp_bluedroid_disable called successfully");
if (esp_bluedroid_deinit() != ESP_OK) goto exit;
ESP_LOGD(TAG, "esp_bluedroid_deinit called successfully");
if (esp_bt_controller_disable() != ESP_OK) goto exit;
ESP_LOGD(TAG, "esp_bt_controller_disable called successfully");
if (esp_bt_controller_deinit() != ESP_OK) goto exit;
ESP_LOGD(TAG, "bt stopped successfully");
ESP_LOGD(TAG, "bt stopped successfully");
exit:
vQueueDelete(s_bt_app_task_queue);
running = false;
vQueueDelete(s_bt_app_task_queue);
running = false;
vTaskDelete(NULL);
}
void bt_app_task_start_up(bt_av_hdl_stack_evt_t* handler)
{
void bt_app_task_start_up(bt_av_hdl_stack_evt_t* handler) {
xTaskCreate(bt_app_task_handler, "BtAppT", 4096, handler, configMAX_PRIORITIES - 3, NULL);
}
void bt_app_task_shut_down(void)
{
running = false;
}
void bt_app_task_shut_down(void) { running = false; }

37
components/driver_bt/bt_app_core.h
View File

@@ -8,53 +8,58 @@
#ifndef __BT_APP_CORE_H__
#define __BT_APP_CORE_H__
#include "Status.pb.h"
#include "esp_log.h"
#include "time.h"
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "Status.pb.h"
#define BT_APP_CORE_TAG "BT_APP_CORE"
#define BT_APP_SIG_WORK_DISPATCH (0x01)
#ifdef __cplusplus
extern "C" {
#endif
#define BT_APP_CORE_TAG "BT_APP_CORE"
#define BT_APP_SIG_WORK_DISPATCH (0x01)
enum {
BT_APP_EVT_STACK_UP = 0,
};
extern sys_AV_STATE bt_app_source_get_a2d_state();
extern sys_MEDIA_STATE bt_app_source_get_media_state();
extern sys_status_av_states bt_app_source_get_a2d_state();
extern sys_status_media_states bt_app_source_get_media_state();
/**
* @brief handler for the dispatched work
*/
typedef void (* bt_app_cb_t) (uint16_t event, void *param);
typedef void (*bt_app_cb_t)(uint16_t event, void* param);
/* message to be sent */
typedef struct {
uint16_t sig; /*!< signal to bt_app_task */
uint16_t event; /*!< message event id */
bt_app_cb_t cb; /*!< context switch callback */
void *param; /*!< parameter area needs to be last */
uint16_t sig; /*!< signal to bt_app_task */
uint16_t event; /*!< message event id */
bt_app_cb_t cb; /*!< context switch callback */
void* param; /*!< parameter area needs to be last */
} bt_app_msg_t;
/**
* @brief parameter deep-copy function to be customized
*/
typedef void (* bt_app_copy_cb_t) (bt_app_msg_t *msg, void *p_dest, void *p_src);
typedef void (*bt_app_copy_cb_t)(bt_app_msg_t* msg, void* p_dest, void* p_src);
/**
* @brief callback for startup event
*/
typedef void bt_av_hdl_stack_evt_t(uint16_t event, void *p_param);
typedef void bt_av_hdl_stack_evt_t(uint16_t event, void* p_param);
/**
* @brief work dispatcher for the application task
*/
bool bt_app_work_dispatch(bt_app_cb_t p_cback, uint16_t event, void *p_params, int param_len, bt_app_copy_cb_t p_copy_cback);
bool bt_app_work_dispatch(bt_app_cb_t p_cback, uint16_t event, void* p_params, int param_len,
bt_app_copy_cb_t p_copy_cback);
void bt_app_task_start_up(bt_av_hdl_stack_evt_t* handler);
void bt_app_task_shut_down(void);
#endif /* __BT_APP_CORE_H__ */
#ifdef __cplusplus
}
#endif

12
components/driver_bt/bt_app_sink.c
View File

@@ -21,7 +21,7 @@
#include "esp_gap_bt_api.h"
#include "esp_a2dp_api.h"
#include "esp_avrc_api.h"
#include "Configurator.h"
#include "Config.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "tools.h"
@@ -45,7 +45,6 @@ static const char BT_RC_CT_TAG[] = "RCCT";
#define CONFIG_BT_NAME "ESP32-BT"
#endif
static char * bt_name = NULL;
static bool (*bt_app_a2d_cmd_cb)(bt_sink_cmd_t cmd, ...);
static void (*bt_app_a2d_data_cb)(const uint8_t *data, uint32_t len);
@@ -511,7 +510,7 @@ static void volume_set_by_local_host(int value, bool is_step)
_lock_release(&s_volume_lock);
if(sys_state->bt_sink_volume != s_volume){
sys_state->bt_sink_volume = s_volume;
configurator_raise_state_changed();
config_raise_state_changed();
}
if (s_volume_notify) {
@@ -567,8 +566,8 @@ void bt_sink_init(bt_cmd_vcb_t cmd_cb, bt_data_cb_t data_cb)
bt_app_a2d_cmd_cb = cmd_handler;
cmd_handler_chain = cmd_cb;
bt_app_a2d_data_cb = data_cb;
sys_BluetoothSink * bt_sink;
if(!SYS_SERVICES_BTSINK(bt_sink)){
sys_services_bt_sink * bt_sink;
if(!sys_services_config_BTSINK(bt_sink)){
return;
}
char pin_code[ESP_BT_PIN_CODE_LEN+1] = "1234\0";
@@ -583,7 +582,7 @@ void bt_sink_init(bt_cmd_vcb_t cmd_cb, bt_data_cb_t data_cb)
*/
esp_bt_pin_type_t pin_type = ESP_BT_PIN_TYPE_FIXED;
strncpy(pin_code,bt_sink->pin,sizeof(pin_code));
if(SYS_SERVICES_BTSINK(bt_sink) && strlen(bt_sink->pin)>ESP_BT_PIN_CODE_LEN){
if( strlen(bt_sink->pin)>ESP_BT_PIN_CODE_LEN){
ESP_LOGW(BT_AV_TAG, "BT Sink pin code [%s] too long. ", bt_sink->pin);
pin_code[ESP_BT_PIN_CODE_LEN] = '\0';
@@ -606,7 +605,6 @@ void bt_sink_init(bt_cmd_vcb_t cmd_cb, bt_data_cb_t data_cb)
if (bError) memcpy(esp_pin_code, "1234", 4);
esp_bt_gap_set_pin(pin_type, strlen(pin_code), esp_pin_code);
free(pin_code);
}
void bt_sink_deinit(void)

141
components/driver_bt/bt_app_source.c
View File

@@ -20,8 +20,10 @@
#include "cJSON.h"
#include "tools.h"
#include "accessors.h"
#include "Configurator.h"
#include "Config.h"
#include "Status.pb.h"
#include "bootstate.h"
static const char * TAG = "bt_app_source";
static const char * BT_RC_CT_TAG="RCCT";
@@ -31,11 +33,12 @@ extern void output_bt_stop(void);
extern void output_bt_start(void);
extern char* output_state_str(void);
extern bool output_stopped(void);
extern bool is_recovery_running;
extern sys_squeezelite_config* get_profile(const char* name);
static void bt_app_av_state_connecting(uint16_t event, void *param);
static void filter_inquiry_scan_result(esp_bt_gap_cb_param_t *param);
sys_OutputBT * out_bt = NULL;
sys_squeezelite_bt * out_bt = NULL;
#define BT_APP_HEART_BEAT_EVT (0xff00)
@@ -76,8 +79,8 @@ static void bt_av_notify_evt_handler(uint8_t event_id, esp_avrc_rn_param_t *even
static esp_bd_addr_t s_peer_bda = {0};
static uint8_t s_peer_bdname[ESP_BT_GAP_MAX_BDNAME_LEN + 1];
sys_AV_STATE bt_app_source_a2d_state = sys_AV_STATE_A_IDLE;
sys_MEDIA_STATE bt_app_source_media_state = sys_MEDIA_STATE_M_IDLE;
sys_status_av_states bt_app_source_a2d_state = sys_status_av_states_A_IDLE;
sys_status_media_states bt_app_source_media_state = sys_status_media_states_M_IDLE;
static uint32_t s_pkt_cnt = 0;
static TimerHandle_t s_tmr=NULL;
static int prev_duration=10000;
@@ -175,23 +178,23 @@ static void peers_list_maintain(const char * s_peer_bdname, int32_t rssi){
}
}
sys_AV_STATE bt_app_source_get_a2d_state(){
sys_status_av_states bt_app_source_get_a2d_state(){
if(!is_recovery_running){
// if we are in recovery mode, don't log BT status
ESP_LOGD(TAG,"a2dp status: %u = %s", bt_app_source_a2d_state, sys_AV_STATE_name(bt_app_source_a2d_state));
ESP_LOGD(TAG,"a2dp status: %u = %s", bt_app_source_a2d_state, sys_status_av_states_name(bt_app_source_a2d_state));
}
return bt_app_source_a2d_state;
}
sys_MEDIA_STATE bt_app_source_get_media_state(){
ESP_LOGD(TAG,"media state : %s ", sys_MEDIA_STATE_name(bt_app_source_media_state));
sys_status_media_states bt_app_source_get_media_state(){
ESP_LOGD(TAG,"media state : %s ", sys_status_media_states_name(bt_app_source_media_state));
return bt_app_source_media_state;
}
void set_app_source_state(int new_state){
if(bt_app_source_a2d_state!=new_state){
ESP_LOGD(TAG, "Updating state from %s to %s", sys_AV_STATE_name(bt_app_source_a2d_state), sys_AV_STATE_name(new_state));
ESP_LOGD(TAG, "Updating state from %s to %s", sys_status_av_states_name(bt_app_source_a2d_state), sys_status_av_states_name(new_state));
bt_app_source_a2d_state=new_state;
}
}
@@ -202,39 +205,37 @@ void set_a2dp_media_state(int new_state){
}
}
void hal_bluetooth_init()
{
if(!ASSIGN_COND_VAL_3LVL(services,squeezelite,output_bt,out_bt) ){
ESP_LOGD(TAG,"Bluetooth not configured");
void hal_bluetooth_init() {
sys_squeezelite_config* config = get_profile(NULL); // get the active profile
sys_squeezelite_bt* out_bt = (config && config->has_output_bt) ? &config->output_bt : NULL;
if (!out_bt) {
ESP_LOGD(TAG, "Bluetooth not configured");
return;
}
if(strlen(out_bt->sink_name) == 0){
ESP_LOGE(TAG,"Sink name not configured!");
if (strlen(out_bt->sink_name) == 0) {
ESP_LOGE(TAG, "Sink name not configured!");
return;
}
ESP_LOGD(TAG,"Initializing bluetooth sink");
ESP_LOGD(TAG, "Initializing bluetooth sink");
// create task and run event loop
// create task and run event loop
bt_app_task_start_up(bt_av_hdl_stack_evt);
/*
* Set default parameters for Legacy Pairing
* Use variable pin, input pin code when pairing
*/
esp_bt_pin_type_t pin_type = ESP_BT_PIN_TYPE_VARIABLE;
/*
* Set default parameters for Legacy Pairing
* Use variable pin, input pin code when pairing
*/
esp_bt_pin_type_t pin_type = ESP_BT_PIN_TYPE_VARIABLE;
uint8_t pin_code_len;
uint8_t *pin_code;
if(strlen(out_bt->pin) == 0){
pin_code = (uint8_t *)"0000";
uint8_t* pin_code;
if (strlen(out_bt->pin) == 0) {
pin_code = (uint8_t*)"0000";
pin_code_len = 4;
}
else {
pin_code = (uint8_t *) out_bt->pin;
} else {
pin_code = (uint8_t*)out_bt->pin;
pin_code_len = strlen(out_bt->pin);
}
esp_bt_gap_set_pin(pin_type, pin_code_len,pin_code);
esp_bt_gap_set_pin(pin_type, pin_code_len, pin_code);
}
void hal_bluetooth_stop(void) {
@@ -301,8 +302,8 @@ static void bt_app_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *pa
if (param->disc_st_chg.state == ESP_BT_GAP_DISCOVERY_STOPPED) {
peers_list_maintain(NULL, PEERS_LIST_MAINTAIN_PURGE);
if (bt_app_source_a2d_state == sys_AV_STATE_A_DISCOVERED) {
set_app_source_state(sys_AV_STATE_A_CONNECTING);
if (bt_app_source_a2d_state == sys_status_av_states_A_DISCOVERED) {
set_app_source_state(sys_status_av_states_A_CONNECTING);
ESP_LOGI(TAG,"Discovery completed. Ready to start connecting to %s. ", s_peer_bdname);
esp_a2d_source_connect(s_peer_bda);
} else {
@@ -403,7 +404,7 @@ static const char * conn_state_str(esp_a2d_connection_state_t state){
static void unexpected_connection_state(int from, esp_a2d_connection_state_t to)
{
ESP_LOGW(TAG,"Unexpected connection state change. App State: %s (%u) Connection State %s (%u)", sys_AV_STATE_name(from), from,conn_state_str(to), to);
ESP_LOGW(TAG,"Unexpected connection state change. App State: %s (%u) Connection State %s (%u)", sys_status_av_states_name(from), from,conn_state_str(to), to);
}
static void handle_connect_state_unconnected(uint16_t event, esp_a2d_cb_param_t *param){
@@ -444,20 +445,20 @@ static void handle_connect_state_connecting(uint16_t event, esp_a2d_cb_param_t *
else {
ESP_LOGW(TAG,"A2DP connect unsuccessful");
}
set_app_source_state(sys_AV_STATE_A_UNCONNECTED);
set_app_source_state(sys_status_av_states_A_UNCONNECTED);
break;
case ESP_A2D_CONNECTION_STATE_CONNECTING:
break;
case ESP_A2D_CONNECTION_STATE_CONNECTED:
set_app_source_state(sys_AV_STATE_A_CONNECTED);
set_a2dp_media_state(sys_MEDIA_STATE_M_IDLE);
set_app_source_state(sys_status_av_states_A_CONNECTED);
set_a2dp_media_state(sys_status_media_states_M_IDLE);
ESP_LOGD(TAG,"Setting scan mode to ESP_BT_NON_CONNECTABLE, ESP_BT_NON_DISCOVERABLE");
esp_bt_gap_set_scan_mode(ESP_BT_NON_CONNECTABLE, ESP_BT_NON_DISCOVERABLE);
ESP_LOGD(TAG,"Done setting scan mode. App state is now CONNECTED and media state IDLE.");
break;
case ESP_A2D_CONNECTION_STATE_DISCONNECTING:
unexpected_connection_state(bt_app_source_a2d_state, param->conn_stat.state);
set_app_source_state(sys_AV_STATE_A_CONNECTING);
set_app_source_state(sys_status_av_states_A_CONNECTING);
break;
default:
break;
@@ -469,7 +470,7 @@ static void handle_connect_state_connected(uint16_t event, esp_a2d_cb_param_t *p
{
case ESP_A2D_CONNECTION_STATE_DISCONNECTED:
ESP_LOGW(TAG,"a2dp disconnected");
set_app_source_state(sys_AV_STATE_A_UNCONNECTED);
set_app_source_state(sys_status_av_states_A_UNCONNECTED);
esp_bt_gap_set_scan_mode(ESP_BT_CONNECTABLE, ESP_BT_GENERAL_DISCOVERABLE);
break;
case ESP_A2D_CONNECTION_STATE_CONNECTING:
@@ -479,7 +480,7 @@ static void handle_connect_state_connected(uint16_t event, esp_a2d_cb_param_t *p
unexpected_connection_state(bt_app_source_a2d_state, param->conn_stat.state);
break;
case ESP_A2D_CONNECTION_STATE_DISCONNECTING:
set_app_source_state(sys_AV_STATE_A_DISCONNECTING);
set_app_source_state(sys_status_av_states_A_DISCONNECTING);
break;
default:
@@ -493,7 +494,7 @@ static void handle_connect_state_disconnecting(uint16_t event, esp_a2d_cb_param_
{
case ESP_A2D_CONNECTION_STATE_DISCONNECTED:
ESP_LOGI(TAG,"a2dp disconnected");
set_app_source_state(sys_AV_STATE_A_UNCONNECTED);
set_app_source_state(sys_status_av_states_A_UNCONNECTED);
esp_bt_gap_set_scan_mode(ESP_BT_CONNECTABLE, ESP_BT_GENERAL_DISCOVERABLE);
break;
case ESP_A2D_CONNECTION_STATE_CONNECTING:
@@ -513,24 +514,24 @@ static void handle_connect_state_disconnecting(uint16_t event, esp_a2d_cb_param_
static void bt_app_av_sm_hdlr(uint16_t event, void *param)
{
ESP_LOGV(TAG,"bt_app_av_sm_hdlr.%s a2d state: %s", event==BT_APP_HEART_BEAT_EVT?"Heart Beat.":"",sys_AV_STATE_name(bt_app_source_a2d_state));
ESP_LOGV(TAG,"bt_app_av_sm_hdlr.%s a2d state: %s", event==BT_APP_HEART_BEAT_EVT?"Heart Beat.":"",sys_status_av_states_name(bt_app_source_a2d_state));
switch (bt_app_source_a2d_state) {
case sys_AV_STATE_A_DISCOVERING:
ESP_LOGV(TAG,"state %s, evt 0x%x, output state: %s", sys_AV_STATE_name(bt_app_source_a2d_state), event, output_state_str());
case sys_status_av_states_A_DISCOVERING:
ESP_LOGV(TAG,"state %s, evt 0x%x, output state: %s", sys_status_av_states_name(bt_app_source_a2d_state), event, output_state_str());
break;
case sys_AV_STATE_A_DISCOVERED:
ESP_LOGV(TAG,"state %s, evt 0x%x, output state: %s", sys_AV_STATE_name(bt_app_source_a2d_state), event, output_state_str());
case sys_status_av_states_A_DISCOVERED:
ESP_LOGV(TAG,"state %s, evt 0x%x, output state: %s", sys_status_av_states_name(bt_app_source_a2d_state), event, output_state_str());
break;
case sys_AV_STATE_A_UNCONNECTED:
case sys_status_av_states_A_UNCONNECTED:
bt_app_av_state_unconnected(event, param);
break;
case sys_AV_STATE_A_CONNECTING:
case sys_status_av_states_A_CONNECTING:
bt_app_av_state_connecting(event, param);
break;
case sys_AV_STATE_A_CONNECTED:
case sys_status_av_states_A_CONNECTED:
bt_app_av_state_connected(event, param);
break;
case sys_AV_STATE_A_DISCONNECTING:
case sys_status_av_states_A_DISCONNECTING:
bt_app_av_state_disconnecting(event, param);
break;
default:
@@ -591,7 +592,7 @@ static void filter_inquiry_scan_result(esp_bt_gap_cb_param_t *param)
uint8_t nameLen = 0;
esp_bt_gap_dev_prop_t *p;
memset(bda_str, 0x00, sizeof(bda_str));
if(bt_app_source_a2d_state != sys_AV_STATE_A_DISCOVERING)
if(bt_app_source_a2d_state != sys_status_av_states_A_DISCOVERING)
{
// Ignore messages that might have been queued already
// when we've discovered the target device.
@@ -650,7 +651,7 @@ static void filter_inquiry_scan_result(esp_bt_gap_cb_param_t *param)
if (squeezelite_conf.sink_name && strlen(squeezelite_conf.sink_name) >0 && strcmp((char *)s_peer_bdname, squeezelite_conf.sink_name) == 0) {
ESP_LOGI(TAG,"Found our target device. address %s, name %s", bda_str, s_peer_bdname);
memcpy(s_peer_bda, param->disc_res.bda, ESP_BD_ADDR_LEN);
set_app_source_state(sys_AV_STATE_A_DISCOVERED);
set_app_source_state(sys_status_av_states_A_DISCOVERED);
esp_bt_gap_cancel_discovery();
} else {
ESP_LOGV(TAG,"Not the device we are looking for (%s). Continuing scan", squeezelite_conf.sink_name?squeezelite_conf.sink_name:"N/A");
@@ -698,7 +699,7 @@ static void bt_av_hdl_stack_evt(uint16_t event, void *p_param)
/* start device discovery */
ESP_LOGI(TAG,"Starting device discovery...");
set_app_source_state(sys_AV_STATE_A_DISCOVERING);
set_app_source_state(sys_status_av_states_A_DISCOVERING);
esp_bt_gap_start_discovery(ESP_BT_INQ_MODE_GENERAL_INQUIRY, 10, 0);
/* create and start heart beat timer */
@@ -722,7 +723,7 @@ static void bt_app_rc_ct_cb(esp_avrc_ct_cb_event_t event, esp_avrc_ct_cb_param_t
case ESP_AVRC_CT_REMOTE_FEATURES_EVT:
case ESP_AVRC_CT_GET_RN_CAPABILITIES_RSP_EVT:
case ESP_AVRC_CT_SET_ABSOLUTE_VOLUME_RSP_EVT: {
ESP_LOGD(TAG,"Received %s message", sys_ESP_AVRC_CT_name(event));
ESP_LOGD(TAG,"Received %s message", sys_status_avrc_ct_name(event));
bt_app_work_dispatch(bt_av_hdl_avrc_ct_evt, event, param, sizeof(esp_avrc_ct_cb_param_t), NULL);
break;
}
@@ -735,7 +736,7 @@ static void bt_app_av_media_proc(uint16_t event, void *param)
{
esp_a2d_cb_param_t *a2d = NULL;
switch (bt_app_source_media_state) {
case sys_MEDIA_STATE_M_IDLE: {
case sys_status_media_states_M_IDLE: {
if (event == BT_APP_HEART_BEAT_EVT) {
if(!output_stopped())
{
@@ -749,34 +750,34 @@ static void bt_app_av_media_proc(uint16_t event, void *param)
a2d->media_ctrl_stat.status == ESP_A2D_MEDIA_CTRL_ACK_SUCCESS
) {
ESP_LOGI(TAG,"a2dp media ready, starting playback!");
set_a2dp_media_state(sys_MEDIA_STATE_M_STARTING);
set_a2dp_media_state(sys_status_media_states_M_STARTING);
esp_a2d_media_ctrl(ESP_A2D_MEDIA_CTRL_START);
}
}
break;
}
case sys_MEDIA_STATE_M_STARTING: {
case sys_status_media_states_M_STARTING: {
if (event == ESP_A2D_MEDIA_CTRL_ACK_EVT) {
a2d = (esp_a2d_cb_param_t *)(param);
if (a2d->media_ctrl_stat.cmd == ESP_A2D_MEDIA_CTRL_START &&
a2d->media_ctrl_stat.status == ESP_A2D_MEDIA_CTRL_ACK_SUCCESS) {
ESP_LOGI(TAG,"a2dp media started successfully.");
output_bt_start();
set_a2dp_media_state(sys_MEDIA_STATE_M_STARTED);
set_a2dp_media_state(sys_status_media_states_M_STARTED);
} else {
// not started succesfully, transfer to idle state
ESP_LOGI(TAG,"a2dp media start failed.");
set_a2dp_media_state(sys_MEDIA_STATE_M_IDLE);
set_a2dp_media_state(sys_status_media_states_M_IDLE);
}
}
break;
}
case sys_MEDIA_STATE_M_STARTED: {
case sys_status_media_states_M_STARTED: {
if (event == BT_APP_HEART_BEAT_EVT) {
if(output_stopped()) {
ESP_LOGI(TAG,"Output state is %s. Stopping a2dp media ...", output_state_str());
set_a2dp_media_state(sys_MEDIA_STATE_M_STOPPING);
set_a2dp_media_state(sys_status_media_states_M_STOPPING);
esp_a2d_media_ctrl(ESP_A2D_MEDIA_CTRL_STOP);
} else {
output_bt_tick();
@@ -784,15 +785,15 @@ static void bt_app_av_media_proc(uint16_t event, void *param)
}
break;
}
case sys_MEDIA_STATE_M_STOPPING: {
ESP_LOG_DEBUG_EVENT(TAG,QUOTE(sys_MEDIA_STATE_M_STOPPING));
case sys_status_media_states_M_STOPPING: {
ESP_LOG_DEBUG_EVENT(TAG,QUOTE(sys_status_media_states_M_STOPPING));
if (event == ESP_A2D_MEDIA_CTRL_ACK_EVT) {
a2d = (esp_a2d_cb_param_t *)(param);
if (a2d->media_ctrl_stat.cmd == ESP_A2D_MEDIA_CTRL_STOP &&
a2d->media_ctrl_stat.status == ESP_A2D_MEDIA_CTRL_ACK_SUCCESS) {
ESP_LOGI(TAG,"a2dp media stopped successfully...");
output_bt_stop();
set_a2dp_media_state(sys_MEDIA_STATE_M_IDLE);
set_a2dp_media_state(sys_status_media_states_M_IDLE);
} else {
ESP_LOGI(TAG,"a2dp media stopping...");
esp_a2d_media_ctrl(ESP_A2D_MEDIA_CTRL_STOP);
@@ -801,9 +802,9 @@ static void bt_app_av_media_proc(uint16_t event, void *param)
break;
}
case sys_MEDIA_STATE_M_WAIT_DISCONNECT:{
case sys_status_media_states_M_WAIT_DISCONNECT:{
esp_a2d_source_disconnect(s_peer_bda);
set_app_source_state(sys_AV_STATE_A_DISCONNECTING);
set_app_source_state(sys_status_av_states_A_DISCONNECTING);
ESP_LOGI(TAG,"a2dp disconnecting...");
}
}
@@ -843,11 +844,11 @@ static void bt_app_av_state_unconnected(uint16_t event, void *param)
uint8_t *p = s_peer_bda;
ESP_LOGI(TAG, "a2dp connecting to %s, BT peer: %02x:%02x:%02x:%02x:%02x:%02x",s_peer_bdname,p[0], p[1], p[2], p[3], p[4], p[5]);
if(esp_a2d_source_connect(s_peer_bda)==ESP_OK) {
set_app_source_state(sys_AV_STATE_A_CONNECTING);
set_app_source_state(sys_status_av_states_A_CONNECTING);
s_connecting_intv = 0;
}
else {
set_app_source_state(sys_AV_STATE_A_UNCONNECTED);
set_app_source_state(sys_status_av_states_A_UNCONNECTED);
// there was an issue connecting... continue to discover
ESP_LOGE(TAG,"Attempt at connecting failed, restart at discover...");
esp_bt_gap_start_discovery(ESP_BT_INQ_MODE_GENERAL_INQUIRY, 10, 0);
@@ -877,7 +878,7 @@ static void bt_app_av_state_connecting(uint16_t event, void *param)
break;
case BT_APP_HEART_BEAT_EVT:
if (++s_connecting_intv >= 2) {
set_app_source_state(sys_AV_STATE_A_UNCONNECTED);
set_app_source_state(sys_status_av_states_A_UNCONNECTED);
ESP_LOGW(TAG,"A2DP Connect time out! Setting state to Unconnected. ");
s_connecting_intv = 0;
}