diff --git a/src/ble/ctrlm_ble_network.cpp b/src/ble/ctrlm_ble_network.cpp index 64ec4984..a0f37652 100644 --- a/src/ble/ctrlm_ble_network.cpp +++ b/src/ble/ctrlm_ble_network.cpp @@ -2797,7 +2797,33 @@ void ctrlm_obj_network_ble_t::power_state_change(gboolean waking_up) { } void ctrlm_obj_network_ble_t::rfc_retrieved_handler(const ctrlm_rfc_attr_t &attr) { - // TODO - No RFC parameters as of now + XLOGD_INFO("process BLE RFC values"); + + // Process options object + bool disable_voice = false; + if(attr.get_rfc_value(JSON_OBJ_NAME_NETWORK_BLE_OPTIONS JSON_PATH_SEPERATOR JSON_BOOL_NAME_NETWORK_BLE_OPTIONS_DISABLE_VOICE, disable_voice)) { + voice_disabled_ = disable_voice; + XLOGD_INFO("BLE voice support is %s by config", voice_disabled_ ? "disabled" : "enabled"); + } + + auto config = getConfigSettings(); + if (config == nullptr) { + XLOGD_ERROR("config not available"); + return; + } + + json_t *obj = nullptr; + if(!attr.get_rfc_json_value(&obj)) { + XLOGD_ERROR("failed to get RFC json object"); + return; + } + + // Update config settings from RFC json object + bool updated = config->updateFromJson(obj); + if(!updated) { + XLOGD_WARN("no BLE config updates found in RFC"); + } + json_decref(obj); } std::vector ctrlm_obj_network_ble_t::get_controller_obj_list() const { diff --git a/src/ble/hal/blercu/blercupairingstatemachine.cpp b/src/ble/hal/blercu/blercupairingstatemachine.cpp index 0779fb69..8fa38aa5 100644 --- a/src/ble/hal/blercu/blercupairingstatemachine.cpp +++ b/src/ble/hal/blercu/blercupairingstatemachine.cpp @@ -44,11 +44,8 @@ BleRcuPairingStateMachine::BleRcuPairingStateMachine(const shared_ptrdiscoveryTimeout()) - , m_discoveryTimeoutDefault(config->discoveryTimeout()) - , m_pairingTimeout(config->pairingTimeout()) - , m_setupTimeout(config->setupTimeout()) - , m_unpairingTimeout(config->upairingTimeout()) , m_pairingAttempts(0) , m_pairingSuccesses(0) , m_pairingSucceeded(false) @@ -287,6 +284,7 @@ void BleRcuPairingStateMachine::startAutoWithTimeout(int timeoutMs) m_pairingAttempts++; m_pairingSucceeded = false; XLOGD_INFO("Started auto pairing procedure"); + XLOGD_DEBUG("timeouts - discovery <%d ms> pairing <%d ms> setup <%d ms> unpairing <%d ms>", m_discoveryTimeout, m_config->pairingTimeout(), m_config->setupTimeout(), m_config->upairingTimeout()); } @@ -304,7 +302,7 @@ void BleRcuPairingStateMachine::startWithCode(uint8_t pairingCode) return; } - m_discoveryTimeout = m_discoveryTimeoutDefault; + m_discoveryTimeout = m_config->discoveryTimeout(); // use the default discovery timeout for this pairing method m_isAutoPairing = false; // clear the target device @@ -345,6 +343,7 @@ void BleRcuPairingStateMachine::startWithCode(uint8_t pairingCode) m_pairingAttempts++; m_pairingSucceeded = false; XLOGD_INFO("started pairing, searching for device with prefix code %03d or MAC hash 0x%02X", m_pairingCode, m_pairingMacHash); + XLOGD_DEBUG("timeouts - discovery <%d ms> pairing <%d ms> setup <%d ms> unpairing <%d ms>", m_discoveryTimeout, m_config->pairingTimeout(), m_config->setupTimeout(), m_config->upairingTimeout()); } // ----------------------------------------------------------------------------- @@ -360,6 +359,8 @@ void BleRcuPairingStateMachine::startWithMacList(const std::vector & return; } + m_discoveryTimeout = m_config->discoveryTimeout(); // use the default discovery timeout for this pairing method + // clear the target device m_targetAddress.clear(); @@ -389,7 +390,7 @@ void BleRcuPairingStateMachine::startWithMacList(const std::vector & for (const auto &address : macList) { XLOGD_INFO("<%s>", address.toString().c_str()); } - + XLOGD_DEBUG("timeouts - discovery <%d ms> pairing <%d ms> setup <%d ms> unpairing <%d ms>", m_discoveryTimeout, m_config->pairingTimeout(), m_config->setupTimeout(), m_config->upairingTimeout()); } @@ -511,9 +512,9 @@ void BleRcuPairingStateMachine::onStateTransition(int oldState, int newState) } } else if (newState == UnpairingState) { if (oldState == EnablePairableState || oldState == PairingState) { - XLOGD_AUTOMATION_WARN("timed-out in pairing phase (rcu device didn't pair within %dms)", m_pairingTimeout); + XLOGD_AUTOMATION_WARN("timed-out in pairing phase (rcu device didn't pair within %dms)", m_config->pairingTimeout()); } else if (oldState == SetupState) { - XLOGD_AUTOMATION_WARN("timed-out in setup phase (rcu didn't response to all requests within %dms)", m_setupTimeout); + XLOGD_AUTOMATION_WARN("timed-out in setup phase (rcu didn't response to all requests within %dms)", m_config->setupTimeout()); } } @@ -643,7 +644,7 @@ void BleRcuPairingStateMachine::onExitedDiscoverySuperState() void BleRcuPairingStateMachine::onEnteredStoppingDiscoveryState() { // start the pairing timeout timer - m_stateMachine.postDelayedEvent(PairingTimeoutEvent, m_pairingTimeout); + m_stateMachine.postDelayedEvent(PairingTimeoutEvent, m_config->pairingTimeout()); // if we've got to this state it means we have a target device if (m_targetAddress.isNull()) { @@ -708,7 +709,7 @@ void BleRcuPairingStateMachine::onEnteredEnablePairableState() // in pairable mode because we don't know if the previous timeout is long enough for our purposes. // The timeout is set to 5 seconds past the overall time we've given the state machine // to pair with the rcu. - m_adapter->enablePairable(m_pairingTimeout + 5000); + m_adapter->enablePairable(m_config->pairingTimeout() + 5000); if (m_adapter->isPairable()) { // is already pairable so just post the 'enabled' event @@ -748,8 +749,9 @@ void BleRcuPairingStateMachine::onEnteredPairingState() void BleRcuPairingStateMachine::onEnteredSetupState() { // start the setup timeout timer - m_stateMachine.postDelayedEvent(SetupTimeoutEvent, m_setupTimeout); - XLOGD_DEBUG("starting setup timeout timer for %dms", m_setupTimeout); + int timeout = m_config->setupTimeout(); + m_stateMachine.postDelayedEvent(SetupTimeoutEvent, timeout); + XLOGD_DEBUG("starting setup timeout timer for %dms", timeout); } // ----------------------------------------------------------------------------- @@ -781,7 +783,7 @@ void BleRcuPairingStateMachine::onExitedPairingSuperState() void BleRcuPairingStateMachine::onEnteredUnpairingState() { // start the unpairing timeout timer - m_stateMachine.postDelayedEvent(UnpairingTimeoutEvent, m_unpairingTimeout); + m_stateMachine.postDelayedEvent(UnpairingTimeoutEvent, m_config->upairingTimeout()); // if we've got to this state it means we have a target device if (m_targetAddress.isNull()) { diff --git a/src/ble/hal/blercu/blercupairingstatemachine.h b/src/ble/hal/blercu/blercupairingstatemachine.h index f3d18178..2988f198 100644 --- a/src/ble/hal/blercu/blercupairingstatemachine.h +++ b/src/ble/hal/blercu/blercupairingstatemachine.h @@ -192,11 +192,9 @@ class BleRcuPairingStateMachine StateMachine m_stateMachine; + const std::shared_ptr m_config; + int m_discoveryTimeout; - int m_discoveryTimeoutDefault; - int m_pairingTimeout; - int m_setupTimeout; - int m_unpairingTimeout; int m_pairingAttempts; int m_pairingSuccesses; diff --git a/src/ble/hal/configsettings/configsettings.cpp b/src/ble/hal/configsettings/configsettings.cpp index ce8cc3a7..29539642 100644 --- a/src/ble/hal/configsettings/configsettings.cpp +++ b/src/ble/hal/configsettings/configsettings.cpp @@ -200,6 +200,37 @@ std::shared_ptr ConfigSettings::parseJson(json_t *jsonConfig) return std::make_shared(timeouts, std::move(models)); } +// ----------------------------------------------------------------------------- +/*! + Parses a json config file and updates the existing object. Any unrecognized fields are ignored. + + \see defaults() + */ +bool ConfigSettings::updateJson(json_t *jsonConfig) +{ + bool updated = false; + + if (jsonConfig == nullptr || !json_is_object(jsonConfig)) { + XLOGD_WARN("invalid json config"); + return(updated); + } + + // find the timeout params + json_t *timeoutsObj = json_object_get(jsonConfig, "timeouts"); + if (timeoutsObj && json_is_object(timeoutsObj)) { + m_timeOuts = parseTimeouts(timeoutsObj); + updated = true; + } + + // find the model details array + json_t *modelArray = json_object_get(jsonConfig, "models"); + if (modelArray && json_is_array(modelArray)) { + XLOGD_WARN("models cannot be updated"); + } + + return(updated); +} + // ----------------------------------------------------------------------------- /*! Parses a json config file and returns a \l{std::shared_ptr} to a @@ -378,3 +409,11 @@ int ConfigSettings::hidrawWaitLimitTimeout() const return m_timeOuts.hidrawWaitLimitMSecs; } +// ----------------------------------------------------------------------------- +/*! + Returns true if any of the config fields are updated. Otherwise, returns false. + */ +bool ConfigSettings::updateFromJson(json_t *jsonConfig) +{ + return updateJson(jsonConfig); +} diff --git a/src/ble/hal/configsettings/configsettings.h b/src/ble/hal/configsettings/configsettings.h index 5a4d5e9b..c51c9491 100644 --- a/src/ble/hal/configsettings/configsettings.h +++ b/src/ble/hal/configsettings/configsettings.h @@ -48,6 +48,7 @@ class ConfigSettings static std::shared_ptr fromJsonFile(const std::string &filePath); static std::shared_ptr fromJsonBuffer(const char *jsonBuffer); static std::shared_ptr parseJson(json_t *jsonConfig); + bool updateJson(json_t *jsonConfig); struct TimeOuts { int discoveryMSecs; @@ -65,6 +66,7 @@ class ConfigSettings std::vector &&modelDetails); public: + bool updateFromJson(json_t *jsonConfig); int discoveryTimeout() const; int pairingTimeout() const; int setupTimeout() const; @@ -80,11 +82,9 @@ class ConfigSettings static TimeOuts parseTimeouts(json_t *json); private: - const TimeOuts m_timeOuts; + TimeOuts m_timeOuts; const std::vector m_modelDetails; }; -// QDebug operator<<(QDebug dbg, const ConfigSettings &settings); - #endif // !defined(CONFIGSETTINGS_H)