summaryrefslogtreecommitdiff
path: root/src/drivers/bluetooth.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/drivers/bluetooth.cpp')
-rw-r--r--src/drivers/bluetooth.cpp338
1 files changed, 196 insertions, 142 deletions
diff --git a/src/drivers/bluetooth.cpp b/src/drivers/bluetooth.cpp
index 412cba1f..2edf5ad9 100644
--- a/src/drivers/bluetooth.cpp
+++ b/src/drivers/bluetooth.cpp
@@ -4,6 +4,7 @@
#include <algorithm>
#include <atomic>
+#include <iterator>
#include <mutex>
#include <ostream>
#include <sstream>
@@ -113,92 +114,111 @@ IRAM_ATTR auto a2dp_data_cb(uint8_t* buf, int32_t buf_size) -> int32_t {
return buf_size;
}
-Bluetooth::Bluetooth(NvsStorage& storage, tasks::WorkerPool& bg_worker) {
+Bluetooth::Bluetooth(NvsStorage& storage,
+ tasks::WorkerPool& bg_worker,
+ EventHandler cb)
+ : nvs_(storage) {
sBgWorker = &bg_worker;
- bluetooth::BluetoothState::Init(storage);
+ bluetooth::BluetoothState::Init(storage, cb);
}
-auto Bluetooth::Enable() -> bool {
- auto lock = bluetooth::BluetoothState::lock();
- tinyfsm::FsmList<bluetooth::BluetoothState>::dispatch(
- bluetooth::events::Enable{});
+auto Bluetooth::enable(bool en) -> void {
+ if (en) {
+ auto lock = bluetooth::BluetoothState::lock();
+ tinyfsm::FsmList<bluetooth::BluetoothState>::dispatch(
+ bluetooth::events::Enable{});
+ } else {
+ // FIXME: the BT tasks unfortunately call back into us while holding an
+ // internal lock, which then deadlocks with our fsm lock.
+ // auto lock = bluetooth::BluetoothState::lock();
+ tinyfsm::FsmList<bluetooth::BluetoothState>::dispatch(
+ bluetooth::events::Disable{});
+ }
+}
+auto Bluetooth::enabled() -> bool {
+ auto lock = bluetooth::BluetoothState::lock();
return !bluetooth::BluetoothState::is_in_state<bluetooth::Disabled>();
}
-auto Bluetooth::Disable() -> void {
- // FIXME: the BT tasks unfortunately call back into us while holding an
- // internal lock, which then deadlocks with our fsm lock.
- // auto lock = bluetooth::BluetoothState::lock();
+auto Bluetooth::source(PcmBuffer* src) -> void {
+ if (src == sStream) {
+ return;
+ }
+ auto lock = bluetooth::BluetoothState::lock();
+ sStream = src;
tinyfsm::FsmList<bluetooth::BluetoothState>::dispatch(
- bluetooth::events::Disable{});
+ bluetooth::events::SourceChanged{});
}
-auto Bluetooth::IsEnabled() -> bool {
- auto lock = bluetooth::BluetoothState::lock();
- return !bluetooth::BluetoothState::is_in_state<bluetooth::Disabled>();
+auto Bluetooth::softVolume(float f) -> void {
+ sVolumeFactor = f;
}
-auto Bluetooth::IsConnected() -> bool {
+auto Bluetooth::connectionState() -> ConnectionState {
auto lock = bluetooth::BluetoothState::lock();
- return bluetooth::BluetoothState::is_in_state<bluetooth::Connected>();
+ if (bluetooth::BluetoothState::is_in_state<bluetooth::Connected>()) {
+ return ConnectionState::kConnected;
+ } else if (bluetooth::BluetoothState::is_in_state<bluetooth::Connecting>()) {
+ return ConnectionState::kConnecting;
+ }
+ return ConnectionState::kDisconnected;
}
-auto Bluetooth::ConnectedDevice() -> std::optional<bluetooth::MacAndName> {
+auto Bluetooth::pairedDevice() -> std::optional<bluetooth::MacAndName> {
auto lock = bluetooth::BluetoothState::lock();
- if (!bluetooth::BluetoothState::is_in_state<bluetooth::Connected>()) {
- return {};
- }
- return bluetooth::BluetoothState::preferred_device();
+ return bluetooth::BluetoothState::pairedDevice();
}
-auto Bluetooth::KnownDevices() -> std::vector<bluetooth::Device> {
+auto Bluetooth::pairedDevice(std::optional<bluetooth::MacAndName> dev) -> void {
auto lock = bluetooth::BluetoothState::lock();
- std::vector<bluetooth::Device> out = bluetooth::BluetoothState::devices();
- std::sort(out.begin(), out.end(), [](const auto& a, const auto& b) -> bool {
- return a.signal_strength < b.signal_strength;
- });
- return out;
+ bluetooth::BluetoothState::pairedDevice(dev);
}
-auto Bluetooth::SetPreferredDevice(std::optional<bluetooth::MacAndName> dev)
- -> void {
- auto lock = bluetooth::BluetoothState::lock();
- auto cur = bluetooth::BluetoothState::preferred_device();
- if (dev && cur && dev->mac == cur->mac) {
- return;
- }
- ESP_LOGI(kTag, "preferred is '%s' (%u%u%u%u%u%u)", dev->name.c_str(),
- dev->mac[0], dev->mac[1], dev->mac[2], dev->mac[3], dev->mac[4],
- dev->mac[5]);
- bluetooth::BluetoothState::preferred_device(dev);
- tinyfsm::FsmList<bluetooth::BluetoothState>::dispatch(
- bluetooth::events::PreferredDeviceChanged{});
+auto Bluetooth::knownDevices() -> std::vector<bluetooth::MacAndName> {
+ return nvs_.BluetoothNames();
}
-auto Bluetooth::PreferredDevice() -> std::optional<bluetooth::MacAndName> {
- auto lock = bluetooth::BluetoothState::lock();
- return bluetooth::BluetoothState::preferred_device();
+auto Bluetooth::forgetKnownDevice(const bluetooth::mac_addr_t& mac) -> void {
+ nvs_.BluetoothName(mac, {});
}
-auto Bluetooth::SetSource(PcmBuffer* src) -> void {
+auto Bluetooth::discoveryEnabled(bool en) -> void {
auto lock = bluetooth::BluetoothState::lock();
- if (src == bluetooth::BluetoothState::source()) {
- return;
- }
- bluetooth::BluetoothState::source(src);
- tinyfsm::FsmList<bluetooth::BluetoothState>::dispatch(
- bluetooth::events::SourceChanged{});
+ bluetooth::BluetoothState::discovery(en);
}
-auto Bluetooth::SetVolumeFactor(float f) -> void {
- sVolumeFactor = f;
+auto Bluetooth::discoveryEnabled() -> bool {
+ auto lock = bluetooth::BluetoothState::lock();
+ return bluetooth::BluetoothState::discovery();
}
-auto Bluetooth::SetEventHandler(std::function<void(bluetooth::Event)> cb)
- -> void {
- auto lock = bluetooth::BluetoothState::lock();
- bluetooth::BluetoothState::event_handler(cb);
+auto Bluetooth::discoveredDevices() -> std::vector<bluetooth::MacAndName> {
+ std::vector<bluetooth::Device> discovered;
+ {
+ auto lock = bluetooth::BluetoothState::lock();
+ discovered = bluetooth::BluetoothState::discoveredDevices();
+ }
+
+ // Show devices with stronger signals first, since they're more likely to be
+ // physically close (and therefore more likely to be what the user wants).
+ std::sort(discovered.begin(), discovered.end(),
+ [](const auto& a, const auto& b) -> bool {
+ return a.signal_strength < b.signal_strength;
+ });
+
+ // Convert to the right format.
+ std::vector<bluetooth::MacAndName> out;
+ out.reserve(discovered.size());
+ std::transform(discovered.begin(), discovered.end(), std::back_inserter(out),
+ [&](const bluetooth::Device& dev) {
+ return bluetooth::MacAndName{
+ .mac = dev.address,
+ .name = {dev.name.data(), dev.name.size()},
+ };
+ });
+
+ return out;
}
static auto DeviceName() -> std::pmr::string {
@@ -251,6 +271,10 @@ auto Scanner::StopScanningNow() -> void {
}
}
+auto Scanner::enabled() -> bool {
+ return enabled_;
+}
+
auto Scanner::HandleGapEvent(const events::internal::Gap& ev) -> void {
switch (ev.type) {
case ESP_BT_GAP_DISC_RES_EVT:
@@ -343,17 +367,18 @@ NvsStorage* BluetoothState::sStorage_;
Scanner* BluetoothState::sScanner_;
std::mutex BluetoothState::sFsmMutex{};
-std::map<mac_addr_t, Device> BluetoothState::sDevices_{};
-std::optional<MacAndName> BluetoothState::sPreferredDevice_{};
-std::optional<MacAndName> BluetoothState::sConnectingDevice_{};
+std::map<mac_addr_t, Device> BluetoothState::sDiscoveredDevices_{};
+std::optional<MacAndName> BluetoothState::sPairedWith_{};
+std::optional<MacAndName> BluetoothState::sConnectingTo_{};
int BluetoothState::sConnectAttemptsRemaining_{0};
-std::atomic<PcmBuffer*> BluetoothState::sSource_;
std::function<void(Event)> BluetoothState::sEventHandler_;
-auto BluetoothState::Init(NvsStorage& storage) -> void {
+auto BluetoothState::Init(NvsStorage& storage, Bluetooth::EventHandler cb)
+ -> void {
sStorage_ = &storage;
- sPreferredDevice_ = storage.PreferredBluetoothDevice();
+ sEventHandler_ = cb;
+ sPairedWith_ = storage.PreferredBluetoothDevice();
tinyfsm::FsmList<bluetooth::BluetoothState>::start();
}
@@ -361,68 +386,85 @@ auto BluetoothState::lock() -> std::lock_guard<std::mutex> {
return std::lock_guard<std::mutex>{sFsmMutex};
}
-auto BluetoothState::devices() -> std::vector<Device> {
- std::vector<Device> out;
- for (const auto& device : sDevices_) {
- out.push_back(device.second);
- }
- return out;
+auto BluetoothState::pairedDevice() -> std::optional<MacAndName> {
+ return sPairedWith_;
}
-auto BluetoothState::preferred_device() -> std::optional<MacAndName> {
- return sPreferredDevice_;
-}
+auto BluetoothState::pairedDevice(std::optional<MacAndName> dev) -> void {
+ auto cur = sPairedWith_;
+ if (dev && cur && dev->mac == cur->mac) {
+ return;
+ }
+ if (dev) {
+ ESP_LOGI(kTag, "pairing with '%s' (%u%u%u%u%u%u)", dev->name.c_str(),
+ dev->mac[0], dev->mac[1], dev->mac[2], dev->mac[3], dev->mac[4],
+ dev->mac[5]);
+ }
+ sPairedWith_ = dev;
+ std::invoke(sEventHandler_, SimpleEvent::kDeviceDiscovered);
-auto BluetoothState::preferred_device(std::optional<MacAndName> addr) -> void {
- sPreferredDevice_ = addr;
+ tinyfsm::FsmList<bluetooth::BluetoothState>::dispatch(
+ bluetooth::events::PairedDeviceChanged{});
}
-auto BluetoothState::source() -> PcmBuffer* {
- return sSource_.load();
+auto BluetoothState::discovery() -> bool {
+ return sScanner_->enabled();
}
-auto BluetoothState::source(PcmBuffer* src) -> void {
- sSource_.store(src);
+auto BluetoothState::discovery(bool en) -> void {
+ if (en) {
+ if (!sScanner_->enabled()) {
+ sDiscoveredDevices_.clear();
+ }
+ sScanner_->ScanContinuously();
+ } else {
+ sScanner_->StopScanning();
+ }
}
-auto BluetoothState::event_handler(std::function<void(Event)> cb) -> void {
- sEventHandler_ = cb;
+auto BluetoothState::discoveredDevices() -> std::vector<Device> {
+ std::vector<Device> out;
+ for (const auto& device : sDiscoveredDevices_) {
+ out.push_back(device.second);
+ }
+ return out;
}
auto BluetoothState::react(const events::DeviceDiscovered& ev) -> void {
- bool is_preferred = false;
- bool already_known = sDevices_.contains(ev.device.address);
- sDevices_[ev.device.address] = ev.device;
+ bool is_paired = false;
+ bool already_known = sDiscoveredDevices_.contains(ev.device.address);
+ sDiscoveredDevices_[ev.device.address] = ev.device;
- if (sPreferredDevice_ && ev.device.address == sPreferredDevice_->mac) {
- is_preferred = true;
+ if (sPairedWith_ && ev.device.address == sPairedWith_->mac) {
+ is_paired = true;
}
- if (sEventHandler_ && !already_known) {
- std::invoke(sEventHandler_, SimpleEvent::kKnownDevicesChanged);
+ if (!already_known) {
+ std::invoke(sEventHandler_, SimpleEvent::kDeviceDiscovered);
}
- if (is_preferred && sPreferredDevice_) {
- connect(*sPreferredDevice_);
+ if (is_paired && sPairedWith_) {
+ connect(*sPairedWith_);
}
}
auto BluetoothState::connect(const MacAndName& dev) -> bool {
- if (sConnectingDevice_ && sConnectingDevice_->mac == dev.mac) {
+ if (sConnectingTo_ && sConnectingTo_->mac == dev.mac) {
sConnectAttemptsRemaining_--;
} else {
sConnectAttemptsRemaining_ = 3;
}
if (sConnectAttemptsRemaining_ == 0) {
+ sConnectingTo_ = {};
return false;
}
- sConnectingDevice_ = dev;
+ sConnectingTo_ = dev;
ESP_LOGI(kTag, "connecting to '%s' (%u%u%u%u%u%u)", dev.name.c_str(),
dev.mac[0], dev.mac[1], dev.mac[2], dev.mac[3], dev.mac[4],
dev.mac[5]);
- if (esp_a2d_source_connect(sConnectingDevice_->mac.data()) != ESP_OK) {
+ if (esp_a2d_source_connect(sConnectingTo_->mac.data()) != ESP_OK) {
ESP_LOGI(kTag, "Connecting failed...");
if (sConnectAttemptsRemaining_ > 1) {
ESP_LOGI(kTag, "Will retry.");
@@ -508,11 +550,13 @@ void Disabled::react(const events::Enable&) {
// AVRCP Target
err = esp_avrc_tg_init();
if (err != ESP_OK) {
- ESP_LOGE(kTag, "Error during target init: %s %d", esp_err_to_name(err), err);
+ ESP_LOGE(kTag, "Error during target init: %s %d", esp_err_to_name(err),
+ err);
}
err = esp_avrc_tg_register_callback(avrcp_tg_cb);
if (err != ESP_OK) {
- ESP_LOGE(kTag, "Error registering AVRC tg callback: %s %d", esp_err_to_name(err), err);
+ ESP_LOGE(kTag, "Error registering AVRC tg callback: %s %d",
+ esp_err_to_name(err), err);
}
// Set the supported passthrough commands on the tg
@@ -522,19 +566,20 @@ void Disabled::react(const events::Enable&) {
do {
// Sleep for a bit
vTaskDelay(pdMS_TO_TICKS(10));
- err = esp_avrc_tg_get_psth_cmd_filter(ESP_AVRC_PSTH_FILTER_ALLOWED_CMD, &psth);
+ err = esp_avrc_tg_get_psth_cmd_filter(ESP_AVRC_PSTH_FILTER_ALLOWED_CMD,
+ &psth);
} while (err != ESP_OK);
- err = esp_avrc_tg_set_psth_cmd_filter(ESP_AVRC_PSTH_FILTER_SUPPORTED_CMD, &psth);
+ err = esp_avrc_tg_set_psth_cmd_filter(ESP_AVRC_PSTH_FILTER_SUPPORTED_CMD,
+ &psth);
if (err != ESP_OK) {
ESP_LOGE(kTag, "Error: %s %d", esp_err_to_name(err), err);
}
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);
+ ESP_AVRC_RN_VOLUME_CHANGE);
assert(esp_avrc_tg_set_rn_evt_cap(&evt_set) == ESP_OK);
-
// Initialise A2DP. This handles streaming audio. Currently ESP-IDF's SBC
// encoder only supports 2 channels of interleaved 16 bit samples, at
// 44.1kHz, so there is no additional configuration to be done for the
@@ -547,37 +592,27 @@ void Disabled::react(const events::Enable&) {
esp_bt_gap_set_scan_mode(ESP_BT_NON_CONNECTABLE, ESP_BT_NON_DISCOVERABLE);
ESP_LOGI(kTag, "bt enabled");
- if (sPreferredDevice_) {
- ESP_LOGI(kTag, "connecting to preferred device '%s'",
- sPreferredDevice_->name.c_str());
- connect(*sPreferredDevice_);
+ if (sPairedWith_) {
+ ESP_LOGI(kTag, "connecting to paired device '%s'",
+ sPairedWith_->name.c_str());
+ connect(*sPairedWith_);
} else {
- ESP_LOGI(kTag, "scanning for devices");
transit<Idle>();
}
}
void Idle::entry() {
ESP_LOGI(kTag, "bt is idle");
- sScanner_->ScanContinuously();
}
-void Idle::exit() {
- sScanner_->StopScanning();
-}
+void Idle::exit() {}
void Idle::react(const events::Disable& ev) {
transit<Disabled>();
}
-void Idle::react(const events::PreferredDeviceChanged& ev) {
- bool is_discovered = false;
- if (sPreferredDevice_ && sDevices_.contains(sPreferredDevice_->mac)) {
- is_discovered = true;
- }
- if (is_discovered) {
- connect(*sPreferredDevice_);
- }
+void Idle::react(const events::PairedDeviceChanged& ev) {
+ connect(*sPairedWith_);
}
void Idle::react(events::internal::Gap ev) {
@@ -599,7 +634,6 @@ void Connecting::entry() {
timeoutCallback);
xTimerStart(sTimeoutTimer, portMAX_DELAY);
- sScanner_->StopScanning();
if (sEventHandler_) {
std::invoke(sEventHandler_, SimpleEvent::kConnectionStateChanged);
}
@@ -615,19 +649,24 @@ void Connecting::exit() {
void Connecting::react(const events::ConnectTimedOut& ev) {
ESP_LOGI(kTag, "timed out awaiting connection");
- esp_a2d_source_disconnect(sConnectingDevice_->mac.data());
- if (!connect(*sConnectingDevice_)) {
+ esp_a2d_source_disconnect(sConnectingTo_->mac.data());
+ if (!connect(*sConnectingTo_)) {
transit<Idle>();
}
}
void Connecting::react(const events::Disable& ev) {
- // TODO: disconnect gracefully
+ esp_a2d_source_disconnect(sConnectingTo_->mac.data());
transit<Disabled>();
}
-void Connecting::react(const events::PreferredDeviceChanged& ev) {
- // TODO. Cancel out and start again.
+void Connecting::react(const events::PairedDeviceChanged& ev) {
+ esp_a2d_source_disconnect(sConnectingTo_->mac.data());
+ if (sPairedWith_) {
+ connect(*sPairedWith_);
+ } else {
+ transit<Idle>();
+ }
}
void Connecting::react(events::internal::Gap ev) {
@@ -698,15 +737,20 @@ void Connected::entry() {
ESP_LOGI(kTag, "entering connected state");
transaction_num_ = 0;
- connected_to_ = sConnectingDevice_->mac;
- sPreferredDevice_ = sConnectingDevice_;
- sConnectingDevice_ = {};
+ connected_to_ = sConnectingTo_->mac;
+ sPairedWith_ = sConnectingTo_;
+
+ sStorage_->BluetoothName(sConnectingTo_->mac, sConnectingTo_->name);
+ std::invoke(sEventHandler_, SimpleEvent::kKnownDevicesChanged);
+
+ sConnectingTo_ = {};
auto stored_pref = sStorage_->PreferredBluetoothDevice();
- if (!stored_pref || (sPreferredDevice_->name != stored_pref->name ||
- sPreferredDevice_->mac != stored_pref->mac)) {
- sStorage_->PreferredBluetoothDevice(sPreferredDevice_);
+ if (!stored_pref || (sPairedWith_->name != stored_pref->name ||
+ sPairedWith_->mac != stored_pref->mac)) {
+ sStorage_->PreferredBluetoothDevice(sPairedWith_);
}
+
// TODO: if we already have a source, immediately start playing
}
@@ -719,13 +763,11 @@ void Connected::react(const events::Disable& ev) {
transit<Disabled>();
}
-void Connected::react(const events::PreferredDeviceChanged& ev) {
- sConnectingDevice_ = sPreferredDevice_;
- transit<Connecting>();
+void Connected::react(const events::PairedDeviceChanged& ev) {
+ transit<Idle>();
}
void Connected::react(const events::SourceChanged& ev) {
- sStream = sSource_;
if (sStream != nullptr) {
ESP_LOGI(kTag, "checking source is ready");
esp_a2d_media_ctrl(ESP_A2D_MEDIA_CTRL_CHECK_SRC_RDY);
@@ -775,7 +817,8 @@ void Connected::react(events::internal::Avrc ev) {
switch (ev.type) {
case ESP_AVRC_CT_CONNECTION_STATE_EVT:
if (ev.param.conn_stat.connected) {
- auto err = esp_avrc_ct_send_register_notification_cmd(4, ESP_AVRC_RN_VOLUME_CHANGE, 0);
+ auto err = esp_avrc_ct_send_register_notification_cmd(
+ 4, ESP_AVRC_RN_VOLUME_CHANGE, 0);
if (err != ESP_OK) {
ESP_LOGE(kTag, "Error: %s %d", esp_err_to_name(err), err);
}
@@ -787,15 +830,20 @@ void Connected::react(events::internal::Avrc ev) {
case ESP_AVRC_CT_REMOTE_FEATURES_EVT:
// The remote device is telling us about its capabilities! We don't
// currently care about any of them.
- ESP_LOGI(kTag, "Recieved capabilitites: %lu", ev.param.rmt_feats.feat_mask);
+ ESP_LOGI(kTag, "Recieved capabilitites: %lu",
+ ev.param.rmt_feats.feat_mask);
break;
case ESP_AVRC_CT_CHANGE_NOTIFY_EVT:
if (ev.param.change_ntf.event_id == ESP_AVRC_RN_VOLUME_CHANGE) {
if (sEventHandler_) {
- std::invoke(sEventHandler_, bluetooth::RemoteVolumeChanged{.new_vol = ev.param.change_ntf.event_parameter.volume});
+ std::invoke(
+ sEventHandler_,
+ bluetooth::RemoteVolumeChanged{
+ .new_vol = ev.param.change_ntf.event_parameter.volume});
}
// Resubscribe to volume facts
- auto err = esp_avrc_ct_send_register_notification_cmd(4, ESP_AVRC_RN_VOLUME_CHANGE, 0);
+ auto err = esp_avrc_ct_send_register_notification_cmd(
+ 4, ESP_AVRC_RN_VOLUME_CHANGE, 0);
if (err != ESP_OK) {
ESP_LOGE(kTag, "Error: %s %d", esp_err_to_name(err), err);
}
@@ -809,16 +857,20 @@ void Connected::react(events::internal::Avrc ev) {
void Connected::react(const events::internal::Avrctg ev) {
switch (ev.type) {
case ESP_AVRC_TG_CONNECTION_STATE_EVT:
- ESP_LOGI(kTag, "Got connection event. Connected: %s", ev.param.conn_stat.connected ? "true" : "false");
+ ESP_LOGI(kTag, "Got connection event. Connected: %s",
+ ev.param.conn_stat.connected ? "true" : "false");
if (ev.param.conn_stat.connected) {
}
break;
case ESP_AVRC_TG_REMOTE_FEATURES_EVT:
- ESP_LOGI(kTag, "Got remote features feat flag %d", ev.param.rmt_feats.ct_feat_flag);
- ESP_LOGI(kTag, "Got remote features feat mask %lu", ev.param.rmt_feats.feat_mask);
+ ESP_LOGI(kTag, "Got remote features feat flag %d",
+ ev.param.rmt_feats.ct_feat_flag);
+ ESP_LOGI(kTag, "Got remote features feat mask %lu",
+ ev.param.rmt_feats.feat_mask);
break;
case ESP_AVRC_TG_PASSTHROUGH_CMD_EVT:
- ESP_LOGI(kTag, "Got passthrough event keycode: %x, %d", ev.param.psth_cmd.key_code, ev.param.psth_cmd.key_state);
+ ESP_LOGI(kTag, "Got passthrough event keycode: %x, %d",
+ ev.param.psth_cmd.key_code, ev.param.psth_cmd.key_state);
if (ev.param.psth_cmd.key_state == 1 && sEventHandler_) {
switch (ev.param.psth_cmd.key_code) {
case ESP_AVRC_PT_CMD_PLAY:
@@ -840,7 +892,8 @@ void Connected::react(const events::internal::Avrctg ev) {
std::invoke(sEventHandler_, bluetooth::SimpleEvent::kBackward);
break;
default:
- ESP_LOGI(kTag, "Unhandled passthrough cmd. Key code: %d", ev.param.psth_cmd.key_code);
+ ESP_LOGI(kTag, "Unhandled passthrough cmd. Key code: %d",
+ ev.param.psth_cmd.key_code);
}
}
break;
@@ -848,14 +901,15 @@ void Connected::react(const events::internal::Avrctg ev) {
if (ev.param.reg_ntf.event_id == ESP_AVRC_RN_VOLUME_CHANGE) {
// TODO: actually do this lol
esp_avrc_rn_param_t rn_param;
- rn_param.volume = 64;
+ rn_param.volume = 64;
auto err = esp_avrc_tg_send_rn_rsp(ESP_AVRC_RN_VOLUME_CHANGE,
- ESP_AVRC_RN_RSP_INTERIM, &rn_param);
+ ESP_AVRC_RN_RSP_INTERIM, &rn_param);
if (err != ESP_OK) {
ESP_LOGE(kTag, "Error: %s %d", esp_err_to_name(err), err);
}
} else {
- ESP_LOGW(kTag, "unhandled AVRC TG Register Notification event: %u", ev.param.reg_ntf.event_id);
+ ESP_LOGW(kTag, "unhandled AVRC TG Register Notification event: %u",
+ ev.param.reg_ntf.event_id);
}
break;
}
generated by cgit v1.2.3 (git 2.25.1) at 2026-04-29 16:59:45 +0000