samples: matter: Added BT recovery mechanism to Matter Bridge.

applications/matter_bridge/CMakeLists.txt

@@ -46,6 +46,7 @@ target_sources(app PRIVATE
  ${COMMON_ROOT}/src/bridge/bridge_manager.cpp
  ${COMMON_ROOT}/src/bridge/bridged_device.cpp
  ${COMMON_ROOT}/src/bridge/bridge_storage_manager.cpp
+ ${COMMON_ROOT}/src/bridge/bridged_device_data_provider.cpp
  src/zap-generated/IMClusterCommandHandler.cpp
  src/zap-generated/callback-stub.cpp
  ${COMMON_ROOT}/src/led_widget.cpp

applications/matter_bridge/src/bridged_device_types/ble_onoff_light_data_provider.cpp

@@ -60,8 +60,7 @@ void BleOnOffLightDataProvider::NotifyUpdateState(chip::ClusterId clusterId, chi
  size_t dataSize)
 {
  if (mUpdateAttributeCallback) {
- mUpdateAttributeCallback(*this, Clusters::OnOff::Id, Clusters::OnOff::Attributes::OnOff::Id, data,
- dataSize);
+ mUpdateAttributeCallback(*this, clusterId, attributeId, data, dataSize);
  }
 }
 

applications/matter_bridge/src/bridged_device_types/onoff_light.cpp

@@ -112,28 +112,37 @@ CHIP_ERROR OnOffLightDevice::HandleWrite(ClusterId clusterId, AttributeId attrib
 CHIP_ERROR OnOffLightDevice::HandleAttributeChange(chip::ClusterId clusterId, chip::AttributeId attributeId, void *data,
  size_t dataSize)
 {
- if (clusterId != Clusters::OnOff::Id || !data) {
+ if (!data) {
  return CHIP_ERROR_INVALID_ARGUMENT;
  }
 
- CHIP_ERROR err;
+ switch (clusterId) {
+ case Clusters::BridgedDeviceBasicInformation::Id:
+ HandleWriteDeviceBasicInformation(clusterId, attributeId, data, dataSize);
+ return CHIP_NO_ERROR;
+ case Clusters::OnOff::Id: {
+ switch (attributeId) {
+ case Clusters::OnOff::Attributes::OnOff::Id: {
+ CHIP_ERROR err;
 
- switch (attributeId) {
- case Clusters::OnOff::Attributes::OnOff::Id: {
- bool value;
+ bool value;
 
- err = CopyAttribute(data, dataSize, &value, sizeof(value));
+  err = CopyAttribute(data, dataSize, &value, sizeof(value));
 
- if (err != CHIP_NO_ERROR) {
- return err;
- }
+  if (err != CHIP_NO_ERROR) {
+  return err;
+  }
 
- SetOnOff(value);
- break;
+ SetOnOff(value);
+ break;
+ }
+ default:
+ return CHIP_ERROR_INVALID_ARGUMENT;
+ }
  }
  default:
  return CHIP_ERROR_INVALID_ARGUMENT;
  }
 
- return err;
+ return CHIP_ERROR_INVALID_ARGUMENT;
 }

samples/matter/common/src/bridge/Kconfig

@@ -11,3 +11,15 @@ config BRIDGE_MAX_DYNAMIC_ENDPOINTS_NUMBER
 config BRIDGE_MAX_BRIDGED_DEVICES_NUMBER
  int "Maximum number of physical non-Matter devices supported by the Bridge"
  default 16
+
+if BRIDGED_DEVICE_BT
+
+config BRIDGE_BT_RECOVERY_INTERVAL_MS
+ int "Time (in ms) between recovery attempts when the BLE connection to the bridged device is lost"
+ default 1000
+
+config BRIDGE_BT_RECOVERY_SCAN_TIMEOUT_MS
+ int "Time (in ms) within which the Bridge will try to re-establish a connection to the lost BT LE device"
+ default 2000
+
+endif

samples/matter/common/src/bridge/ble_bridged_device.h

@@ -33,8 +33,8 @@ struct BLEBridgedDevice {
  bool discoverySucceeded, void *context);
 
  bt_addr_le_t mAddr;
- DeviceConnectedCallback mConnectedCallback;
- void *mConnectedCallbackContext;
+ DeviceConnectedCallback mFirstConnectionCallback;
+ void *mFirstConnectionCallbackContext;
  bt_uuid *mServiceUuid;
  bt_conn *mConn;
  BLEBridgedDeviceProvider *mProvider;

samples/matter/common/src/bridge/ble_connectivity_manager.cpp

@@ -68,8 +68,8 @@ void BLEConnectivityManager::ConnectionHandler(bt_conn *conn, uint8_t conn_err)
 
  /* Find the created device instance based on address. */
  for (int i = 0; i < Instance().mCreatedDevicesCounter; i++) {
- if (memcmp(&Instance().mCreatedDevices[i].mAddr, addr,
-   sizeof(Instance().mCreatedDevices[i].mAddr)) == 0) {
+ if (memcmp(&Instance().mCreatedDevices[i].mAddr, addr, sizeof(Instance().mCreatedDevices[i].mAddr)) ==
+ 0) {
  device = &Instance().mCreatedDevices[i];
  break;
  }
@@ -79,10 +79,15 @@ void BLEConnectivityManager::ConnectionHandler(bt_conn *conn, uint8_t conn_err)
  return;
  }
 
- LOG_INF("Connected: %s", str_addr);
-
  /* TODO: Add security validation. */
 
+ if (conn_err && Instance().mRecovery.mRecoveryInProgress) {
+ Instance().mRecovery.PutDevice(device);
+ return;
+ }
+
+ LOG_INF("Connected: %s", str_addr);
+
  /* Start GATT discovery for the device's service UUID. */
  err = bt_gatt_dm_start(conn, device->mServiceUuid, &discovery_cb, device);
  if (err) {
@@ -94,19 +99,35 @@ void BLEConnectivityManager::ConnectionHandler(bt_conn *conn, uint8_t conn_err)
 
 void BLEConnectivityManager::DisconnectionHandler(bt_conn *conn, uint8_t reason)
 {
- char addr[BT_ADDR_LE_STR_LEN];
+ /* Verify whether the device should be recovered */
+ BLEBridgedDevice *device = Instance().FindBLEBridgedDevice(conn);
 
- bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
+ if (device) {
+ char addr[BT_ADDR_LE_STR_LEN];
+ bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
 
- LOG_INF("Disconnected: %s (reason %u)", addr, reason);
+  LOG_INF("Disconnected: %s (reason %u)", addr, reason);
 
- /* TODO: Implement connection re-establishment procedure. */
+ if (device->mConn) {
+ bt_conn_unref(device->mConn);
+ device->mConn = nullptr;
+ }
+
+ if (reason == BT_HCI_ERR_CONN_TIMEOUT) {
+ Instance().mRecovery.NotifyLostDevice(device);
+ if (device->mProvider) {
+ VerifyOrReturn(CHIP_NO_ERROR == device->mProvider->NotifyReachableStatusChange(false),
+ LOG_WRN("The device has not been notified about the status change."));
+ }
+ }
+
+ /* TODO Add removing a device when disconnection has been invoked by the user */
+ }
 }
 
 void BLEConnectivityManager::DiscoveryCompletedHandler(bt_gatt_dm *dm, void *context)
 {
  LOG_INF("The GATT discovery completed");
-
  BLEBridgedDevice *device = reinterpret_cast<BLEBridgedDevice *>(context);
  bool discoveryResult = false;
  const bt_gatt_dm_attr *gatt_service_attr = bt_gatt_dm_service_get(dm);
@@ -120,7 +141,22 @@ void BLEConnectivityManager::DiscoveryCompletedHandler(bt_gatt_dm *dm, void *con
  discoveryResult = true;
 exit:
 
- device->mConnectedCallback(device, dm, discoveryResult, device->mConnectedCallbackContext);
+ if (!Instance().mRecovery.mRecoveryInProgress) {
+ device->mFirstConnectionCallback(device, dm, discoveryResult, device->mFirstConnectionCallbackContext);
+ }
+
+ if (device->mProvider) {
+ VerifyOrReturn(CHIP_NO_ERROR == device->mProvider->NotifyReachableStatusChange(true),
+ LOG_WRN("The device has not been notified about the status change."));
+ }
+
+ Instance().mRecovery.mRecoveryInProgress = false;
+
+ if (Instance().mRecovery.IsNeeded()) {
+ Instance().mRecovery.StartTimer();
+ }
+
+ bt_gatt_dm_data_release(dm);
 }
 
 void BLEConnectivityManager::DiscoveryNotFound(bt_conn *conn, void *context)
@@ -129,7 +165,7 @@ void BLEConnectivityManager::DiscoveryNotFound(bt_conn *conn, void *context)
 
  BLEBridgedDevice *device = reinterpret_cast<BLEBridgedDevice *>(context);
 
- device->mConnectedCallback(device, nullptr, false, device->mConnectedCallbackContext);
+ device->mFirstConnectionCallback(device, nullptr, false, device->mFirstConnectionCallbackContext);
 }
 
 void BLEConnectivityManager::DiscoveryError(bt_conn *conn, int err, void *context)
@@ -138,7 +174,7 @@ void BLEConnectivityManager::DiscoveryError(bt_conn *conn, int err, void *contex
 
  BLEBridgedDevice *device = reinterpret_cast<BLEBridgedDevice *>(context);
 
- device->mConnectedCallback(device, nullptr, false, device->mConnectedCallbackContext);
+ device->mFirstConnectionCallback(device, nullptr, false, device->mFirstConnectionCallbackContext);
 }
 
 CHIP_ERROR BLEConnectivityManager::Init(bt_uuid **serviceUuids, uint8_t serviceUuidsCount)
@@ -180,7 +216,7 @@ CHIP_ERROR BLEConnectivityManager::Init(bt_uuid **serviceUuids, uint8_t serviceU
  return CHIP_NO_ERROR;
 }
 
-CHIP_ERROR BLEConnectivityManager::Scan(ScanDoneCallback callback, void *context)
+CHIP_ERROR BLEConnectivityManager::Scan(ScanDoneCallback callback, void *context, uint32_t scanTimeoutMs)
 {
  if (mScanActive) {
  LOG_ERR("Scan is already in progress");
@@ -201,12 +237,43 @@ CHIP_ERROR BLEConnectivityManager::Scan(ScanDoneCallback callback, void *context
  return System::MapErrorZephyr(err);
  }
 
- k_timer_start(&mScanTimer, K_MSEC(kScanTimeoutMs), K_NO_WAIT);
+ k_timer_start(&mScanTimer, K_MSEC(scanTimeoutMs), K_NO_WAIT);
  mScanActive = true;
 
  return CHIP_NO_ERROR;
 }
 
+void BLEConnectivityManager::ReScanCallback(ScannedDevice *devices, uint8_t count, void *context)
+{
+ LOG_DBG("Lost devices no. %d", Instance().mRecovery.GetCurrentAmount());
+ LOG_DBG("Found devices no. %d", Instance().mScannedDevicesCounter);
+
+ if (Instance().mScannedDevicesCounter != 0 && !Instance().mRecovery.mRecoveryInProgress) {
+ BLEBridgedDevice *deviceLost = Instance().mRecovery.GetDevice();
+ if (deviceLost) {
+ for (uint8_t idx = 0; idx < Instance().mScannedDevicesCounter; idx++) {
+ auto &deviceScanned = Instance().mScannedDevices[idx];
+ if (memcmp(&deviceScanned.mAddr, &deviceLost->mAddr, sizeof(deviceLost->mAddr)) == 0) {
+ LOG_DBG("Found the lost device");
+
+ Instance().mRecovery.mIndexToRecover = idx;
+ Instance().mRecovery.mCurrentDevice = deviceLost;
+ Instance().mRecovery.mRecoveryInProgress = true;
+
+ DeviceLayer::PlatformMgr().ScheduleWork(
+ [](intptr_t context) { Instance().Reconnect(); }, 0);
+ break;
+ }
+ }
+ if (!Instance().mRecovery.mRecoveryInProgress) {
+ Instance().mRecovery.NotifyLostDevice(deviceLost);
+ }
+ }
+ } else if (Instance().mRecovery.IsNeeded()) {
+ Instance().mRecovery.StartTimer();
+ }
+}
+
 CHIP_ERROR BLEConnectivityManager::StopScan()
 {
  if (!mScanActive) {
@@ -232,9 +299,25 @@ void BLEConnectivityManager::ScanTimeoutCallback(k_timer *timer)
 void BLEConnectivityManager::ScanTimeoutHandle(intptr_t context)
 {
  Instance().StopScan();
- Instance().mScanDoneCallback(Instance().mScannedDevices,
- Instance().mScannedDevicesCounter,
- Instance().mScanDoneCallbackContext);
+ Instance().mScanDoneCallback(Instance().mScannedDevices, Instance().mScannedDevicesCounter,
+ Instance().mScanDoneCallbackContext);
+}
+
+CHIP_ERROR BLEConnectivityManager::Reconnect()
+{
+ StopScan();
+
+ bt_conn *conn;
+
+ int err = bt_conn_le_create(&mScannedDevices[Instance().mRecovery.mIndexToRecover].mAddr, create_param,
+ &mScannedDevices[Instance().mRecovery.mIndexToRecover].mConnParam, &conn);
+
+ if (err) {
+ LOG_ERR("Creating reconnection failed (err %d)", err);
+ return System::MapErrorZephyr(err);
+ }
+
+ return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR BLEConnectivityManager::Connect(uint8_t index, BLEBridgedDevice::DeviceConnectedCallback callback,
@@ -267,8 +350,8 @@ CHIP_ERROR BLEConnectivityManager::Connect(uint8_t index, BLEBridgedDevice::Devi
  }
 
  mCreatedDevices[mCreatedDevicesCounter].mAddr = mScannedDevices[index].mAddr;
- mCreatedDevices[mCreatedDevicesCounter].mConnectedCallback = callback;
- mCreatedDevices[mCreatedDevicesCounter].mConnectedCallbackContext = context;
+ mCreatedDevices[mCreatedDevicesCounter].mFirstConnectionCallback = callback;
+ mCreatedDevices[mCreatedDevicesCounter].mFirstConnectionCallbackContext = context;
  mCreatedDevices[mCreatedDevicesCounter].mServiceUuid = serviceUuid;
  mCreatedDevicesCounter++;
 
@@ -295,3 +378,42 @@ BLEBridgedDevice *BLEConnectivityManager::FindBLEBridgedDevice(bt_conn *conn)
 
  return nullptr;
 }
+
+BLEConnectivityManager::Recovery::Recovery()
+{
+ ring_buf_init(&mRingBuf, sizeof(mDevicesToRecover), reinterpret_cast<uint8_t *>(mDevicesToRecover));
+ k_timer_init(&mRecoveryTimer, TimerTimeoutCallback, nullptr);
+ k_timer_user_data_set(&mRecoveryTimer, this);
+}
+
+void BLEConnectivityManager::Recovery::NotifyLostDevice(BLEBridgedDevice *device)
+{
+ if (device) {
+ PutDevice(device);
+ StartTimer();
+ }
+}
+
+void BLEConnectivityManager::Recovery::TimerTimeoutCallback(k_timer *timer)
+{
+ LOG_DBG("Re-scanning BLE connections...");
+ DeviceLayer::PlatformMgr().ScheduleWork(
+ [](intptr_t) { Instance().Scan(ReScanCallback, nullptr, kRecoveryScanTimeoutMs); }, 0);
+}
+
+BLEBridgedDevice *BLEConnectivityManager::Recovery::GetDevice()
+{
+ uint32_t deviceAddr;
+ int ret = ring_buf_get(&mRingBuf, reinterpret_cast<uint8_t *>(&deviceAddr), sizeof(deviceAddr));
+ if (ret == sizeof(deviceAddr)) {
+ return reinterpret_cast<BLEBridgedDevice *>(deviceAddr);
+ }
+
+ return nullptr;
+}
+
+bool BLEConnectivityManager::Recovery::PutDevice(BLEBridgedDevice *device)
+{
+ int ret = ring_buf_put(&mRingBuf, reinterpret_cast<uint8_t *>(&device), sizeof(device));
+ return ret == sizeof(device);
+}