From 0df08b169047942f5b15f767fd8d99bb563e6198 Mon Sep 17 00:00:00 2001 From: klu339 Date: Tue, 31 Mar 2026 14:45:46 +0000 Subject: [PATCH 01/12] RDKEMW-15315: T2 RCU pairing --- src/ble/ctrlm_ble_network.cpp | 72 ++++++++++++ src/ble/ctrlm_ble_network.h | 18 +++ src/ble/ctrlm_ble_rcu_interface.cpp | 6 + src/ble/ctrlm_ble_rcu_interface.h | 5 + src/ble/hal/blercu/blercuadapter.h | 4 +- src/ble/hal/blercu/blercucontroller.cpp | 51 ++++++++ src/ble/hal/blercu/blercucontroller.h | 18 +++ src/ble/hal/blercu/blercudevice.h | 5 +- .../hal/blercu/blercupairingstatemachine.cpp | 109 +++++++++++++++++- .../hal/blercu/blercupairingstatemachine.h | 45 +++++++- src/ble/hal/blercu/bluez/blercuadapter.cpp | 10 +- src/ble/hal/blercu/bluez/blercuadapter_p.h | 2 +- src/ble/hal/blercu/bluez/blercudevice.cpp | 3 +- src/ctrlm_tr181.h | 3 +- src/telemetry/ctrlm_telemetry.cpp | 9 +- src/telemetry/ctrlm_telemetry.h | 3 +- src/telemetry/ctrlm_telemetry_markers.h | 22 ++++ 17 files changed, 360 insertions(+), 25 deletions(-) diff --git a/src/ble/ctrlm_ble_network.cpp b/src/ble/ctrlm_ble_network.cpp index 57cdb6da..0db0c39d 100644 --- a/src/ble/ctrlm_ble_network.cpp +++ b/src/ble/ctrlm_ble_network.cpp @@ -47,6 +47,7 @@ #include #include #include "ctrlm_rcp_ipc_iarm_thunder.h" +#include "ctrlm_telemetry.h" using namespace std; @@ -370,6 +371,9 @@ ctrlm_hal_result_t ctrlm_obj_network_ble_t::hal_init_request(GThread *ctrlm_main ble_rcu_interface_->addRcuKeypressHandler(Slot(is_alive_, std::bind(&ctrlm_obj_network_ble_t::ind_keypress, this, std::placeholders::_1))); + ble_rcu_interface_->addRcuPairingOutcomeHandler(Slot(is_alive_, + std::bind(&ctrlm_obj_network_ble_t::ind_rcu_pairing_outcome, this, std::placeholders::_1))); + ble_rcu_interface_->startKeyMonitorThread(); @@ -1657,6 +1661,74 @@ void ctrlm_obj_network_ble_t::req_process_unpair(void *data, int size) { // BEGIN - Process Indications from HAL to the network in CTRLM Main thread context // ------------------------------------------------------------------------------------------------------------------------------------------------------------------ +void ctrlm_obj_network_ble_t::ind_rcu_pairing_outcome(const BleRcuPairingOutcome &outcome) { + // Queue to the ctrlm main thread for duration computation and telemetry emission + auto copy = std::make_shared(outcome); + ctrlm_main_queue_handler_push_new( + CTRLM_HANDLER_NETWORK, + (ctrlm_msg_handler_network_t)&ctrlm_obj_network_ble_t::ind_process_rcu_pairing_outcome, + copy, + NULL, + id_); +} + +void ctrlm_obj_network_ble_t::ind_process_rcu_pairing_outcome(void *data, int size) { + THREAD_ID_VALIDATE(); + const BleRcuPairingOutcome *outcome = static_cast(data); + if (!outcome) { + XLOGD_ERROR("pairing outcome data is NULL"); + return; + } + + ctrlm_ble_pair_attempt_t attempt; + attempt.method = outcome->method; + attempt.result = outcome->result; + attempt.discovered = outcome->discovered; + attempt.bluez_retries = outcome->bluezRetries; + attempt.paired_mac = outcome->pairedMac; + attempt.error_msg = outcome->bluezError; + + XLOGD_INFO("BLE pairing attempt complete: method=%s result=%s paired_mac=%s " + "bluez_retries=%d bluez_msg=%s discovered=%zu", + attempt.method.c_str(), attempt.result.c_str(), attempt.paired_mac.c_str(), + attempt.bluez_retries, attempt.error_msg.c_str(), attempt.discovered.size()); + +#ifdef TELEMETRY_SUPPORT + // Serialize to JSON compatible with the ctrlm.ble.pairing.attempt T2 marker + json_t *jroot = json_object(); + if (jroot) { + json_object_set_new(jroot, "version", json_integer(MARKER_RCU_PAIRING_ATTEMPT_VERSION)); + json_object_set_new(jroot, "method", json_string(attempt.method.c_str())); + json_object_set_new(jroot, "result", json_string(attempt.result.c_str())); + json_object_set_new(jroot, "paired_mac", json_string(attempt.paired_mac.c_str())); + json_object_set_new(jroot, "bluez_retries", json_integer(attempt.bluez_retries)); + json_object_set_new(jroot, "bluez_msg", json_string(attempt.error_msg.c_str())); + + json_t *jdiscovered = json_array(); + if (jdiscovered) { + for (const auto &dev : attempt.discovered) { + json_t *jdev = json_object(); + if (jdev) { + json_object_set_new(jdev, "mac", json_string(dev.first.c_str())); + json_object_set_new(jdev, "name", json_string(dev.second.c_str())); + json_array_append_new(jdiscovered, jdev); + } + } + json_object_set_new(jroot, "discovered", jdiscovered); + } + + char *json_str = json_dumps(jroot, JSON_COMPACT); + XLOGD_WARN("KLU339 %s", json_str); + if (json_str) { + ctrlm_telemetry_event_t ev(MARKER_RCU_PAIRING_ATTEMPT, std::string(json_str)); + ctrlm_telemetry_t::get_instance()->event(ctrlm_telemetry_report_t::RCU, ev); + free(json_str); + } + json_decref(jroot); + } +#endif // TELEMETRY_SUPPORT +} + void ctrlm_obj_network_ble_t::ind_rcu_status(ctrlm_hal_ble_RcuStatusData_t *params) { // push to the main queue and process it synchronously there diff --git a/src/ble/ctrlm_ble_network.h b/src/ble/ctrlm_ble_network.h index 1182889a..c0702980 100644 --- a/src/ble/ctrlm_ble_network.h +++ b/src/ble/ctrlm_ble_network.h @@ -92,6 +92,22 @@ typedef struct { } ctrlm_ble_upgrade_image_info_t; +/////////////////////////////////////////////////////////////////////////////////////////// + +/** + * @brief BLE RCU Pairing Attempt Metrics + * + * Aggregates the outcome of a single BLE pairing attempt for telemetry emission. + */ +struct ctrlm_ble_pair_attempt_t { + std::string method; // pairing method string (auto_timeout, ir_code, mac_hash, mac_list) + std::string result; // "success" or failure reason string + std::vector> discovered; // {mac_str, was_paired} + int bluez_retries; + std::string paired_mac; // empty on failure + std::string error_msg; +}; + /////////////////////////////////////////////////////////////////////////////////////////// /** @@ -134,11 +150,13 @@ class ctrlm_obj_network_ble_t : public ctrlm_obj_network_t { void ind_rcu_paired(ctrlm_hal_ble_IndPaired_params_t *params); void ind_rcu_unpaired(ctrlm_hal_ble_IndUnPaired_params_t *params); void ind_keypress(ctrlm_hal_ble_IndKeypress_params_t *params); + void ind_rcu_pairing_outcome(const BleRcuPairingOutcome &outcome); void ind_process_rcu_status(void *data, int size); void ind_process_paired(void *data, int size); void ind_process_unpaired(void *data, int size); void ind_process_keypress(void *data, int size); + void ind_process_rcu_pairing_outcome(void *data, int size); virtual void req_process_network_status(void *data, int size); virtual void req_process_controller_status(void *data, int size); diff --git a/src/ble/ctrlm_ble_rcu_interface.cpp b/src/ble/ctrlm_ble_rcu_interface.cpp index f90cdc67..8d1d0e1a 100644 --- a/src/ble/ctrlm_ble_rcu_interface.cpp +++ b/src/ble/ctrlm_ble_rcu_interface.cpp @@ -185,6 +185,12 @@ void ctrlm_ble_rcu_interface_t::initialize() m_rcuUnpairedSlots.invoke(¶ms); }; m_controller->addManagedDeviceRemovedSlot(Slot(m_isAlive, deviceRemovedSlot)); + + auto pairingOutcomeSlot = [this](const BleRcuPairingOutcome &outcome) + { + m_rcuPairingOutcomeSlots.invoke(outcome); + }; + m_controller->addPairingOutcomeSlot(Slot(m_isAlive, pairingOutcomeSlot)); } voice_params_par_t params; diff --git a/src/ble/ctrlm_ble_rcu_interface.h b/src/ble/ctrlm_ble_rcu_interface.h index c9209c6f..e29c7fc8 100644 --- a/src/ble/ctrlm_ble_rcu_interface.h +++ b/src/ble/ctrlm_ble_rcu_interface.h @@ -145,12 +145,17 @@ class ctrlm_ble_rcu_interface_t { m_rcuKeypressSlots.addSlot(func); } + inline void addRcuPairingOutcomeHandler(const Slot &func) + { + m_rcuPairingOutcomeSlots.addSlot(func); + } Slots m_rcuStatusChangedSlots; Slots m_rcuPairedSlots; Slots m_rcuUnpairedSlots; Slots m_rcuKeypressSlots; + Slots m_rcuPairingOutcomeSlots; private: std::shared_ptr m_isAlive; diff --git a/src/ble/hal/blercu/blercuadapter.h b/src/ble/hal/blercu/blercuadapter.h index cd9fc9e8..d795acb8 100644 --- a/src/ble/hal/blercu/blercuadapter.h +++ b/src/ble/hal/blercu/blercuadapter.h @@ -107,7 +107,7 @@ class BleRcuAdapter { m_deviceNameChangedSlots.addSlot(func); } - inline void addDevicePairingErrorSlot(const Slot &func) + inline void addDevicePairingErrorSlot(const Slot &func) { m_devicePairingErrorSlots.addSlot(func); } @@ -135,7 +135,7 @@ class BleRcuAdapter Slots m_deviceFoundSlots; Slots m_deviceRemovedSlots; Slots m_deviceNameChangedSlots; - Slots m_devicePairingErrorSlots; + Slots m_devicePairingErrorSlots; Slots m_devicePairingChangedSlots; Slots m_deviceReadyChangedSlots; diff --git a/src/ble/hal/blercu/blercucontroller.cpp b/src/ble/hal/blercu/blercucontroller.cpp index 9924c9df..3f8fac7b 100644 --- a/src/ble/hal/blercu/blercucontroller.cpp +++ b/src/ble/hal/blercu/blercucontroller.cpp @@ -41,6 +41,34 @@ using namespace std; +static const char* pairingMethodStr(BleRcuPairingStateMachine::PairingMethod m) +{ + switch (m) { + case BleRcuPairingStateMachine::AUTO_TIMEOUT: return "auto_timeout"; + case BleRcuPairingStateMachine::MAC_LIST: return "mac_list"; + case BleRcuPairingStateMachine::IR_CODE: return "ir_code"; + case BleRcuPairingStateMachine::MAC_HASH: return "mac_hash"; + default: return "unknown"; + } +} + +static const char* failureReasonStr(BleRcuPairingStateMachine::FailureReason r) +{ + switch (r) { + case BleRcuPairingStateMachine::SUCCESS: return "success"; + case BleRcuPairingStateMachine::FAIL_DISCOVERY_TIMEOUT: return "discovery_timeout"; + case BleRcuPairingStateMachine::FAIL_DISCOVERY_STOPPED: return "discovery_stopped"; + case BleRcuPairingStateMachine::FAIL_DISCOVERY_STOP_TIMEOUT:return "discovery_stop_timeout"; + case BleRcuPairingStateMachine::FAIL_PAIRING_TIMEOUT: return "pairing_timeout"; + case BleRcuPairingStateMachine::FAIL_BLUEZ_ERROR: return "bluez_error"; + case BleRcuPairingStateMachine::FAIL_ADAPTER_OFF: return "adapter_off"; + case BleRcuPairingStateMachine::FAIL_DEVICE_UNPAIRED: return "device_unpaired"; + case BleRcuPairingStateMachine::FAIL_DEVICE_REMOVED: return "device_removed"; + case BleRcuPairingStateMachine::FAIL_CANCELLED: return "cancelled"; + default: return "unknown"; + } +} + class BleRcuController_userdata { public: @@ -607,6 +635,17 @@ void BleRcuControllerImpl::onFinishedPairing() m_state = Complete; m_stateChangedSlots.invoke(m_state); + + // emit pairing outcome telemetry + BleRcuPairingOutcome outcome; + outcome.method = pairingMethodStr(m_pairingStateMachine.pairingMethod()); + outcome.result = failureReasonStr(BleRcuPairingStateMachine::SUCCESS); + outcome.bluezRetries = m_pairingStateMachine.bluezRetries(); + outcome.pairedMac = m_pairingStateMachine.pairedMac().toString(); + for (const auto &dev : m_pairingStateMachine.discoveredDevices()) { + outcome.discovered.emplace_back(dev.mac.toString(), dev.name); + } + m_pairingOutcomeSlots.invoke(outcome); } // ----------------------------------------------------------------------------- @@ -646,6 +685,18 @@ void BleRcuControllerImpl::onFailedPairing() m_state = Failed; m_stateChangedSlots.invoke(m_state); + + // emit pairing outcome telemetry + BleRcuPairingOutcome outcome; + outcome.method = pairingMethodStr(m_pairingStateMachine.pairingMethod()); + outcome.result = failureReasonStr(m_pairingStateMachine.failureReason()); + outcome.bluezRetries = m_pairingStateMachine.bluezRetries(); + outcome.pairedMac = m_pairingStateMachine.pairedMac().toString(); + outcome.bluezError = m_pairingStateMachine.bluezError(); + for (const auto &dev : m_pairingStateMachine.discoveredDevices()) { + outcome.discovered.emplace_back(dev.mac.toString(), dev.name); + } + m_pairingOutcomeSlots.invoke(outcome); } diff --git a/src/ble/hal/blercu/blercucontroller.h b/src/ble/hal/blercu/blercucontroller.h index 770d4d07..b54b3b28 100644 --- a/src/ble/hal/blercu/blercucontroller.h +++ b/src/ble/hal/blercu/blercucontroller.h @@ -36,10 +36,23 @@ #include #include +#include +#include +#include class BleRcuDevice; +struct BleRcuPairingOutcome +{ + std::string method; // "auto_timeout" | "ir_code" | "mac_hash" | "mac_list" + std::string result; // "success" | failure-reason string + std::vector> discovered; // {mac_str, was_paired} + int bluezRetries; + std::string pairedMac; // empty on failure + std::string bluezError; +}; + class BleRcuController { @@ -101,12 +114,17 @@ class BleRcuController { m_stateChangedSlots.addSlot(func); } + inline void addPairingOutcomeSlot(const Slot &func) + { + m_pairingOutcomeSlots.addSlot(func); + } protected: Slots m_managedDeviceAddedSlots; Slots m_managedDeviceRemovedSlots; Slots m_pairingStateChangedSlots; Slots m_stateChangedSlots; + Slots m_pairingOutcomeSlots; }; #endif // !defined(BLERCUCONTROLLER_H) diff --git a/src/ble/hal/blercu/blercudevice.h b/src/ble/hal/blercu/blercudevice.h index 8ab7cc44..c2ed4531 100644 --- a/src/ble/hal/blercu/blercudevice.h +++ b/src/ble/hal/blercu/blercudevice.h @@ -187,17 +187,18 @@ class BleRcuDevice { m_readyChangedSlots.addSlot(func); } - inline void addPairingErrorSlot(const Slot &func) + inline void addPairingErrorSlot(const Slot &func) { m_pairingErrorSlots.addSlot(func); } + protected: Slots m_connectedChangedSlots; Slots m_pairedChangedSlots; Slots m_nameChangedSlots; Slots m_readyChangedSlots; - Slots m_pairingErrorSlots; + Slots m_pairingErrorSlots; }; diff --git a/src/ble/hal/blercu/blercupairingstatemachine.cpp b/src/ble/hal/blercu/blercupairingstatemachine.cpp index e23c6939..098cec81 100644 --- a/src/ble/hal/blercu/blercupairingstatemachine.cpp +++ b/src/ble/hal/blercu/blercupairingstatemachine.cpp @@ -52,6 +52,9 @@ BleRcuPairingStateMachine::BleRcuPairingStateMachine(const shared_ptraddPoweredChangedSlot(Slot(m_isAlive, std::bind(&BleRcuPairingStateMachine::onAdapterPoweredChanged, this, std::placeholders::_1))); - m_adapter->addDevicePairingErrorSlot(Slot(m_isAlive, - std::bind(&BleRcuPairingStateMachine::onDevicePairingError, this, std::placeholders::_1, std::placeholders::_2))); + m_adapter->addDevicePairingErrorSlot(Slot(m_isAlive, + std::bind(&BleRcuPairingStateMachine::onDevicePairingError, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4))); } BleRcuPairingStateMachine::~BleRcuPairingStateMachine() @@ -206,6 +209,36 @@ bool BleRcuPairingStateMachine::isScanningForAutoPair() const return isRunning() && m_isAutoPairing && m_stateMachine.inState(DiscoverySuperState); } +BleRcuPairingStateMachine::PairingMethod BleRcuPairingStateMachine::pairingMethod() const +{ + return m_pairingMethod; +} + +BleRcuPairingStateMachine::FailureReason BleRcuPairingStateMachine::failureReason() const +{ + return m_failureReason; +} + +std::vector BleRcuPairingStateMachine::discoveredDevices() const +{ + return m_discoveredDevices; +} + +int BleRcuPairingStateMachine::bluezRetries() const +{ + return m_bluezRetries; +} + +BleAddress BleRcuPairingStateMachine::pairedMac() const +{ + return m_pairedMac; +} + +std::string BleRcuPairingStateMachine::bluezError() const +{ + return m_bluezErrorMsg; +} + // ----------------------------------------------------------------------------- /*! @@ -239,6 +272,14 @@ void BleRcuPairingStateMachine::startAutoWithTimeout(int timeoutMs) m_targetedPairingNames.push_back(name); } + // reset telemetry tracking state + m_pairingMethod = AUTO_TIMEOUT; + m_failureReason = SUCCESS; + m_discoveredDevices.clear(); + m_bluezRetries = 0; + m_pairedMac.clear(); + m_bluezErrorMsg.clear(); + // start the state machine m_stateMachine.start(); @@ -289,6 +330,14 @@ void BleRcuPairingStateMachine::startWithCode(uint8_t pairingCode) m_targetedPairingNames.push_back(std::regex(nameWithCode, std::regex_constants::ECMAScript)); } + // reset telemetry tracking state + m_pairingMethod = IR_CODE; + m_failureReason = SUCCESS; + m_discoveredDevices.clear(); + m_bluezRetries = 0; + m_pairedMac.clear(); + m_bluezErrorMsg.clear(); + // start the state machine m_stateMachine.start(); @@ -321,6 +370,14 @@ void BleRcuPairingStateMachine::startWithMacList(const std::vector & // set the list of addresses to filter for m_pairingMacList = macList; + // reset telemetry tracking state + m_pairingMethod = MAC_LIST; + m_failureReason = SUCCESS; + m_discoveredDevices.clear(); + m_bluezRetries = 0; + m_pairedMac.clear(); + m_bluezErrorMsg.clear(); + // start the state machine m_stateMachine.start(); @@ -353,6 +410,9 @@ void BleRcuPairingStateMachine::stop() XLOGD_INFO("cancelling pairing"); + // record the cancellation reason before posting the event + m_failureReason = FAIL_CANCELLED; + // post a cancel event and let the state-machine clean up m_stateMachine.postEvent(CancelRequestEvent); } @@ -435,12 +495,16 @@ void BleRcuPairingStateMachine::onStateTransition(int oldState, int newState) if (newState == FinishedState) { if (oldState == UnpairingState) { XLOGD_AUTOMATION_WARN("timed-out in un-pairing phase (failed rcu may be left paired)"); + m_failureReason = FAIL_PAIRING_TIMEOUT; } else if (oldState == StartingDiscoveryState) { XLOGD_AUTOMATION_ERROR("timed-out waiting for discovery started signal"); + m_failureReason = FAIL_DISCOVERY_TIMEOUT; } else if (oldState == DiscoveringState) { XLOGD_AUTOMATION_ERROR("timed-out in discovery phase (didn't find target rcu device to pair to)"); + m_failureReason = FAIL_DISCOVERY_TIMEOUT; } else if (oldState == StoppingDiscoveryState) { XLOGD_AUTOMATION_ERROR("timed-out waiting for discovery to stop (suggesting something has gone wrong inside bluez)"); + m_failureReason = FAIL_DISCOVERY_STOP_TIMEOUT; } } else if (newState == UnpairingState) { if (oldState == EnablePairableState || oldState == PairingState) { @@ -521,6 +585,9 @@ void BleRcuPairingStateMachine::onDiscoveryChanged(bool discovering) if (discovering) { m_stateMachine.postEvent(DiscoveryStartedEvent); } else { + if (m_stateMachine.inState(DiscoverySuperState)) { + m_failureReason = FAIL_DISCOVERY_STOPPED; + } m_stateMachine.postEvent(DiscoveryStoppedEvent); } } @@ -714,6 +781,7 @@ void BleRcuPairingStateMachine::onEnteredUnpairingState() // remove (unpair) the target device because we've failed :-( if (m_adapter->removeDevice(m_targetAddress) == false) { + m_failureReason = FAIL_PAIRING_TIMEOUT; m_stateMachine.postEvent(DeviceUnpairedEvent); } } @@ -884,6 +952,17 @@ void BleRcuPairingStateMachine::onDeviceFound(const BleAddress &address, XLOGD_DEBUG("device added %s %s (target %s)", address.toString().c_str(), name.c_str(), m_targetAddress.toString().c_str()); + bool alreadyRecorded = false; + for (const auto &dev : m_discoveredDevices) { + if (dev.name == name) { alreadyRecorded = true; break; } + } + if (!alreadyRecorded) { + DiscoveredDevice dev; + dev.mac = address; + dev.name = name; + m_discoveredDevices.push_back(dev); + } + processDevice(address, name); } @@ -905,6 +984,11 @@ void BleRcuPairingStateMachine::onDeviceRemoved(const BleAddress &address) // check if the device removed is the one we're targeting if (!m_targetAddress.isNull() && (m_targetAddress == address)) { + if (m_stateMachine.inState(UnpairingState)) { + m_failureReason = FAIL_PAIRING_TIMEOUT; + } else { + m_failureReason = FAIL_DEVICE_REMOVED; + } m_stateMachine.postEvent(DeviceRemovedEvent); } } @@ -941,12 +1025,24 @@ void BleRcuPairingStateMachine::onDeviceNameChanged(const BleAddress &address, */ void BleRcuPairingStateMachine::onDevicePairingError(const BleAddress &address, - const string &error) + const string &error, + int retryCnt, + int maxRetryCnt) { if (!m_stateMachine.isRunning()) { return; } + m_failureReason = FAIL_BLUEZ_ERROR; + m_bluezRetries = retryCnt; + m_bluezErrorMsg = error; + m_pairedMac = address; + + if (retryCnt < maxRetryCnt) { + // Still retrying so don't stop pairing and timers yet + return; + } + XLOGD_ERROR("Device (%s) pairing failed, shutting down state machine...", address.toString().c_str()); // stop the pairing and setup timeout timers @@ -979,6 +1075,11 @@ void BleRcuPairingStateMachine::onDevicePairingChanged(const BleAddress &address if (paired) { m_stateMachine.postEvent(DevicePairedEvent); } else { + if (m_stateMachine.inState(UnpairingState)) { + m_failureReason = FAIL_PAIRING_TIMEOUT; + } else { + m_failureReason = FAIL_DEVICE_UNPAIRED; + } m_stateMachine.postEvent(DeviceUnpairedEvent); } } @@ -1006,6 +1107,7 @@ void BleRcuPairingStateMachine::onDeviceReadyChanged(const BleAddress &address, if (ready) { m_pairingSuccesses++; m_pairingSucceeded = true; + m_pairedMac = address; m_stateMachine.postEvent(DeviceReadyEvent); } } @@ -1027,6 +1129,7 @@ void BleRcuPairingStateMachine::onAdapterPoweredChanged(bool powered) } if (!powered) { + m_failureReason = FAIL_ADAPTER_OFF; m_stateMachine.postEvent(AdapterPoweredOffEvent); } } diff --git a/src/ble/hal/blercu/blercupairingstatemachine.h b/src/ble/hal/blercu/blercupairingstatemachine.h index cfb15c31..f267ef68 100644 --- a/src/ble/hal/blercu/blercupairingstatemachine.h +++ b/src/ble/hal/blercu/blercupairingstatemachine.h @@ -40,13 +40,38 @@ #include #include - class BleRcuAdapter; class ConfigSettings; class BleRcuPairingStateMachine { +public: + enum PairingMethod { + AUTO_TIMEOUT, + MAC_LIST, + IR_CODE, + MAC_HASH + }; + + enum FailureReason { + SUCCESS = 0, + FAIL_DISCOVERY_TIMEOUT, + FAIL_DISCOVERY_STOPPED, + FAIL_DISCOVERY_STOP_TIMEOUT, + FAIL_PAIRING_TIMEOUT, + FAIL_BLUEZ_ERROR, + FAIL_ADAPTER_OFF, + FAIL_DEVICE_UNPAIRED, + FAIL_DEVICE_REMOVED, + FAIL_CANCELLED + }; + + struct DiscoveredDevice { + BleAddress mac; + std::string name; + }; + public: enum State { RunningSuperState, @@ -73,6 +98,14 @@ class BleRcuPairingStateMachine bool isScanningForAutoPair() const; int pairingCode() const; +// Pairing outcome getters (valid after the state machine stops) + PairingMethod pairingMethod() const; + FailureReason failureReason() const; + std::vector discoveredDevices() const; + int bluezRetries() const; + BleAddress pairedMac() const; + std::string bluezError() const; + // public slots: void startAutoWithTimeout(int timeoutMs); void startWithCode(uint8_t pairingCode); @@ -114,7 +147,7 @@ class BleRcuPairingStateMachine void onDeviceNameChanged(const BleAddress &address, const std::string &name); void onDevicePairingChanged(const BleAddress &address, bool paired); void onDeviceReadyChanged(const BleAddress &address, bool ready); - void onDevicePairingError(const BleAddress &address, const std::string &error); + void onDevicePairingError(const BleAddress &address, const std::string &error, int retryCnt, int maxRetryCnt); void onAdapterPoweredChanged(bool powered); @@ -172,6 +205,14 @@ class BleRcuPairingStateMachine int m_pairingSuccesses; bool m_pairingSucceeded; + // Pairing outcome tracking + PairingMethod m_pairingMethod; + FailureReason m_failureReason; + std::vector m_discoveredDevices; + int m_bluezRetries; + BleAddress m_pairedMac; + std::string m_bluezErrorMsg; + BtrMgrAdapter m_btrMgrAdapter; bool discoveryStartedExternally = false; BtrMgrAdapter::OperationType lastOperationType = BtrMgrAdapter::unknownOperation; diff --git a/src/ble/hal/blercu/bluez/blercuadapter.cpp b/src/ble/hal/blercu/bluez/blercuadapter.cpp index 56949f40..14cb0b5c 100644 --- a/src/ble/hal/blercu/bluez/blercuadapter.cpp +++ b/src/ble/hal/blercu/bluez/blercuadapter.cpp @@ -1245,8 +1245,8 @@ bool BleRcuAdapterBluez::addDevice(const BleAddress &address) XLOGD_INFO("requesting bluez pair %s", device->address().toString().c_str()); - device->addPairingErrorSlot(Slot(m_isAlive, - std::bind(&BleRcuAdapterBluez::onDevicePairingError, this, address, std::placeholders::_1))); + device->addPairingErrorSlot(Slot(m_isAlive, + std::bind(&BleRcuAdapterBluez::onDevicePairingError, this, address, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3))); device->pair(0); @@ -1688,9 +1688,11 @@ void BleRcuAdapterBluez::onDeviceNameChanged(const BleAddress &address, */ void BleRcuAdapterBluez::onDevicePairingError(const BleAddress &address, - const std::string &error) + const std::string &error, + int retryCnt, + int maxRetryCnt) { - m_devicePairingErrorSlots.invoke(address, error); + m_devicePairingErrorSlots.invoke(address, error, retryCnt, maxRetryCnt); } // ----------------------------------------------------------------------------- diff --git a/src/ble/hal/blercu/bluez/blercuadapter_p.h b/src/ble/hal/blercu/bluez/blercuadapter_p.h index aeb35f5c..d5124ed2 100644 --- a/src/ble/hal/blercu/bluez/blercuadapter_p.h +++ b/src/ble/hal/blercu/bluez/blercuadapter_p.h @@ -113,7 +113,7 @@ class BleRcuAdapterBluez : public BleRcuAdapter const std::vector &interfaces); void onDeviceNameChanged(const BleAddress &address, const std::string &name); - void onDevicePairingError(const BleAddress &address, const std::string &error); + void onDevicePairingError(const BleAddress &address, const std::string &error, int retryCnt, int maxRetryCnt); void onDevicePairedChanged(const BleAddress &address, bool paired); void onDeviceReadyChanged(const BleAddress &address, bool ready); diff --git a/src/ble/hal/blercu/bluez/blercudevice.cpp b/src/ble/hal/blercu/bluez/blercudevice.cpp index 08aa0287..2c2e02a7 100644 --- a/src/ble/hal/blercu/bluez/blercudevice.cpp +++ b/src/ble/hal/blercu/bluez/blercudevice.cpp @@ -272,8 +272,9 @@ void BleRcuDeviceBluez::onPairRequestReply(PendingReply<> *reply) pair(0); } else { m_pairingRetryCnt = 0; - m_pairingErrorSlots.invoke(reply->errorMessage()); } + int retryCnt = m_pairingRetryCnt; + m_pairingErrorSlots.invoke(reply->errorMessage(), retryCnt, m_maxPairingRetries); } else { XLOGD_DEBUG("%s pairing request successful", m_address.toString().c_str()); } diff --git a/src/ctrlm_tr181.h b/src/ctrlm_tr181.h index 8fdb0b34..d04ea769 100644 --- a/src/ctrlm_tr181.h +++ b/src/ctrlm_tr181.h @@ -59,8 +59,7 @@ #define CTRLM_TR181_VOICE_PARAMS_VSDK_CONFIGURATION "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.Voice.VSDKConfiguration" #define CTRLM_TR181_VOICE_PARAMS_KEYWORD_SENSITIVITY "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.Voice.KeywordSensitivity" #define CTRLM_TR181_TELEMETRY_REPORT_GLOBAL "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.ctrlm.telemetry_report.global" -#define CTRLM_TR181_TELEMETRY_REPORT_RF4CE "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.ctrlm.telemetry_report.rf4ce" -#define CTRLM_TR181_TELEMETRY_REPORT_BLE "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.ctrlm.telemetry_report.ble" +#define CTRLM_TR181_TELEMETRY_REPORT_RCU "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.ctrlm.telemetry_report.rcu" #define CTRLM_TR181_TELEMETRY_REPORT_IP "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.ctrlm.telemetry_report.ip" #define CTRLM_TR181_TELEMETRY_REPORT_VOICE "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.ctrlm.telemetry_report.voice" #define CTRLM_RT181_POWER_RFC_PWRMGR2 "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.Power.PwrMgr2.Enable" diff --git a/src/telemetry/ctrlm_telemetry.cpp b/src/telemetry/ctrlm_telemetry.cpp index 3918444f..398bd369 100644 --- a/src/telemetry/ctrlm_telemetry.cpp +++ b/src/telemetry/ctrlm_telemetry.cpp @@ -60,8 +60,7 @@ ctrlm_telemetry_t::ctrlm_telemetry_t() { this->timeout_id = 0; this->set_duration(this->reporting_interval); this->event_reported[ctrlm_telemetry_report_t::GLOBAL] = false; - this->event_reported[ctrlm_telemetry_report_t::RF4CE] = false; - this->event_reported[ctrlm_telemetry_report_t::BLE] = false; + this->event_reported[ctrlm_telemetry_report_t::RCU] = false; this->event_reported[ctrlm_telemetry_report_t::IP] = false; this->event_reported[ctrlm_telemetry_report_t::VOICE] = false; } @@ -112,8 +111,7 @@ void ctrlm_telemetry_t::report() { const char *ctrlm_telemetry_t::get_report_trigger(ctrlm_telemetry_report_t report) { switch(report) { case ctrlm_telemetry_report_t::GLOBAL: return(CTRLM_TR181_TELEMETRY_REPORT_GLOBAL); - case ctrlm_telemetry_report_t::RF4CE: return(CTRLM_TR181_TELEMETRY_REPORT_RF4CE); - case ctrlm_telemetry_report_t::BLE: return(CTRLM_TR181_TELEMETRY_REPORT_BLE); + case ctrlm_telemetry_report_t::RCU: return(CTRLM_TR181_TELEMETRY_REPORT_RCU); case ctrlm_telemetry_report_t::IP: return(CTRLM_TR181_TELEMETRY_REPORT_IP); case ctrlm_telemetry_report_t::VOICE: return(CTRLM_TR181_TELEMETRY_REPORT_VOICE); } @@ -123,8 +121,7 @@ const char *ctrlm_telemetry_t::get_report_trigger(ctrlm_telemetry_report_t repor const char *ctrlm_telemetry_t::get_report_str(ctrlm_telemetry_report_t report) { switch(report) { case ctrlm_telemetry_report_t::GLOBAL: return("GLOBAL"); - case ctrlm_telemetry_report_t::RF4CE: return("RF4CE"); - case ctrlm_telemetry_report_t::BLE: return("BLE"); + case ctrlm_telemetry_report_t::RCU: return("RCU"); case ctrlm_telemetry_report_t::IP: return("IP"); case ctrlm_telemetry_report_t::VOICE: return("VOICE"); } diff --git a/src/telemetry/ctrlm_telemetry.h b/src/telemetry/ctrlm_telemetry.h index 8b5db4fb..9024ebe2 100644 --- a/src/telemetry/ctrlm_telemetry.h +++ b/src/telemetry/ctrlm_telemetry.h @@ -28,8 +28,7 @@ */ typedef enum { GLOBAL, - RF4CE, - BLE, + RCU, IP, VOICE } ctrlm_telemetry_report_t; diff --git a/src/telemetry/ctrlm_telemetry_markers.h b/src/telemetry/ctrlm_telemetry_markers.h index 23c0f775..c04e0a08 100644 --- a/src/telemetry/ctrlm_telemetry_markers.h +++ b/src/telemetry/ctrlm_telemetry_markers.h @@ -125,4 +125,26 @@ // End Voice Markers // +// +// RCU Markers +// + +// BLE RCU Pairing Attempt Marker +// Value format: JSON object string with the fields below. +// {"method":,"result":,"paired_mac":,"bluez_retries":,"error_msg":,"discovered":[{"mac":,"name":}...]} +// - pairing method: "auto_timeout" | "ir_code" | "mac_hash" | "mac_list" +// - "success" or failure reason: "discovery_timeout" | "discovery_stopped" | "discovery_stop_timeout" | +// "pairing_timeout" | "bluez_error" | "adapter_off" | "device_unpaired" | "device_removed" | "cancelled" +// - MAC address string of paired device, empty string on failure +// - number of bluez pair() retries made before success or final error +// - error message of bluez layer +// - array of devices seen during discovery; each has "mac" and "name" +// - Version of the marker format. +#define MARKER_RCU_PAIRING_ATTEMPT "ctrlm.rcu.pairing.attempt" +#define MARKER_RCU_PAIRING_ATTEMPT_VERSION 1 + +// +// End BLE Markers +// + #endif From 927a2922843eb77460a3033a63e154d9aeeb4a2b Mon Sep 17 00:00:00 2001 From: Kelvin Lu <119349872+klu339@users.noreply.github.com> Date: Tue, 31 Mar 2026 14:41:32 -0400 Subject: [PATCH 02/12] Apply suggestions from code review Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- src/ble/ctrlm_ble_network.cpp | 4 ++-- src/ble/hal/blercu/blercucontroller.h | 2 +- src/telemetry/ctrlm_telemetry_markers.h | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/ble/ctrlm_ble_network.cpp b/src/ble/ctrlm_ble_network.cpp index 0db0c39d..36b5ef40 100644 --- a/src/ble/ctrlm_ble_network.cpp +++ b/src/ble/ctrlm_ble_network.cpp @@ -1702,7 +1702,7 @@ void ctrlm_obj_network_ble_t::ind_process_rcu_pairing_outcome(void *data, int si json_object_set_new(jroot, "result", json_string(attempt.result.c_str())); json_object_set_new(jroot, "paired_mac", json_string(attempt.paired_mac.c_str())); json_object_set_new(jroot, "bluez_retries", json_integer(attempt.bluez_retries)); - json_object_set_new(jroot, "bluez_msg", json_string(attempt.error_msg.c_str())); + json_object_set_new(jroot, "error_msg", json_string(attempt.error_msg.c_str())); json_t *jdiscovered = json_array(); if (jdiscovered) { @@ -1718,7 +1718,7 @@ void ctrlm_obj_network_ble_t::ind_process_rcu_pairing_outcome(void *data, int si } char *json_str = json_dumps(jroot, JSON_COMPACT); - XLOGD_WARN("KLU339 %s", json_str); + XLOGD_DEBUG("Serialized RCU pairing attempt telemetry payload"); if (json_str) { ctrlm_telemetry_event_t ev(MARKER_RCU_PAIRING_ATTEMPT, std::string(json_str)); ctrlm_telemetry_t::get_instance()->event(ctrlm_telemetry_report_t::RCU, ev); diff --git a/src/ble/hal/blercu/blercucontroller.h b/src/ble/hal/blercu/blercucontroller.h index b54b3b28..900fbe63 100644 --- a/src/ble/hal/blercu/blercucontroller.h +++ b/src/ble/hal/blercu/blercucontroller.h @@ -47,7 +47,7 @@ struct BleRcuPairingOutcome { std::string method; // "auto_timeout" | "ir_code" | "mac_hash" | "mac_list" std::string result; // "success" | failure-reason string - std::vector> discovered; // {mac_str, was_paired} + std::vector> discovered; // {mac, name} int bluezRetries; std::string pairedMac; // empty on failure std::string bluezError; diff --git a/src/telemetry/ctrlm_telemetry_markers.h b/src/telemetry/ctrlm_telemetry_markers.h index c04e0a08..88de9270 100644 --- a/src/telemetry/ctrlm_telemetry_markers.h +++ b/src/telemetry/ctrlm_telemetry_markers.h @@ -144,7 +144,7 @@ #define MARKER_RCU_PAIRING_ATTEMPT_VERSION 1 // -// End BLE Markers +// End RCU Markers // #endif From 1433e86ed47ee38fa26e183d76f28be48e6a96f6 Mon Sep 17 00:00:00 2001 From: klu339 Date: Tue, 31 Mar 2026 20:13:11 +0000 Subject: [PATCH 03/12] RDKEMW-15135: Copilot fixes and array of bluez errors --- src/ble/ctrlm_ble_network.cpp | 19 ++++++++++--------- src/ble/ctrlm_ble_network.h | 4 ++-- src/ble/hal/blercu/blercucontroller.cpp | 2 +- src/ble/hal/blercu/blercucontroller.h | 2 +- .../hal/blercu/blercupairingstatemachine.cpp | 3 +-- src/ble/hal/blercu/bluez/blercudevice.cpp | 4 +++- src/telemetry/ctrlm_telemetry_markers.h | 2 +- 7 files changed, 19 insertions(+), 17 deletions(-) diff --git a/src/ble/ctrlm_ble_network.cpp b/src/ble/ctrlm_ble_network.cpp index 36b5ef40..cbf51b50 100644 --- a/src/ble/ctrlm_ble_network.cpp +++ b/src/ble/ctrlm_ble_network.cpp @@ -1686,15 +1686,10 @@ void ctrlm_obj_network_ble_t::ind_process_rcu_pairing_outcome(void *data, int si attempt.discovered = outcome->discovered; attempt.bluez_retries = outcome->bluezRetries; attempt.paired_mac = outcome->pairedMac; - attempt.error_msg = outcome->bluezError; - - XLOGD_INFO("BLE pairing attempt complete: method=%s result=%s paired_mac=%s " - "bluez_retries=%d bluez_msg=%s discovered=%zu", - attempt.method.c_str(), attempt.result.c_str(), attempt.paired_mac.c_str(), - attempt.bluez_retries, attempt.error_msg.c_str(), attempt.discovered.size()); + attempt.bluez_msgs = outcome->bluezError; #ifdef TELEMETRY_SUPPORT - // Serialize to JSON compatible with the ctrlm.ble.pairing.attempt T2 marker + // Serialize to JSON compatible with the ctrlm.rcu.pairing.attempt T2 marker json_t *jroot = json_object(); if (jroot) { json_object_set_new(jroot, "version", json_integer(MARKER_RCU_PAIRING_ATTEMPT_VERSION)); @@ -1702,7 +1697,14 @@ void ctrlm_obj_network_ble_t::ind_process_rcu_pairing_outcome(void *data, int si json_object_set_new(jroot, "result", json_string(attempt.result.c_str())); json_object_set_new(jroot, "paired_mac", json_string(attempt.paired_mac.c_str())); json_object_set_new(jroot, "bluez_retries", json_integer(attempt.bluez_retries)); - json_object_set_new(jroot, "error_msg", json_string(attempt.error_msg.c_str())); + + json_t *jbluez_errors = json_array(); + if (jbluez_errors) { + for (const auto &msg : attempt.bluez_msgs) { + json_array_append_new(jbluez_errors, json_string(msg.c_str())); + } + json_object_set_new(jroot, "bluez_msg", jbluez_errors); + } json_t *jdiscovered = json_array(); if (jdiscovered) { @@ -1718,7 +1720,6 @@ void ctrlm_obj_network_ble_t::ind_process_rcu_pairing_outcome(void *data, int si } char *json_str = json_dumps(jroot, JSON_COMPACT); - XLOGD_DEBUG("Serialized RCU pairing attempt telemetry payload"); if (json_str) { ctrlm_telemetry_event_t ev(MARKER_RCU_PAIRING_ATTEMPT, std::string(json_str)); ctrlm_telemetry_t::get_instance()->event(ctrlm_telemetry_report_t::RCU, ev); diff --git a/src/ble/ctrlm_ble_network.h b/src/ble/ctrlm_ble_network.h index c0702980..deebc2dd 100644 --- a/src/ble/ctrlm_ble_network.h +++ b/src/ble/ctrlm_ble_network.h @@ -102,10 +102,10 @@ typedef struct { struct ctrlm_ble_pair_attempt_t { std::string method; // pairing method string (auto_timeout, ir_code, mac_hash, mac_list) std::string result; // "success" or failure reason string - std::vector> discovered; // {mac_str, was_paired} + std::vector> discovered; // {mac_str, rcu_name} int bluez_retries; std::string paired_mac; // empty on failure - std::string error_msg; + std::vector bluez_msgs; }; /////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/ble/hal/blercu/blercucontroller.cpp b/src/ble/hal/blercu/blercucontroller.cpp index 3f8fac7b..d150c9b1 100644 --- a/src/ble/hal/blercu/blercucontroller.cpp +++ b/src/ble/hal/blercu/blercucontroller.cpp @@ -692,7 +692,7 @@ void BleRcuControllerImpl::onFailedPairing() outcome.result = failureReasonStr(m_pairingStateMachine.failureReason()); outcome.bluezRetries = m_pairingStateMachine.bluezRetries(); outcome.pairedMac = m_pairingStateMachine.pairedMac().toString(); - outcome.bluezError = m_pairingStateMachine.bluezError(); + outcome.bluezError.emplace_back(m_pairingStateMachine.bluezError()); for (const auto &dev : m_pairingStateMachine.discoveredDevices()) { outcome.discovered.emplace_back(dev.mac.toString(), dev.name); } diff --git a/src/ble/hal/blercu/blercucontroller.h b/src/ble/hal/blercu/blercucontroller.h index 900fbe63..40d00e77 100644 --- a/src/ble/hal/blercu/blercucontroller.h +++ b/src/ble/hal/blercu/blercucontroller.h @@ -50,7 +50,7 @@ struct BleRcuPairingOutcome std::vector> discovered; // {mac, name} int bluezRetries; std::string pairedMac; // empty on failure - std::string bluezError; + std::vector bluezError; }; diff --git a/src/ble/hal/blercu/blercupairingstatemachine.cpp b/src/ble/hal/blercu/blercupairingstatemachine.cpp index 098cec81..47307da3 100644 --- a/src/ble/hal/blercu/blercupairingstatemachine.cpp +++ b/src/ble/hal/blercu/blercupairingstatemachine.cpp @@ -954,7 +954,7 @@ void BleRcuPairingStateMachine::onDeviceFound(const BleAddress &address, bool alreadyRecorded = false; for (const auto &dev : m_discoveredDevices) { - if (dev.name == name) { alreadyRecorded = true; break; } + if (dev.mac == address) { alreadyRecorded = true; break; } } if (!alreadyRecorded) { DiscoveredDevice dev; @@ -1036,7 +1036,6 @@ void BleRcuPairingStateMachine::onDevicePairingError(const BleAddress &address, m_failureReason = FAIL_BLUEZ_ERROR; m_bluezRetries = retryCnt; m_bluezErrorMsg = error; - m_pairedMac = address; if (retryCnt < maxRetryCnt) { // Still retrying so don't stop pairing and timers yet diff --git a/src/ble/hal/blercu/bluez/blercudevice.cpp b/src/ble/hal/blercu/bluez/blercudevice.cpp index 2c2e02a7..8abd11f8 100644 --- a/src/ble/hal/blercu/bluez/blercudevice.cpp +++ b/src/ble/hal/blercu/bluez/blercudevice.cpp @@ -266,15 +266,17 @@ void BleRcuDeviceBluez::onPairRequestReply(PendingReply<> *reply) XLOGD_ERROR("%s pairing request failed with error: <%s>", m_address.toString().c_str(), reply->errorMessage().c_str()); + bool resetCnt = false; if (m_pairingRetryCnt < m_maxPairingRetries) { m_pairingRetryCnt++; XLOGD_INFO("Retrying pairing, attempt %d out of %d ", m_pairingRetryCnt, m_maxPairingRetries); pair(0); } else { - m_pairingRetryCnt = 0; + resetCnt = true; } int retryCnt = m_pairingRetryCnt; m_pairingErrorSlots.invoke(reply->errorMessage(), retryCnt, m_maxPairingRetries); + m_pairingRetryCnt = resetCnt ? 0 : m_pairingRetryCnt; } else { XLOGD_DEBUG("%s pairing request successful", m_address.toString().c_str()); } diff --git a/src/telemetry/ctrlm_telemetry_markers.h b/src/telemetry/ctrlm_telemetry_markers.h index 88de9270..5040df7f 100644 --- a/src/telemetry/ctrlm_telemetry_markers.h +++ b/src/telemetry/ctrlm_telemetry_markers.h @@ -137,7 +137,7 @@ // "pairing_timeout" | "bluez_error" | "adapter_off" | "device_unpaired" | "device_removed" | "cancelled" // - MAC address string of paired device, empty string on failure // - number of bluez pair() retries made before success or final error -// - error message of bluez layer +// - array of error message of bluez layer, empty if no errors // - array of devices seen during discovery; each has "mac" and "name" // - Version of the marker format. #define MARKER_RCU_PAIRING_ATTEMPT "ctrlm.rcu.pairing.attempt" From 6b7f3bc2c363ce589b43e33adbac074ff7a35e87 Mon Sep 17 00:00:00 2001 From: klu339 Date: Wed, 1 Apr 2026 13:50:09 -0400 Subject: [PATCH 04/12] RDKEMW-15135: Fix vector msg and clean up --- src/ble/ctrlm_ble_network.cpp | 20 ++++++------------- src/ble/ctrlm_ble_network.h | 16 --------------- src/ble/hal/blercu/blercucontroller.cpp | 2 +- .../hal/blercu/blercupairingstatemachine.cpp | 4 ++-- .../hal/blercu/blercupairingstatemachine.h | 4 ++-- src/ble/hal/blercu/bluez/blercudevice.cpp | 8 +++----- src/telemetry/ctrlm_telemetry.cpp | 2 +- 7 files changed, 15 insertions(+), 41 deletions(-) diff --git a/src/ble/ctrlm_ble_network.cpp b/src/ble/ctrlm_ble_network.cpp index cbf51b50..ed0ecd86 100644 --- a/src/ble/ctrlm_ble_network.cpp +++ b/src/ble/ctrlm_ble_network.cpp @@ -1680,27 +1680,19 @@ void ctrlm_obj_network_ble_t::ind_process_rcu_pairing_outcome(void *data, int si return; } - ctrlm_ble_pair_attempt_t attempt; - attempt.method = outcome->method; - attempt.result = outcome->result; - attempt.discovered = outcome->discovered; - attempt.bluez_retries = outcome->bluezRetries; - attempt.paired_mac = outcome->pairedMac; - attempt.bluez_msgs = outcome->bluezError; - #ifdef TELEMETRY_SUPPORT // Serialize to JSON compatible with the ctrlm.rcu.pairing.attempt T2 marker json_t *jroot = json_object(); if (jroot) { json_object_set_new(jroot, "version", json_integer(MARKER_RCU_PAIRING_ATTEMPT_VERSION)); - json_object_set_new(jroot, "method", json_string(attempt.method.c_str())); - json_object_set_new(jroot, "result", json_string(attempt.result.c_str())); - json_object_set_new(jroot, "paired_mac", json_string(attempt.paired_mac.c_str())); - json_object_set_new(jroot, "bluez_retries", json_integer(attempt.bluez_retries)); + json_object_set_new(jroot, "method", json_string(outcome->method.c_str())); + json_object_set_new(jroot, "result", json_string(outcome->result.c_str())); + json_object_set_new(jroot, "paired_mac", json_string(outcome->pairedMac.c_str())); + json_object_set_new(jroot, "bluez_retries", json_integer(outcome->bluezRetries)); json_t *jbluez_errors = json_array(); if (jbluez_errors) { - for (const auto &msg : attempt.bluez_msgs) { + for (const auto &msg : outcome->bluezError) { json_array_append_new(jbluez_errors, json_string(msg.c_str())); } json_object_set_new(jroot, "bluez_msg", jbluez_errors); @@ -1708,7 +1700,7 @@ void ctrlm_obj_network_ble_t::ind_process_rcu_pairing_outcome(void *data, int si json_t *jdiscovered = json_array(); if (jdiscovered) { - for (const auto &dev : attempt.discovered) { + for (const auto &dev : outcome->discovered) { json_t *jdev = json_object(); if (jdev) { json_object_set_new(jdev, "mac", json_string(dev.first.c_str())); diff --git a/src/ble/ctrlm_ble_network.h b/src/ble/ctrlm_ble_network.h index deebc2dd..9e4f99b4 100644 --- a/src/ble/ctrlm_ble_network.h +++ b/src/ble/ctrlm_ble_network.h @@ -92,22 +92,6 @@ typedef struct { } ctrlm_ble_upgrade_image_info_t; -/////////////////////////////////////////////////////////////////////////////////////////// - -/** - * @brief BLE RCU Pairing Attempt Metrics - * - * Aggregates the outcome of a single BLE pairing attempt for telemetry emission. - */ -struct ctrlm_ble_pair_attempt_t { - std::string method; // pairing method string (auto_timeout, ir_code, mac_hash, mac_list) - std::string result; // "success" or failure reason string - std::vector> discovered; // {mac_str, rcu_name} - int bluez_retries; - std::string paired_mac; // empty on failure - std::vector bluez_msgs; -}; - /////////////////////////////////////////////////////////////////////////////////////////// /** diff --git a/src/ble/hal/blercu/blercucontroller.cpp b/src/ble/hal/blercu/blercucontroller.cpp index d150c9b1..67118da9 100644 --- a/src/ble/hal/blercu/blercucontroller.cpp +++ b/src/ble/hal/blercu/blercucontroller.cpp @@ -692,7 +692,7 @@ void BleRcuControllerImpl::onFailedPairing() outcome.result = failureReasonStr(m_pairingStateMachine.failureReason()); outcome.bluezRetries = m_pairingStateMachine.bluezRetries(); outcome.pairedMac = m_pairingStateMachine.pairedMac().toString(); - outcome.bluezError.emplace_back(m_pairingStateMachine.bluezError()); + outcome.bluezError = m_pairingStateMachine.bluezError(); for (const auto &dev : m_pairingStateMachine.discoveredDevices()) { outcome.discovered.emplace_back(dev.mac.toString(), dev.name); } diff --git a/src/ble/hal/blercu/blercupairingstatemachine.cpp b/src/ble/hal/blercu/blercupairingstatemachine.cpp index 47307da3..1598b0a8 100644 --- a/src/ble/hal/blercu/blercupairingstatemachine.cpp +++ b/src/ble/hal/blercu/blercupairingstatemachine.cpp @@ -234,7 +234,7 @@ BleAddress BleRcuPairingStateMachine::pairedMac() const return m_pairedMac; } -std::string BleRcuPairingStateMachine::bluezError() const +std::vector BleRcuPairingStateMachine::bluezError() const { return m_bluezErrorMsg; } @@ -1035,7 +1035,7 @@ void BleRcuPairingStateMachine::onDevicePairingError(const BleAddress &address, m_failureReason = FAIL_BLUEZ_ERROR; m_bluezRetries = retryCnt; - m_bluezErrorMsg = error; + m_bluezErrorMsg.push_back(error); if (retryCnt < maxRetryCnt) { // Still retrying so don't stop pairing and timers yet diff --git a/src/ble/hal/blercu/blercupairingstatemachine.h b/src/ble/hal/blercu/blercupairingstatemachine.h index f267ef68..8830da34 100644 --- a/src/ble/hal/blercu/blercupairingstatemachine.h +++ b/src/ble/hal/blercu/blercupairingstatemachine.h @@ -104,7 +104,7 @@ class BleRcuPairingStateMachine std::vector discoveredDevices() const; int bluezRetries() const; BleAddress pairedMac() const; - std::string bluezError() const; + std::vector bluezError() const; // public slots: void startAutoWithTimeout(int timeoutMs); @@ -211,7 +211,7 @@ class BleRcuPairingStateMachine std::vector m_discoveredDevices; int m_bluezRetries; BleAddress m_pairedMac; - std::string m_bluezErrorMsg; + std::vector m_bluezErrorMsg; BtrMgrAdapter m_btrMgrAdapter; bool discoveryStartedExternally = false; diff --git a/src/ble/hal/blercu/bluez/blercudevice.cpp b/src/ble/hal/blercu/bluez/blercudevice.cpp index 8abd11f8..2e352bd3 100644 --- a/src/ble/hal/blercu/bluez/blercudevice.cpp +++ b/src/ble/hal/blercu/bluez/blercudevice.cpp @@ -266,17 +266,15 @@ void BleRcuDeviceBluez::onPairRequestReply(PendingReply<> *reply) XLOGD_ERROR("%s pairing request failed with error: <%s>", m_address.toString().c_str(), reply->errorMessage().c_str()); - bool resetCnt = false; if (m_pairingRetryCnt < m_maxPairingRetries) { m_pairingRetryCnt++; XLOGD_INFO("Retrying pairing, attempt %d out of %d ", m_pairingRetryCnt, m_maxPairingRetries); + m_pairingErrorSlots.invoke(reply->errorMessage(), m_pairingRetryCnt, m_maxPairingRetries); pair(0); } else { - resetCnt = true; + m_pairingErrorSlots.invoke(reply->errorMessage(), m_pairingRetryCnt, m_maxPairingRetries); + m_pairingRetryCnt = 0; } - int retryCnt = m_pairingRetryCnt; - m_pairingErrorSlots.invoke(reply->errorMessage(), retryCnt, m_maxPairingRetries); - m_pairingRetryCnt = resetCnt ? 0 : m_pairingRetryCnt; } else { XLOGD_DEBUG("%s pairing request successful", m_address.toString().c_str()); } diff --git a/src/telemetry/ctrlm_telemetry.cpp b/src/telemetry/ctrlm_telemetry.cpp index 398bd369..32a6f946 100644 --- a/src/telemetry/ctrlm_telemetry.cpp +++ b/src/telemetry/ctrlm_telemetry.cpp @@ -60,7 +60,7 @@ ctrlm_telemetry_t::ctrlm_telemetry_t() { this->timeout_id = 0; this->set_duration(this->reporting_interval); this->event_reported[ctrlm_telemetry_report_t::GLOBAL] = false; - this->event_reported[ctrlm_telemetry_report_t::RCU] = false; + this->event_reported[ctrlm_telemetry_report_t::RCU] = false; this->event_reported[ctrlm_telemetry_report_t::IP] = false; this->event_reported[ctrlm_telemetry_report_t::VOICE] = false; } From 871504a5bae593d9b773dd38df759a0b3c6e21f7 Mon Sep 17 00:00:00 2001 From: klu339 Date: Wed, 1 Apr 2026 20:38:50 +0000 Subject: [PATCH 05/12] RDKEMW-15135: another round of Copilot review comments --- src/ble/ctrlm_ble_network.cpp | 4 ++++ src/ble/hal/blercu/blercupairingstatemachine.cpp | 15 +++++++++++---- src/telemetry/ctrlm_telemetry_markers.h | 2 +- 3 files changed, 16 insertions(+), 5 deletions(-) diff --git a/src/ble/ctrlm_ble_network.cpp b/src/ble/ctrlm_ble_network.cpp index ed0ecd86..71f5d145 100644 --- a/src/ble/ctrlm_ble_network.cpp +++ b/src/ble/ctrlm_ble_network.cpp @@ -1675,6 +1675,10 @@ void ctrlm_obj_network_ble_t::ind_rcu_pairing_outcome(const BleRcuPairingOutcome void ctrlm_obj_network_ble_t::ind_process_rcu_pairing_outcome(void *data, int size) { THREAD_ID_VALIDATE(); const BleRcuPairingOutcome *outcome = static_cast(data); + if (sizeof(BleRcuPairingOutcome) != size) { + XLOGD_ERROR("Invalid size!"); + return; + } if (!outcome) { XLOGD_ERROR("pairing outcome data is NULL"); return; diff --git a/src/ble/hal/blercu/blercupairingstatemachine.cpp b/src/ble/hal/blercu/blercupairingstatemachine.cpp index 1598b0a8..db6b66b6 100644 --- a/src/ble/hal/blercu/blercupairingstatemachine.cpp +++ b/src/ble/hal/blercu/blercupairingstatemachine.cpp @@ -492,19 +492,21 @@ void BleRcuPairingStateMachine::onStateExit(int state) */ void BleRcuPairingStateMachine::onStateTransition(int oldState, int newState) { + FailureReason newFailureReason = SUCCESS; + if (newState == FinishedState) { if (oldState == UnpairingState) { XLOGD_AUTOMATION_WARN("timed-out in un-pairing phase (failed rcu may be left paired)"); - m_failureReason = FAIL_PAIRING_TIMEOUT; + newFailureReason = FAIL_PAIRING_TIMEOUT; } else if (oldState == StartingDiscoveryState) { XLOGD_AUTOMATION_ERROR("timed-out waiting for discovery started signal"); - m_failureReason = FAIL_DISCOVERY_TIMEOUT; + newFailureReason = FAIL_DISCOVERY_TIMEOUT; } else if (oldState == DiscoveringState) { XLOGD_AUTOMATION_ERROR("timed-out in discovery phase (didn't find target rcu device to pair to)"); - m_failureReason = FAIL_DISCOVERY_TIMEOUT; + newFailureReason = FAIL_DISCOVERY_TIMEOUT; } else if (oldState == StoppingDiscoveryState) { XLOGD_AUTOMATION_ERROR("timed-out waiting for discovery to stop (suggesting something has gone wrong inside bluez)"); - m_failureReason = FAIL_DISCOVERY_STOP_TIMEOUT; + newFailureReason = FAIL_DISCOVERY_STOP_TIMEOUT; } } else if (newState == UnpairingState) { if (oldState == EnablePairableState || oldState == PairingState) { @@ -513,6 +515,11 @@ void BleRcuPairingStateMachine::onStateTransition(int oldState, int newState) XLOGD_AUTOMATION_WARN("timed-out in setup phase (rcu didn't response to all requests within %dms)", m_setupTimeout); } } + + // Change the failure reason only if it hasn't already been set elsewhere + if (newFailureReason != SUCCESS && m_failureReason == SUCCESS) { + m_failureReason = newFailureReason; + } } void BleRcuPairingStateMachine::onEnteredStoppingDiscoveryStartedExternally() diff --git a/src/telemetry/ctrlm_telemetry_markers.h b/src/telemetry/ctrlm_telemetry_markers.h index 5040df7f..c9487770 100644 --- a/src/telemetry/ctrlm_telemetry_markers.h +++ b/src/telemetry/ctrlm_telemetry_markers.h @@ -131,7 +131,7 @@ // BLE RCU Pairing Attempt Marker // Value format: JSON object string with the fields below. -// {"method":,"result":,"paired_mac":,"bluez_retries":,"error_msg":,"discovered":[{"mac":,"name":}...]} +// {"method":,"result":,"paired_mac":,"bluez_retries":,"bluez_msg":,"discovered":[{"mac":,"name":}...]} // - pairing method: "auto_timeout" | "ir_code" | "mac_hash" | "mac_list" // - "success" or failure reason: "discovery_timeout" | "discovery_stopped" | "discovery_stop_timeout" | // "pairing_timeout" | "bluez_error" | "adapter_off" | "device_unpaired" | "device_removed" | "cancelled" From 3e2cf43fc9ac3b779b2d6f6ff381ab88b1d567cb Mon Sep 17 00:00:00 2001 From: klu339 Date: Wed, 8 Apr 2026 15:55:12 +0000 Subject: [PATCH 06/12] RDKEMW-15135: Re-formatted marker --- src/ble/ctrlm_ble_network.cpp | 72 ++++++++++--------- src/ble/ctrlm_ble_network.h | 1 + src/ble/hal/blercu/blercucontroller.cpp | 59 ++++----------- src/ble/hal/blercu/blercucontroller.h | 14 ++-- .../hal/blercu/blercupairingstatemachine.cpp | 36 ++++++---- .../hal/blercu/blercupairingstatemachine.h | 13 ++-- src/telemetry/ctrlm_telemetry_event.cpp | 12 +++- src/telemetry/ctrlm_telemetry_event.h | 2 + src/telemetry/ctrlm_telemetry_markers.h | 16 +++-- .../telemetry/ctrlm_voice_telemetry_events.h | 2 +- 10 files changed, 112 insertions(+), 115 deletions(-) diff --git a/src/ble/ctrlm_ble_network.cpp b/src/ble/ctrlm_ble_network.cpp index 71f5d145..13b6a032 100644 --- a/src/ble/ctrlm_ble_network.cpp +++ b/src/ble/ctrlm_ble_network.cpp @@ -311,6 +311,13 @@ ctrlm_obj_network_ble_t::ctrlm_obj_network_ble_t(ctrlm_network_type_t type, ctrl if(rfc) { rfc->add_changed_listener(ctrlm_rfc_t::attrs::BLE, std::bind(&ctrlm_obj_network_ble_t::rfc_retrieved_handler, this, std::placeholders::_1)); } + + #ifdef TELEMETRY_SUPPORT + ctrlm_telemetry_t *telemetry = ctrlm_get_telemetry_obj(); + if(telemetry) { + telemetry->add_listener(ctrlm_telemetry_report_t::RCU, std::bind(&ctrlm_obj_network_ble_t::telemetry_report_handler, this)); + } + #endif } ctrlm_obj_network_ble_t::ctrlm_obj_network_ble_t() { @@ -1686,43 +1693,34 @@ void ctrlm_obj_network_ble_t::ind_process_rcu_pairing_outcome(void *data, int si #ifdef TELEMETRY_SUPPORT // Serialize to JSON compatible with the ctrlm.rcu.pairing.attempt T2 marker - json_t *jroot = json_object(); - if (jroot) { - json_object_set_new(jroot, "version", json_integer(MARKER_RCU_PAIRING_ATTEMPT_VERSION)); - json_object_set_new(jroot, "method", json_string(outcome->method.c_str())); - json_object_set_new(jroot, "result", json_string(outcome->result.c_str())); - json_object_set_new(jroot, "paired_mac", json_string(outcome->pairedMac.c_str())); - json_object_set_new(jroot, "bluez_retries", json_integer(outcome->bluezRetries)); - - json_t *jbluez_errors = json_array(); - if (jbluez_errors) { - for (const auto &msg : outcome->bluezError) { - json_array_append_new(jbluez_errors, json_string(msg.c_str())); - } - json_object_set_new(jroot, "bluez_msg", jbluez_errors); - } - - json_t *jdiscovered = json_array(); - if (jdiscovered) { - for (const auto &dev : outcome->discovered) { - json_t *jdev = json_object(); - if (jdev) { - json_object_set_new(jdev, "mac", json_string(dev.first.c_str())); - json_object_set_new(jdev, "name", json_string(dev.second.c_str())); - json_array_append_new(jdiscovered, jdev); - } - } - json_object_set_new(jroot, "discovered", jdiscovered); + std::stringstream ss; + ss << "["; + ss << MARKER_RCU_PAIRING_ATTEMPT_VERSION << ","; + ss << "\"" << name_get() << "\","; + ss << outcome->method << ","; + ss << outcome->result << ","; + ss << outcome->discovered << ","; + ss << "\"" << outcome->pairedMac << "\","; + ss << "\"" << outcome->name << "\","; + ss << outcome->bluezRetries << ","; + + for (uint8_t i = 0; i < outcome->maxBluezRetries; i++) { + if (i >= outcome->bluezRetries || i >= outcome->bluezError.size()) { + ss << "\"null\""; + } else { + std::string msg = outcome->bluezError.at(i); + auto pos = msg.rfind(": "); + msg = (pos != std::string::npos) ? msg.substr(pos + 2) : msg; + ss << "\"" << msg << "\""; } - - char *json_str = json_dumps(jroot, JSON_COMPACT); - if (json_str) { - ctrlm_telemetry_event_t ev(MARKER_RCU_PAIRING_ATTEMPT, std::string(json_str)); - ctrlm_telemetry_t::get_instance()->event(ctrlm_telemetry_report_t::RCU, ev); - free(json_str); + if (i != (outcome->maxBluezRetries-1)) { + ss << ","; } - json_decref(jroot); } + ss << "]"; + + ctrlm_telemetry_event_t ev(MARKER_RCU_PAIRING_ATTEMPT, ss.str()); + ctrlm_telemetry_t::get_instance()->event(ctrlm_telemetry_report_t::RCU, ev); #endif // TELEMETRY_SUPPORT } @@ -2731,3 +2729,9 @@ void ctrlm_obj_network_ble_t::start_controller_audio_streaming(ctrlm_voice_start bool ctrlm_obj_network_ble_t::is_managed_by_network(ctrlm_controller_id_t id) { return (id >= BLE_RCU_ID_RANGE_MIN && id < BLE_RCU_ID_RANGE_MAX); } + +void ctrlm_obj_network_ble_t::telemetry_report_handler() { + #ifndef TELEMETRY_SUPPORT + XLOGD_WARN("telemetry is not enabled"); + #endif +} diff --git a/src/ble/ctrlm_ble_network.h b/src/ble/ctrlm_ble_network.h index 9e4f99b4..da606682 100644 --- a/src/ble/ctrlm_ble_network.h +++ b/src/ble/ctrlm_ble_network.h @@ -197,6 +197,7 @@ class ctrlm_obj_network_ble_t : public ctrlm_obj_network_t { std::shared_ptr getConfigSettings(); virtual void start_controller_audio_streaming(ctrlm_voice_start_audio_params_t *params); + void telemetry_report_handler(); protected: virtual bool is_managed_by_network(ctrlm_controller_id_t id); diff --git a/src/ble/hal/blercu/blercucontroller.cpp b/src/ble/hal/blercu/blercucontroller.cpp index 67118da9..e60da50f 100644 --- a/src/ble/hal/blercu/blercucontroller.cpp +++ b/src/ble/hal/blercu/blercucontroller.cpp @@ -41,35 +41,6 @@ using namespace std; -static const char* pairingMethodStr(BleRcuPairingStateMachine::PairingMethod m) -{ - switch (m) { - case BleRcuPairingStateMachine::AUTO_TIMEOUT: return "auto_timeout"; - case BleRcuPairingStateMachine::MAC_LIST: return "mac_list"; - case BleRcuPairingStateMachine::IR_CODE: return "ir_code"; - case BleRcuPairingStateMachine::MAC_HASH: return "mac_hash"; - default: return "unknown"; - } -} - -static const char* failureReasonStr(BleRcuPairingStateMachine::FailureReason r) -{ - switch (r) { - case BleRcuPairingStateMachine::SUCCESS: return "success"; - case BleRcuPairingStateMachine::FAIL_DISCOVERY_TIMEOUT: return "discovery_timeout"; - case BleRcuPairingStateMachine::FAIL_DISCOVERY_STOPPED: return "discovery_stopped"; - case BleRcuPairingStateMachine::FAIL_DISCOVERY_STOP_TIMEOUT:return "discovery_stop_timeout"; - case BleRcuPairingStateMachine::FAIL_PAIRING_TIMEOUT: return "pairing_timeout"; - case BleRcuPairingStateMachine::FAIL_BLUEZ_ERROR: return "bluez_error"; - case BleRcuPairingStateMachine::FAIL_ADAPTER_OFF: return "adapter_off"; - case BleRcuPairingStateMachine::FAIL_DEVICE_UNPAIRED: return "device_unpaired"; - case BleRcuPairingStateMachine::FAIL_DEVICE_REMOVED: return "device_removed"; - case BleRcuPairingStateMachine::FAIL_CANCELLED: return "cancelled"; - default: return "unknown"; - } -} - - class BleRcuController_userdata { public: BleRcuController_userdata(shared_ptr isAlive_, BleRcuControllerImpl* controller_) @@ -638,13 +609,13 @@ void BleRcuControllerImpl::onFinishedPairing() // emit pairing outcome telemetry BleRcuPairingOutcome outcome; - outcome.method = pairingMethodStr(m_pairingStateMachine.pairingMethod()); - outcome.result = failureReasonStr(BleRcuPairingStateMachine::SUCCESS); - outcome.bluezRetries = m_pairingStateMachine.bluezRetries(); - outcome.pairedMac = m_pairingStateMachine.pairedMac().toString(); - for (const auto &dev : m_pairingStateMachine.discoveredDevices()) { - outcome.discovered.emplace_back(dev.mac.toString(), dev.name); - } + outcome.method = m_pairingStateMachine.pairingMethod(); + outcome.result = BleRcuPairingStateMachine::SUCCESS; + outcome.bluezRetries = m_pairingStateMachine.bluezRetries(); + outcome.maxBluezRetries = m_pairingStateMachine.maxBluezRetries(); + outcome.pairedMac = m_pairingStateMachine.pairedMac().toString(); + outcome.name = m_pairingStateMachine.pairedName(); + outcome.discovered = m_pairingStateMachine.discoveredDevices(); m_pairingOutcomeSlots.invoke(outcome); } @@ -688,14 +659,14 @@ void BleRcuControllerImpl::onFailedPairing() // emit pairing outcome telemetry BleRcuPairingOutcome outcome; - outcome.method = pairingMethodStr(m_pairingStateMachine.pairingMethod()); - outcome.result = failureReasonStr(m_pairingStateMachine.failureReason()); - outcome.bluezRetries = m_pairingStateMachine.bluezRetries(); - outcome.pairedMac = m_pairingStateMachine.pairedMac().toString(); - outcome.bluezError = m_pairingStateMachine.bluezError(); - for (const auto &dev : m_pairingStateMachine.discoveredDevices()) { - outcome.discovered.emplace_back(dev.mac.toString(), dev.name); - } + outcome.method = m_pairingStateMachine.pairingMethod(); + outcome.result = m_pairingStateMachine.failureReason(); + outcome.bluezRetries = m_pairingStateMachine.bluezRetries(); + outcome.maxBluezRetries = m_pairingStateMachine.maxBluezRetries(); + outcome.pairedMac = m_pairingStateMachine.pairedMac().toString(); + outcome.bluezError = m_pairingStateMachine.bluezError(); + outcome.discovered = m_pairingStateMachine.discoveredDevices(); + outcome.name = ""; m_pairingOutcomeSlots.invoke(outcome); } diff --git a/src/ble/hal/blercu/blercucontroller.h b/src/ble/hal/blercu/blercucontroller.h index 40d00e77..5ca104f2 100644 --- a/src/ble/hal/blercu/blercucontroller.h +++ b/src/ble/hal/blercu/blercucontroller.h @@ -45,12 +45,14 @@ class BleRcuDevice; struct BleRcuPairingOutcome { - std::string method; // "auto_timeout" | "ir_code" | "mac_hash" | "mac_list" - std::string result; // "success" | failure-reason string - std::vector> discovered; // {mac, name} - int bluezRetries; - std::string pairedMac; // empty on failure - std::vector bluezError; + int method; // "auto_timeout" | "ir_code" | "mac_hash" | "mac_list" + int result; // "success" | failure-reason string + int discovered; // number of discovered devices + int bluezRetries; // number of bluez retries attempted + int maxBluezRetries; // max number of retries + std::string pairedMac; // empty on failure + std::string name; // empty on failure + std::vector bluezError; // bluez error messages }; diff --git a/src/ble/hal/blercu/blercupairingstatemachine.cpp b/src/ble/hal/blercu/blercupairingstatemachine.cpp index db6b66b6..b7a29c65 100644 --- a/src/ble/hal/blercu/blercupairingstatemachine.cpp +++ b/src/ble/hal/blercu/blercupairingstatemachine.cpp @@ -55,6 +55,7 @@ BleRcuPairingStateMachine::BleRcuPairingStateMachine(const shared_ptr BleRcuPairingStateMachine::discoveredDevices() const +int BleRcuPairingStateMachine::discoveredDevices() const { - return m_discoveredDevices; + return m_discoveredDevices.size(); } int BleRcuPairingStateMachine::bluezRetries() const @@ -229,11 +230,22 @@ int BleRcuPairingStateMachine::bluezRetries() const return m_bluezRetries; } +int BleRcuPairingStateMachine::maxBluezRetries() const +{ + return m_bluezMaxRetries; +} + BleAddress BleRcuPairingStateMachine::pairedMac() const { return m_pairedMac; } +std::string BleRcuPairingStateMachine::pairedName() const +{ + auto it = m_discoveredDevices.find(m_pairedMac); + return (it != m_discoveredDevices.end()) ? it->second : ""; +} + std::vector BleRcuPairingStateMachine::bluezError() const { return m_bluezErrorMsg; @@ -277,6 +289,7 @@ void BleRcuPairingStateMachine::startAutoWithTimeout(int timeoutMs) m_failureReason = SUCCESS; m_discoveredDevices.clear(); m_bluezRetries = 0; + m_bluezMaxRetries = 0; m_pairedMac.clear(); m_bluezErrorMsg.clear(); @@ -335,6 +348,7 @@ void BleRcuPairingStateMachine::startWithCode(uint8_t pairingCode) m_failureReason = SUCCESS; m_discoveredDevices.clear(); m_bluezRetries = 0; + m_bluezMaxRetries = 0; m_pairedMac.clear(); m_bluezErrorMsg.clear(); @@ -375,6 +389,7 @@ void BleRcuPairingStateMachine::startWithMacList(const std::vector & m_failureReason = SUCCESS; m_discoveredDevices.clear(); m_bluezRetries = 0; + m_bluezMaxRetries = 0; m_pairedMac.clear(); m_bluezErrorMsg.clear(); @@ -503,7 +518,7 @@ void BleRcuPairingStateMachine::onStateTransition(int oldState, int newState) newFailureReason = FAIL_DISCOVERY_TIMEOUT; } else if (oldState == DiscoveringState) { XLOGD_AUTOMATION_ERROR("timed-out in discovery phase (didn't find target rcu device to pair to)"); - newFailureReason = FAIL_DISCOVERY_TIMEOUT; + newFailureReason = FAIL_TARGET_RCU_NOT_FOUND; } else if (oldState == StoppingDiscoveryState) { XLOGD_AUTOMATION_ERROR("timed-out waiting for discovery to stop (suggesting something has gone wrong inside bluez)"); newFailureReason = FAIL_DISCOVERY_STOP_TIMEOUT; @@ -617,6 +632,7 @@ void BleRcuPairingStateMachine::onEnteredDiscoveringState() map::const_iterator it = deviceNames.begin(); for (; it != deviceNames.end(); ++it) { processDevice(it->first, it->second); + m_discoveredDevices.emplace(it->first, it->second) } } @@ -958,17 +974,7 @@ void BleRcuPairingStateMachine::onDeviceFound(const BleAddress &address, XLOGD_DEBUG("device added %s %s (target %s)", address.toString().c_str(), name.c_str(), m_targetAddress.toString().c_str()); - - bool alreadyRecorded = false; - for (const auto &dev : m_discoveredDevices) { - if (dev.mac == address) { alreadyRecorded = true; break; } - } - if (!alreadyRecorded) { - DiscoveredDevice dev; - dev.mac = address; - dev.name = name; - m_discoveredDevices.push_back(dev); - } + m_discoveredDevices.emplace(address, name); processDevice(address, name); } @@ -1018,6 +1024,7 @@ void BleRcuPairingStateMachine::onDeviceNameChanged(const BleAddress &address, XLOGD_DEBUG("device name changed %s %s (target %s)", address.toString().c_str(), name.c_str(), m_targetAddress.toString().c_str()); + m_discoveredDevices[address] = name; processDevice(address, name); } @@ -1042,6 +1049,7 @@ void BleRcuPairingStateMachine::onDevicePairingError(const BleAddress &address, m_failureReason = FAIL_BLUEZ_ERROR; m_bluezRetries = retryCnt; + m_bluezMaxRetries = maxRetryCnt; m_bluezErrorMsg.push_back(error); if (retryCnt < maxRetryCnt) { diff --git a/src/ble/hal/blercu/blercupairingstatemachine.h b/src/ble/hal/blercu/blercupairingstatemachine.h index 8830da34..30255c0a 100644 --- a/src/ble/hal/blercu/blercupairingstatemachine.h +++ b/src/ble/hal/blercu/blercupairingstatemachine.h @@ -60,6 +60,7 @@ class BleRcuPairingStateMachine FAIL_DISCOVERY_STOPPED, FAIL_DISCOVERY_STOP_TIMEOUT, FAIL_PAIRING_TIMEOUT, + FAIL_TARGET_RCU_NOT_FOUND, FAIL_BLUEZ_ERROR, FAIL_ADAPTER_OFF, FAIL_DEVICE_UNPAIRED, @@ -67,11 +68,6 @@ class BleRcuPairingStateMachine FAIL_CANCELLED }; - struct DiscoveredDevice { - BleAddress mac; - std::string name; - }; - public: enum State { RunningSuperState, @@ -101,9 +97,11 @@ class BleRcuPairingStateMachine // Pairing outcome getters (valid after the state machine stops) PairingMethod pairingMethod() const; FailureReason failureReason() const; - std::vector discoveredDevices() const; + int discoveredDevices() const; int bluezRetries() const; + int maxBluezRetries() const; BleAddress pairedMac() const; + std::string pairedName() const; std::vector bluezError() const; // public slots: @@ -208,8 +206,9 @@ class BleRcuPairingStateMachine // Pairing outcome tracking PairingMethod m_pairingMethod; FailureReason m_failureReason; - std::vector m_discoveredDevices; + std::map m_discoveredDevices; int m_bluezRetries; + int m_bluezMaxRetries; BleAddress m_pairedMac; std::vector m_bluezErrorMsg; diff --git a/src/telemetry/ctrlm_telemetry_event.cpp b/src/telemetry/ctrlm_telemetry_event.cpp index 6ca82571..6ab33336 100644 --- a/src/telemetry/ctrlm_telemetry_event.cpp +++ b/src/telemetry/ctrlm_telemetry_event.cpp @@ -34,6 +34,14 @@ bool ctrlm_telemetry_event_t::event() const { template <> bool ctrlm_telemetry_event_t::event() const { - XLOGD_TELEMETRY("telemetry event <%s, %s>", this->marker.c_str(), this->value.c_str()); - return(t2_event_s((char *)this->marker.c_str(), (char *)this->value.c_str()) == T2ERROR_SUCCESS); + if (value.length() > CTRLM_TELEMETRY_MAX_EVENT_SIZE_BYTES) { + XLOGD_ERROR("telemetry event <%s> dropped: value length <%zu> exceeds maximum <%d> bytes", + this->marker.c_str(), + this->value.length(), + this->CTRLM_TELEMETRY_MAX_EVENT_SIZE_BYTES); + return false; + } else { + XLOGD_TELEMETRY("telemetry event <%s, %s>", this->marker.c_str(), this->value.c_str()); + return(t2_event_s((char *)this->marker.c_str(), (char *)this->value.c_str()) == T2ERROR_SUCCESS); + } } diff --git a/src/telemetry/ctrlm_telemetry_event.h b/src/telemetry/ctrlm_telemetry_event.h index 1628afb1..b83ca853 100644 --- a/src/telemetry/ctrlm_telemetry_event.h +++ b/src/telemetry/ctrlm_telemetry_event.h @@ -26,6 +26,8 @@ #include #endif +#define CTRLM_TELEMETRY_MAX_EVENT_SIZE_BYTES 4536 // Maximum size of event list in bytes (there are limitations in the T2 implementation that restrict the maximum size of an event string. This value should be within the limits of the T2 implementation) + template class ctrlm_telemetry_event_t { static_assert(std::is_same::value || std::is_same::value || std::is_same::value, "Invalid telemetry event type"); diff --git a/src/telemetry/ctrlm_telemetry_markers.h b/src/telemetry/ctrlm_telemetry_markers.h index c9487770..a7c5d3f3 100644 --- a/src/telemetry/ctrlm_telemetry_markers.h +++ b/src/telemetry/ctrlm_telemetry_markers.h @@ -130,16 +130,18 @@ // // BLE RCU Pairing Attempt Marker -// Value format: JSON object string with the fields below. -// {"method":,"result":,"paired_mac":,"bluez_retries":,"bluez_msg":,"discovered":[{"mac":,"name":}...]} -// - pairing method: "auto_timeout" | "ir_code" | "mac_hash" | "mac_list" -// - "success" or failure reason: "discovery_timeout" | "discovery_stopped" | "discovery_stop_timeout" | +// Value format: Array of comma separated integers or string with the fields below. +// [,,,,,,,,,,] +// - version of the marker format. +// - type of network the marker is coming from +// - enum representing pairing method: "auto_timeout" | "ir_code" | "mac_hash" | "mac_list" +// - number of discovered devices from pairing attempt +// - enum that represents "success" or failure reason: "discovery_timeout" | "discovery_stopped" | "discovery_stop_timeout" | // "pairing_timeout" | "bluez_error" | "adapter_off" | "device_unpaired" | "device_removed" | "cancelled" // - MAC address string of paired device, empty string on failure +// - name of paired remote, empty string on failure // - number of bluez pair() retries made before success or final error -// - array of error message of bluez layer, empty if no errors -// - array of devices seen during discovery; each has "mac" and "name" -// - Version of the marker format. +// - error message of bluez layer, empty if no errors #define MARKER_RCU_PAIRING_ATTEMPT "ctrlm.rcu.pairing.attempt" #define MARKER_RCU_PAIRING_ATTEMPT_VERSION 1 diff --git a/src/voice/telemetry/ctrlm_voice_telemetry_events.h b/src/voice/telemetry/ctrlm_voice_telemetry_events.h index adadfde6..93badb20 100644 --- a/src/voice/telemetry/ctrlm_voice_telemetry_events.h +++ b/src/voice/telemetry/ctrlm_voice_telemetry_events.h @@ -79,7 +79,7 @@ class ctrlm_voice_telemetry_session_t : public ctrlm_telemetry_event_t Date: Wed, 8 Apr 2026 19:27:06 +0000 Subject: [PATCH 07/12] RDKEMW-15135: copilot comments Reason for change: Test Procedure: Risks: Signed-off-by: Kelvin Lu --- src/ble/ctrlm_ble_network.cpp | 2 +- src/ble/hal/blercu/blercuadapter.h | 6 ++--- src/ble/hal/blercu/blercucontroller.cpp | 4 ++-- src/ble/hal/blercu/blercudevice.h | 4 ++-- .../hal/blercu/blercupairingstatemachine.cpp | 24 ++++++------------- .../hal/blercu/blercupairingstatemachine.h | 4 ++-- src/ble/hal/blercu/bluez/blercuadapter.cpp | 13 +++++----- src/ble/hal/blercu/bluez/blercuadapter_p.h | 4 ++-- src/ble/hal/blercu/bluez/blercudevice.cpp | 12 ++++++---- src/ble/hal/blercu/bluez/blercudevice_p.h | 2 +- src/telemetry/ctrlm_telemetry_event.cpp | 2 +- src/telemetry/ctrlm_telemetry_markers.h | 5 ++-- 12 files changed, 36 insertions(+), 46 deletions(-) diff --git a/src/ble/ctrlm_ble_network.cpp b/src/ble/ctrlm_ble_network.cpp index 13b6a032..5d8a43f7 100644 --- a/src/ble/ctrlm_ble_network.cpp +++ b/src/ble/ctrlm_ble_network.cpp @@ -1692,7 +1692,7 @@ void ctrlm_obj_network_ble_t::ind_process_rcu_pairing_outcome(void *data, int si } #ifdef TELEMETRY_SUPPORT - // Serialize to JSON compatible with the ctrlm.rcu.pairing.attempt T2 marker + // Serialize to array for ctrlm.rcu.pairing.attempt T2 marker std::stringstream ss; ss << "["; ss << MARKER_RCU_PAIRING_ATTEMPT_VERSION << ","; diff --git a/src/ble/hal/blercu/blercuadapter.h b/src/ble/hal/blercu/blercuadapter.h index d795acb8..1fcee795 100644 --- a/src/ble/hal/blercu/blercuadapter.h +++ b/src/ble/hal/blercu/blercuadapter.h @@ -72,7 +72,7 @@ class BleRcuAdapter virtual bool isDevicePaired(const BleAddress &address) const = 0; virtual bool isDeviceConnected(const BleAddress &address) const = 0; - virtual bool addDevice(const BleAddress &address) = 0; + virtual bool addDevice(const BleAddress &address, int retries) = 0; virtual bool removeDevice(const BleAddress &address) = 0; virtual bool setConnectionParams(BleAddress address, double minInterval, double maxInterval, @@ -107,7 +107,7 @@ class BleRcuAdapter { m_deviceNameChangedSlots.addSlot(func); } - inline void addDevicePairingErrorSlot(const Slot &func) + inline void addDevicePairingErrorSlot(const Slot &func) { m_devicePairingErrorSlots.addSlot(func); } @@ -135,7 +135,7 @@ class BleRcuAdapter Slots m_deviceFoundSlots; Slots m_deviceRemovedSlots; Slots m_deviceNameChangedSlots; - Slots m_devicePairingErrorSlots; + Slots m_devicePairingErrorSlots; Slots m_devicePairingChangedSlots; Slots m_deviceReadyChangedSlots; diff --git a/src/ble/hal/blercu/blercucontroller.cpp b/src/ble/hal/blercu/blercucontroller.cpp index e60da50f..b76b5d00 100644 --- a/src/ble/hal/blercu/blercucontroller.cpp +++ b/src/ble/hal/blercu/blercucontroller.cpp @@ -612,7 +612,7 @@ void BleRcuControllerImpl::onFinishedPairing() outcome.method = m_pairingStateMachine.pairingMethod(); outcome.result = BleRcuPairingStateMachine::SUCCESS; outcome.bluezRetries = m_pairingStateMachine.bluezRetries(); - outcome.maxBluezRetries = m_pairingStateMachine.maxBluezRetries(); + outcome.maxBluezRetries = MAX_PAIRING_RETRIES; outcome.pairedMac = m_pairingStateMachine.pairedMac().toString(); outcome.name = m_pairingStateMachine.pairedName(); outcome.discovered = m_pairingStateMachine.discoveredDevices(); @@ -662,7 +662,7 @@ void BleRcuControllerImpl::onFailedPairing() outcome.method = m_pairingStateMachine.pairingMethod(); outcome.result = m_pairingStateMachine.failureReason(); outcome.bluezRetries = m_pairingStateMachine.bluezRetries(); - outcome.maxBluezRetries = m_pairingStateMachine.maxBluezRetries(); + outcome.maxBluezRetries = MAX_PAIRING_RETRIES; outcome.pairedMac = m_pairingStateMachine.pairedMac().toString(); outcome.bluezError = m_pairingStateMachine.bluezError(); outcome.discovered = m_pairingStateMachine.discoveredDevices(); diff --git a/src/ble/hal/blercu/blercudevice.h b/src/ble/hal/blercu/blercudevice.h index c2ed4531..b77cfba7 100644 --- a/src/ble/hal/blercu/blercudevice.h +++ b/src/ble/hal/blercu/blercudevice.h @@ -187,7 +187,7 @@ class BleRcuDevice { m_readyChangedSlots.addSlot(func); } - inline void addPairingErrorSlot(const Slot &func) + inline void addPairingErrorSlot(const Slot &func) { m_pairingErrorSlots.addSlot(func); } @@ -198,7 +198,7 @@ class BleRcuDevice Slots m_pairedChangedSlots; Slots m_nameChangedSlots; Slots m_readyChangedSlots; - Slots m_pairingErrorSlots; + Slots m_pairingErrorSlots; }; diff --git a/src/ble/hal/blercu/blercupairingstatemachine.cpp b/src/ble/hal/blercu/blercupairingstatemachine.cpp index b7a29c65..9b854768 100644 --- a/src/ble/hal/blercu/blercupairingstatemachine.cpp +++ b/src/ble/hal/blercu/blercupairingstatemachine.cpp @@ -55,7 +55,7 @@ BleRcuPairingStateMachine::BleRcuPairingStateMachine(const shared_ptraddPoweredChangedSlot(Slot(m_isAlive, std::bind(&BleRcuPairingStateMachine::onAdapterPoweredChanged, this, std::placeholders::_1))); - m_adapter->addDevicePairingErrorSlot(Slot(m_isAlive, - std::bind(&BleRcuPairingStateMachine::onDevicePairingError, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4))); + m_adapter->addDevicePairingErrorSlot(Slot(m_isAlive, + std::bind(&BleRcuPairingStateMachine::onDevicePairingError, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3))); } BleRcuPairingStateMachine::~BleRcuPairingStateMachine() @@ -230,11 +230,6 @@ int BleRcuPairingStateMachine::bluezRetries() const return m_bluezRetries; } -int BleRcuPairingStateMachine::maxBluezRetries() const -{ - return m_bluezMaxRetries; -} - BleAddress BleRcuPairingStateMachine::pairedMac() const { return m_pairedMac; @@ -289,7 +284,6 @@ void BleRcuPairingStateMachine::startAutoWithTimeout(int timeoutMs) m_failureReason = SUCCESS; m_discoveredDevices.clear(); m_bluezRetries = 0; - m_bluezMaxRetries = 0; m_pairedMac.clear(); m_bluezErrorMsg.clear(); @@ -348,7 +342,6 @@ void BleRcuPairingStateMachine::startWithCode(uint8_t pairingCode) m_failureReason = SUCCESS; m_discoveredDevices.clear(); m_bluezRetries = 0; - m_bluezMaxRetries = 0; m_pairedMac.clear(); m_bluezErrorMsg.clear(); @@ -389,7 +382,6 @@ void BleRcuPairingStateMachine::startWithMacList(const std::vector & m_failureReason = SUCCESS; m_discoveredDevices.clear(); m_bluezRetries = 0; - m_bluezMaxRetries = 0; m_pairedMac.clear(); m_bluezErrorMsg.clear(); @@ -632,7 +624,7 @@ void BleRcuPairingStateMachine::onEnteredDiscoveringState() map::const_iterator it = deviceNames.begin(); for (; it != deviceNames.end(); ++it) { processDevice(it->first, it->second); - m_discoveredDevices.emplace(it->first, it->second) + m_discoveredDevices.emplace(it->first, it->second); } } @@ -750,7 +742,7 @@ void BleRcuPairingStateMachine::onEnteredPairingState() m_pairingSlots.invoke(); // request the manager to pair with the device - m_adapter->addDevice(m_targetAddress); + m_adapter->addDevice(m_targetAddress, MAX_PAIRING_RETRIES); } // ----------------------------------------------------------------------------- @@ -1040,8 +1032,7 @@ void BleRcuPairingStateMachine::onDeviceNameChanged(const BleAddress &address, */ void BleRcuPairingStateMachine::onDevicePairingError(const BleAddress &address, const string &error, - int retryCnt, - int maxRetryCnt) + int retryCnt) { if (!m_stateMachine.isRunning()) { return; @@ -1049,10 +1040,9 @@ void BleRcuPairingStateMachine::onDevicePairingError(const BleAddress &address, m_failureReason = FAIL_BLUEZ_ERROR; m_bluezRetries = retryCnt; - m_bluezMaxRetries = maxRetryCnt; m_bluezErrorMsg.push_back(error); - if (retryCnt < maxRetryCnt) { + if (retryCnt < MAX_PAIRING_RETRIES) { // Still retrying so don't stop pairing and timers yet return; } diff --git a/src/ble/hal/blercu/blercupairingstatemachine.h b/src/ble/hal/blercu/blercupairingstatemachine.h index 30255c0a..5bf6b99b 100644 --- a/src/ble/hal/blercu/blercupairingstatemachine.h +++ b/src/ble/hal/blercu/blercupairingstatemachine.h @@ -43,6 +43,7 @@ class BleRcuAdapter; class ConfigSettings; +#define MAX_PAIRING_RETRIES 3 class BleRcuPairingStateMachine { @@ -99,7 +100,6 @@ class BleRcuPairingStateMachine FailureReason failureReason() const; int discoveredDevices() const; int bluezRetries() const; - int maxBluezRetries() const; BleAddress pairedMac() const; std::string pairedName() const; std::vector bluezError() const; @@ -145,7 +145,7 @@ class BleRcuPairingStateMachine void onDeviceNameChanged(const BleAddress &address, const std::string &name); void onDevicePairingChanged(const BleAddress &address, bool paired); void onDeviceReadyChanged(const BleAddress &address, bool ready); - void onDevicePairingError(const BleAddress &address, const std::string &error, int retryCnt, int maxRetryCnt); + void onDevicePairingError(const BleAddress &address, const std::string &error, int retryCnt); void onAdapterPoweredChanged(bool powered); diff --git a/src/ble/hal/blercu/bluez/blercuadapter.cpp b/src/ble/hal/blercu/bluez/blercuadapter.cpp index 14cb0b5c..acd9bf62 100644 --- a/src/ble/hal/blercu/bluez/blercuadapter.cpp +++ b/src/ble/hal/blercu/bluez/blercuadapter.cpp @@ -1227,7 +1227,7 @@ bool BleRcuAdapterBluez::isDeviceConnected(const BleAddress &address) const \sa isDevicePaired(), removeDevice() */ -bool BleRcuAdapterBluez::addDevice(const BleAddress &address) +bool BleRcuAdapterBluez::addDevice(const BleAddress &address, int retries) { if (!m_stateMachine.inState(AdapterPoweredOnState)) { return false; @@ -1245,10 +1245,10 @@ bool BleRcuAdapterBluez::addDevice(const BleAddress &address) XLOGD_INFO("requesting bluez pair %s", device->address().toString().c_str()); - device->addPairingErrorSlot(Slot(m_isAlive, - std::bind(&BleRcuAdapterBluez::onDevicePairingError, this, address, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3))); + device->addPairingErrorSlot(Slot(m_isAlive, + std::bind(&BleRcuAdapterBluez::onDevicePairingError, this, address, std::placeholders::_1, std::placeholders::_2))); - device->pair(0); + device->pair(0, retries); return true; } @@ -1689,10 +1689,9 @@ void BleRcuAdapterBluez::onDeviceNameChanged(const BleAddress &address, */ void BleRcuAdapterBluez::onDevicePairingError(const BleAddress &address, const std::string &error, - int retryCnt, - int maxRetryCnt) + int retryCnt) { - m_devicePairingErrorSlots.invoke(address, error, retryCnt, maxRetryCnt); + m_devicePairingErrorSlots.invoke(address, error, retryCnt); } // ----------------------------------------------------------------------------- diff --git a/src/ble/hal/blercu/bluez/blercuadapter_p.h b/src/ble/hal/blercu/bluez/blercuadapter_p.h index d5124ed2..c283f9d1 100644 --- a/src/ble/hal/blercu/bluez/blercuadapter_p.h +++ b/src/ble/hal/blercu/bluez/blercuadapter_p.h @@ -94,7 +94,7 @@ class BleRcuAdapterBluez : public BleRcuAdapter bool isDevicePaired(const BleAddress &address) const override; bool isDeviceConnected(const BleAddress &address) const override; - bool addDevice(const BleAddress &address) override; + bool addDevice(const BleAddress &address, int retries) override; bool removeDevice(const BleAddress &address) override; bool setConnectionParams(BleAddress address, double minInterval, double maxInterval, @@ -113,7 +113,7 @@ class BleRcuAdapterBluez : public BleRcuAdapter const std::vector &interfaces); void onDeviceNameChanged(const BleAddress &address, const std::string &name); - void onDevicePairingError(const BleAddress &address, const std::string &error, int retryCnt, int maxRetryCnt); + void onDevicePairingError(const BleAddress &address, const std::string &error, int retryCnt); void onDevicePairedChanged(const BleAddress &address, bool paired); void onDeviceReadyChanged(const BleAddress &address, bool ready); diff --git a/src/ble/hal/blercu/bluez/blercudevice.cpp b/src/ble/hal/blercu/bluez/blercudevice.cpp index 2e352bd3..fcf7f315 100644 --- a/src/ble/hal/blercu/bluez/blercudevice.cpp +++ b/src/ble/hal/blercu/bluez/blercudevice.cpp @@ -98,7 +98,7 @@ BleRcuDeviceBluez::BleRcuDeviceBluez(const BleAddress &bdaddr, , m_lastServicesResolvedState(false) , m_isPairing(false) , m_pairingRetryCnt(0) - , m_maxPairingRetries(3) + , m_maxPairingRetries(0) , m_timeSinceReady(0) , m_recoveryAttempts(0) , m_maxRecoveryAttempts(100) @@ -242,8 +242,9 @@ static gboolean getInitialDeviceProperties(gpointer user_data) request then the \a pairingError signal will be emitted. */ -void BleRcuDeviceBluez::pair(int timeout) +void BleRcuDeviceBluez::pair(int timeout, int retries) { + m_maxPairingRetries = retries; m_deviceProxy->Pair( PendingReply<>(m_isAlive, std::bind(&BleRcuDeviceBluez::onPairRequestReply, this, std::placeholders::_1))); @@ -269,11 +270,12 @@ void BleRcuDeviceBluez::onPairRequestReply(PendingReply<> *reply) if (m_pairingRetryCnt < m_maxPairingRetries) { m_pairingRetryCnt++; XLOGD_INFO("Retrying pairing, attempt %d out of %d ", m_pairingRetryCnt, m_maxPairingRetries); - m_pairingErrorSlots.invoke(reply->errorMessage(), m_pairingRetryCnt, m_maxPairingRetries); - pair(0); + m_pairingErrorSlots.invoke(reply->errorMessage(), m_pairingRetryCnt); + pair(0, m_maxPairingRetries); } else { - m_pairingErrorSlots.invoke(reply->errorMessage(), m_pairingRetryCnt, m_maxPairingRetries); + m_pairingErrorSlots.invoke(reply->errorMessage(), m_pairingRetryCnt); m_pairingRetryCnt = 0; + m_maxPairingRetries = 0; } } else { XLOGD_DEBUG("%s pairing request successful", m_address.toString().c_str()); diff --git a/src/ble/hal/blercu/bluez/blercudevice_p.h b/src/ble/hal/blercu/bluez/blercudevice_p.h index 39ecd86c..0700b227 100644 --- a/src/ble/hal/blercu/bluez/blercudevice_p.h +++ b/src/ble/hal/blercu/bluez/blercudevice_p.h @@ -92,7 +92,7 @@ class BleRcuDeviceBluez : public BleRcuDevice public: std::string bluezObjectPath() const; - void pair(int timeout); + void pair(int timeout, int retries); void cancelPairing(); void connect(); diff --git a/src/telemetry/ctrlm_telemetry_event.cpp b/src/telemetry/ctrlm_telemetry_event.cpp index 6ab33336..f6bda2d1 100644 --- a/src/telemetry/ctrlm_telemetry_event.cpp +++ b/src/telemetry/ctrlm_telemetry_event.cpp @@ -38,7 +38,7 @@ bool ctrlm_telemetry_event_t::event() const { XLOGD_ERROR("telemetry event <%s> dropped: value length <%zu> exceeds maximum <%d> bytes", this->marker.c_str(), this->value.length(), - this->CTRLM_TELEMETRY_MAX_EVENT_SIZE_BYTES); + CTRLM_TELEMETRY_MAX_EVENT_SIZE_BYTES); return false; } else { XLOGD_TELEMETRY("telemetry event <%s, %s>", this->marker.c_str(), this->value.c_str()); diff --git a/src/telemetry/ctrlm_telemetry_markers.h b/src/telemetry/ctrlm_telemetry_markers.h index a7c5d3f3..c3ef8579 100644 --- a/src/telemetry/ctrlm_telemetry_markers.h +++ b/src/telemetry/ctrlm_telemetry_markers.h @@ -134,10 +134,9 @@ // [,,,,,,,,,,] // - version of the marker format. // - type of network the marker is coming from -// - enum representing pairing method: "auto_timeout" | "ir_code" | "mac_hash" | "mac_list" +// - enum representing pairing method // - number of discovered devices from pairing attempt -// - enum that represents "success" or failure reason: "discovery_timeout" | "discovery_stopped" | "discovery_stop_timeout" | -// "pairing_timeout" | "bluez_error" | "adapter_off" | "device_unpaired" | "device_removed" | "cancelled" +// - enum that represents "success" or failure reason // - MAC address string of paired device, empty string on failure // - name of paired remote, empty string on failure // - number of bluez pair() retries made before success or final error From 338728cdee9edded5c4e5a1047a8fa3ac2d8cb50 Mon Sep 17 00:00:00 2001 From: klu339 Date: Wed, 8 Apr 2026 19:34:25 +0000 Subject: [PATCH 08/12] copilot code review comments --- src/ble/hal/blercu/blercupairingstatemachine.cpp | 1 - src/ble/hal/blercu/blercupairingstatemachine.h | 1 - src/ble/hal/blercu/bluez/blercuadapter.cpp | 4 ++-- src/ble/hal/blercu/bluez/blercudevice.cpp | 1 - src/telemetry/ctrlm_telemetry_markers.h | 4 ++-- 5 files changed, 4 insertions(+), 7 deletions(-) diff --git a/src/ble/hal/blercu/blercupairingstatemachine.cpp b/src/ble/hal/blercu/blercupairingstatemachine.cpp index 9b854768..a32fa2df 100644 --- a/src/ble/hal/blercu/blercupairingstatemachine.cpp +++ b/src/ble/hal/blercu/blercupairingstatemachine.cpp @@ -55,7 +55,6 @@ BleRcuPairingStateMachine::BleRcuPairingStateMachine(const shared_ptr m_discoveredDevices; int m_bluezRetries; - int m_bluezMaxRetries; BleAddress m_pairedMac; std::vector m_bluezErrorMsg; diff --git a/src/ble/hal/blercu/bluez/blercuadapter.cpp b/src/ble/hal/blercu/bluez/blercuadapter.cpp index acd9bf62..11fcd759 100644 --- a/src/ble/hal/blercu/bluez/blercuadapter.cpp +++ b/src/ble/hal/blercu/bluez/blercuadapter.cpp @@ -1216,10 +1216,10 @@ bool BleRcuAdapterBluez::isDeviceConnected(const BleAddress &address) const // ----------------------------------------------------------------------------- /*! - \fn void BleRcuManager::addDevice(const BleAddress &address) + \fn void BleRcuManager::addDevice(const BleAddress &address, int retries) Sends a request to the bluez daemon to pair the device with the given - \a address. The request is sent even if the device is already paired, + \a address and \a retries. The request is sent even if the device is already paired, this is to handle the case where a pending unpair notification is sitting in the dbus queue but not yet processed. diff --git a/src/ble/hal/blercu/bluez/blercudevice.cpp b/src/ble/hal/blercu/bluez/blercudevice.cpp index fcf7f315..8b6bddf9 100644 --- a/src/ble/hal/blercu/bluez/blercudevice.cpp +++ b/src/ble/hal/blercu/bluez/blercudevice.cpp @@ -275,7 +275,6 @@ void BleRcuDeviceBluez::onPairRequestReply(PendingReply<> *reply) } else { m_pairingErrorSlots.invoke(reply->errorMessage(), m_pairingRetryCnt); m_pairingRetryCnt = 0; - m_maxPairingRetries = 0; } } else { XLOGD_DEBUG("%s pairing request successful", m_address.toString().c_str()); diff --git a/src/telemetry/ctrlm_telemetry_markers.h b/src/telemetry/ctrlm_telemetry_markers.h index c3ef8579..18a53068 100644 --- a/src/telemetry/ctrlm_telemetry_markers.h +++ b/src/telemetry/ctrlm_telemetry_markers.h @@ -134,9 +134,9 @@ // [,,,,,,,,,,] // - version of the marker format. // - type of network the marker is coming from -// - enum representing pairing method +// - enum representing pairing method (see PairingMethod) // - number of discovered devices from pairing attempt -// - enum that represents "success" or failure reason +// - enum that represents "success" or failure reason (see FailureReason) // - MAC address string of paired device, empty string on failure // - name of paired remote, empty string on failure // - number of bluez pair() retries made before success or final error From ca530bd32672ac24c749f92eeb196fbec24661e8 Mon Sep 17 00:00:00 2001 From: klu339 Date: Tue, 21 Apr 2026 20:10:33 +0000 Subject: [PATCH 09/12] Removing RCU mac address for PII concerns --- src/ble/ctrlm_ble_network.cpp | 1 - src/ble/hal/blercu/blercucontroller.cpp | 2 -- src/ble/hal/blercu/blercucontroller.h | 1 - src/ble/hal/blercu/blercupairingstatemachine.cpp | 5 ----- src/ble/hal/blercu/blercupairingstatemachine.h | 1 - src/telemetry/ctrlm_telemetry_markers.h | 3 +-- 6 files changed, 1 insertion(+), 12 deletions(-) diff --git a/src/ble/ctrlm_ble_network.cpp b/src/ble/ctrlm_ble_network.cpp index 5d8a43f7..63c1bf51 100644 --- a/src/ble/ctrlm_ble_network.cpp +++ b/src/ble/ctrlm_ble_network.cpp @@ -1700,7 +1700,6 @@ void ctrlm_obj_network_ble_t::ind_process_rcu_pairing_outcome(void *data, int si ss << outcome->method << ","; ss << outcome->result << ","; ss << outcome->discovered << ","; - ss << "\"" << outcome->pairedMac << "\","; ss << "\"" << outcome->name << "\","; ss << outcome->bluezRetries << ","; diff --git a/src/ble/hal/blercu/blercucontroller.cpp b/src/ble/hal/blercu/blercucontroller.cpp index b76b5d00..deb59392 100644 --- a/src/ble/hal/blercu/blercucontroller.cpp +++ b/src/ble/hal/blercu/blercucontroller.cpp @@ -613,7 +613,6 @@ void BleRcuControllerImpl::onFinishedPairing() outcome.result = BleRcuPairingStateMachine::SUCCESS; outcome.bluezRetries = m_pairingStateMachine.bluezRetries(); outcome.maxBluezRetries = MAX_PAIRING_RETRIES; - outcome.pairedMac = m_pairingStateMachine.pairedMac().toString(); outcome.name = m_pairingStateMachine.pairedName(); outcome.discovered = m_pairingStateMachine.discoveredDevices(); m_pairingOutcomeSlots.invoke(outcome); @@ -663,7 +662,6 @@ void BleRcuControllerImpl::onFailedPairing() outcome.result = m_pairingStateMachine.failureReason(); outcome.bluezRetries = m_pairingStateMachine.bluezRetries(); outcome.maxBluezRetries = MAX_PAIRING_RETRIES; - outcome.pairedMac = m_pairingStateMachine.pairedMac().toString(); outcome.bluezError = m_pairingStateMachine.bluezError(); outcome.discovered = m_pairingStateMachine.discoveredDevices(); outcome.name = ""; diff --git a/src/ble/hal/blercu/blercucontroller.h b/src/ble/hal/blercu/blercucontroller.h index 5ca104f2..dd612cc1 100644 --- a/src/ble/hal/blercu/blercucontroller.h +++ b/src/ble/hal/blercu/blercucontroller.h @@ -50,7 +50,6 @@ struct BleRcuPairingOutcome int discovered; // number of discovered devices int bluezRetries; // number of bluez retries attempted int maxBluezRetries; // max number of retries - std::string pairedMac; // empty on failure std::string name; // empty on failure std::vector bluezError; // bluez error messages }; diff --git a/src/ble/hal/blercu/blercupairingstatemachine.cpp b/src/ble/hal/blercu/blercupairingstatemachine.cpp index a32fa2df..41063870 100644 --- a/src/ble/hal/blercu/blercupairingstatemachine.cpp +++ b/src/ble/hal/blercu/blercupairingstatemachine.cpp @@ -229,11 +229,6 @@ int BleRcuPairingStateMachine::bluezRetries() const return m_bluezRetries; } -BleAddress BleRcuPairingStateMachine::pairedMac() const -{ - return m_pairedMac; -} - std::string BleRcuPairingStateMachine::pairedName() const { auto it = m_discoveredDevices.find(m_pairedMac); diff --git a/src/ble/hal/blercu/blercupairingstatemachine.h b/src/ble/hal/blercu/blercupairingstatemachine.h index f44d4fba..00068a52 100644 --- a/src/ble/hal/blercu/blercupairingstatemachine.h +++ b/src/ble/hal/blercu/blercupairingstatemachine.h @@ -100,7 +100,6 @@ class BleRcuPairingStateMachine FailureReason failureReason() const; int discoveredDevices() const; int bluezRetries() const; - BleAddress pairedMac() const; std::string pairedName() const; std::vector bluezError() const; diff --git a/src/telemetry/ctrlm_telemetry_markers.h b/src/telemetry/ctrlm_telemetry_markers.h index 18a53068..4ee68153 100644 --- a/src/telemetry/ctrlm_telemetry_markers.h +++ b/src/telemetry/ctrlm_telemetry_markers.h @@ -131,13 +131,12 @@ // BLE RCU Pairing Attempt Marker // Value format: Array of comma separated integers or string with the fields below. -// [,,,,,,,,,,] +// [,,,,,,,,,] // - version of the marker format. // - type of network the marker is coming from // - enum representing pairing method (see PairingMethod) // - number of discovered devices from pairing attempt // - enum that represents "success" or failure reason (see FailureReason) -// - MAC address string of paired device, empty string on failure // - name of paired remote, empty string on failure // - number of bluez pair() retries made before success or final error // - error message of bluez layer, empty if no errors From 995b947c581a8d0a872f2dc144feb4ec63f2f8be Mon Sep 17 00:00:00 2001 From: klu339 Date: Tue, 21 Apr 2026 21:15:05 +0000 Subject: [PATCH 10/12] another round of copilot comments --- src/ble/hal/blercu/blercuadapter.h | 2 +- src/ble/hal/blercu/blercucontroller.h | 5 ++--- src/ble/hal/blercu/blercudevice.h | 4 ++-- src/ble/hal/blercu/blercupairingstatemachine.cpp | 9 +++++---- src/ble/hal/blercu/blercupairingstatemachine.h | 2 +- src/ble/hal/blercu/bluez/blercuadapter.cpp | 9 +++++---- src/ble/hal/blercu/bluez/blercudevice.cpp | 4 ++-- 7 files changed, 18 insertions(+), 17 deletions(-) diff --git a/src/ble/hal/blercu/blercuadapter.h b/src/ble/hal/blercu/blercuadapter.h index 1fcee795..d37ec688 100644 --- a/src/ble/hal/blercu/blercuadapter.h +++ b/src/ble/hal/blercu/blercuadapter.h @@ -135,7 +135,7 @@ class BleRcuAdapter Slots m_deviceFoundSlots; Slots m_deviceRemovedSlots; Slots m_deviceNameChangedSlots; - Slots m_devicePairingErrorSlots; + Slots m_devicePairingErrorSlots; Slots m_devicePairingChangedSlots; Slots m_deviceReadyChangedSlots; diff --git a/src/ble/hal/blercu/blercucontroller.h b/src/ble/hal/blercu/blercucontroller.h index dd612cc1..b4eab730 100644 --- a/src/ble/hal/blercu/blercucontroller.h +++ b/src/ble/hal/blercu/blercucontroller.h @@ -45,8 +45,8 @@ class BleRcuDevice; struct BleRcuPairingOutcome { - int method; // "auto_timeout" | "ir_code" | "mac_hash" | "mac_list" - int result; // "success" | failure-reason string + int method; // numeric enum value for PairingMethod + int result; // numeric enum value for FailureReason int discovered; // number of discovered devices int bluezRetries; // number of bluez retries attempted int maxBluezRetries; // max number of retries @@ -54,7 +54,6 @@ struct BleRcuPairingOutcome std::vector bluezError; // bluez error messages }; - class BleRcuController { public: diff --git a/src/ble/hal/blercu/blercudevice.h b/src/ble/hal/blercu/blercudevice.h index b77cfba7..ef297db7 100644 --- a/src/ble/hal/blercu/blercudevice.h +++ b/src/ble/hal/blercu/blercudevice.h @@ -187,7 +187,7 @@ class BleRcuDevice { m_readyChangedSlots.addSlot(func); } - inline void addPairingErrorSlot(const Slot &func) + inline void addPairingErrorSlot(const Slot &func) { m_pairingErrorSlots.addSlot(func); } @@ -198,7 +198,7 @@ class BleRcuDevice Slots m_pairedChangedSlots; Slots m_nameChangedSlots; Slots m_readyChangedSlots; - Slots m_pairingErrorSlots; + Slots m_pairingErrorSlots; }; diff --git a/src/ble/hal/blercu/blercupairingstatemachine.cpp b/src/ble/hal/blercu/blercupairingstatemachine.cpp index 41063870..0779fb69 100644 --- a/src/ble/hal/blercu/blercupairingstatemachine.cpp +++ b/src/ble/hal/blercu/blercupairingstatemachine.cpp @@ -87,8 +87,8 @@ BleRcuPairingStateMachine::BleRcuPairingStateMachine(const shared_ptraddPoweredChangedSlot(Slot(m_isAlive, std::bind(&BleRcuPairingStateMachine::onAdapterPoweredChanged, this, std::placeholders::_1))); - m_adapter->addDevicePairingErrorSlot(Slot(m_isAlive, - std::bind(&BleRcuPairingStateMachine::onDevicePairingError, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3))); + m_adapter->addDevicePairingErrorSlot(Slot(m_isAlive, + std::bind(&BleRcuPairingStateMachine::onDevicePairingError, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4))); } BleRcuPairingStateMachine::~BleRcuPairingStateMachine() @@ -1026,7 +1026,8 @@ void BleRcuPairingStateMachine::onDeviceNameChanged(const BleAddress &address, */ void BleRcuPairingStateMachine::onDevicePairingError(const BleAddress &address, const string &error, - int retryCnt) + int retryCnt, + bool finalRetry) { if (!m_stateMachine.isRunning()) { return; @@ -1036,7 +1037,7 @@ void BleRcuPairingStateMachine::onDevicePairingError(const BleAddress &address, m_bluezRetries = retryCnt; m_bluezErrorMsg.push_back(error); - if (retryCnt < MAX_PAIRING_RETRIES) { + if (!finalRetry) { // Still retrying so don't stop pairing and timers yet return; } diff --git a/src/ble/hal/blercu/blercupairingstatemachine.h b/src/ble/hal/blercu/blercupairingstatemachine.h index 00068a52..f0ba15e8 100644 --- a/src/ble/hal/blercu/blercupairingstatemachine.h +++ b/src/ble/hal/blercu/blercupairingstatemachine.h @@ -144,7 +144,7 @@ class BleRcuPairingStateMachine void onDeviceNameChanged(const BleAddress &address, const std::string &name); void onDevicePairingChanged(const BleAddress &address, bool paired); void onDeviceReadyChanged(const BleAddress &address, bool ready); - void onDevicePairingError(const BleAddress &address, const std::string &error, int retryCnt); + void onDevicePairingError(const BleAddress &address, const std::string &error, int retryCnt, bool finalRetry); void onAdapterPoweredChanged(bool powered); diff --git a/src/ble/hal/blercu/bluez/blercuadapter.cpp b/src/ble/hal/blercu/bluez/blercuadapter.cpp index 11fcd759..ea05fbc4 100644 --- a/src/ble/hal/blercu/bluez/blercuadapter.cpp +++ b/src/ble/hal/blercu/bluez/blercuadapter.cpp @@ -1245,8 +1245,8 @@ bool BleRcuAdapterBluez::addDevice(const BleAddress &address, int retries) XLOGD_INFO("requesting bluez pair %s", device->address().toString().c_str()); - device->addPairingErrorSlot(Slot(m_isAlive, - std::bind(&BleRcuAdapterBluez::onDevicePairingError, this, address, std::placeholders::_1, std::placeholders::_2))); + device->addPairingErrorSlot(Slot(m_isAlive, + std::bind(&BleRcuAdapterBluez::onDevicePairingError, this, address, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3))); device->pair(0, retries); @@ -1689,9 +1689,10 @@ void BleRcuAdapterBluez::onDeviceNameChanged(const BleAddress &address, */ void BleRcuAdapterBluez::onDevicePairingError(const BleAddress &address, const std::string &error, - int retryCnt) + int retryCnt, + bool finalRetry) { - m_devicePairingErrorSlots.invoke(address, error, retryCnt); + m_devicePairingErrorSlots.invoke(address, error, retryCnt, finalRetry); } // ----------------------------------------------------------------------------- diff --git a/src/ble/hal/blercu/bluez/blercudevice.cpp b/src/ble/hal/blercu/bluez/blercudevice.cpp index 8b6bddf9..575c8a5f 100644 --- a/src/ble/hal/blercu/bluez/blercudevice.cpp +++ b/src/ble/hal/blercu/bluez/blercudevice.cpp @@ -270,10 +270,10 @@ void BleRcuDeviceBluez::onPairRequestReply(PendingReply<> *reply) if (m_pairingRetryCnt < m_maxPairingRetries) { m_pairingRetryCnt++; XLOGD_INFO("Retrying pairing, attempt %d out of %d ", m_pairingRetryCnt, m_maxPairingRetries); - m_pairingErrorSlots.invoke(reply->errorMessage(), m_pairingRetryCnt); + m_pairingErrorSlots.invoke(reply->errorMessage(), m_pairingRetryCnt, false); pair(0, m_maxPairingRetries); } else { - m_pairingErrorSlots.invoke(reply->errorMessage(), m_pairingRetryCnt); + m_pairingErrorSlots.invoke(reply->errorMessage(), m_pairingRetryCnt, true); m_pairingRetryCnt = 0; } } else { From 790d62e7c04b414944ad9701c02ca37153a8c8eb Mon Sep 17 00:00:00 2001 From: klu339 Date: Thu, 23 Apr 2026 15:30:27 +0000 Subject: [PATCH 11/12] compile error --- src/ble/hal/blercu/blercuadapter.h | 2 +- src/ble/hal/blercu/bluez/blercuadapter_p.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ble/hal/blercu/blercuadapter.h b/src/ble/hal/blercu/blercuadapter.h index d37ec688..3407c25e 100644 --- a/src/ble/hal/blercu/blercuadapter.h +++ b/src/ble/hal/blercu/blercuadapter.h @@ -107,7 +107,7 @@ class BleRcuAdapter { m_deviceNameChangedSlots.addSlot(func); } - inline void addDevicePairingErrorSlot(const Slot &func) + inline void addDevicePairingErrorSlot(const Slot &func) { m_devicePairingErrorSlots.addSlot(func); } diff --git a/src/ble/hal/blercu/bluez/blercuadapter_p.h b/src/ble/hal/blercu/bluez/blercuadapter_p.h index c283f9d1..33a2e48d 100644 --- a/src/ble/hal/blercu/bluez/blercuadapter_p.h +++ b/src/ble/hal/blercu/bluez/blercuadapter_p.h @@ -113,7 +113,7 @@ class BleRcuAdapterBluez : public BleRcuAdapter const std::vector &interfaces); void onDeviceNameChanged(const BleAddress &address, const std::string &name); - void onDevicePairingError(const BleAddress &address, const std::string &error, int retryCnt); + void onDevicePairingError(const BleAddress &address, const std::string &error, int retryCnt, bool finalRetry); void onDevicePairedChanged(const BleAddress &address, bool paired); void onDeviceReadyChanged(const BleAddress &address, bool ready); From c95a39d127002ecec031a110581b5cedd473b028 Mon Sep 17 00:00:00 2001 From: klu339 Date: Wed, 20 May 2026 20:50:14 +0000 Subject: [PATCH 12/12] rebase and marker needs accum suffix --- src/ble/hal/blercu/blercupairingstatemachine.h | 1 - src/telemetry/ctrlm_telemetry_markers.h | 8 +++++--- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/src/ble/hal/blercu/blercupairingstatemachine.h b/src/ble/hal/blercu/blercupairingstatemachine.h index f0ba15e8..1886f3a7 100644 --- a/src/ble/hal/blercu/blercupairingstatemachine.h +++ b/src/ble/hal/blercu/blercupairingstatemachine.h @@ -52,7 +52,6 @@ class BleRcuPairingStateMachine AUTO_TIMEOUT, MAC_LIST, IR_CODE, - MAC_HASH }; enum FailureReason { diff --git a/src/telemetry/ctrlm_telemetry_markers.h b/src/telemetry/ctrlm_telemetry_markers.h index 4ee68153..684ec2b3 100644 --- a/src/telemetry/ctrlm_telemetry_markers.h +++ b/src/telemetry/ctrlm_telemetry_markers.h @@ -135,12 +135,14 @@ // - version of the marker format. // - type of network the marker is coming from // - enum representing pairing method (see PairingMethod) -// - number of discovered devices from pairing attempt // - enum that represents "success" or failure reason (see FailureReason) +// - number of discovered devices from pairing attempt // - name of paired remote, empty string on failure // - number of bluez pair() retries made before success or final error -// - error message of bluez layer, empty if no errors -#define MARKER_RCU_PAIRING_ATTEMPT "ctrlm.rcu.pairing.attempt" +// - error message 1 from bluez layer or null if no error +// - error message 2 from bluez layer or null if no error +// - error message 3 from bluez layer or null if no error +#define MARKER_RCU_PAIRING_ATTEMPT "ctrlm.rcu.pairing.attempt_accum" #define MARKER_RCU_PAIRING_ATTEMPT_VERSION 1 //