From f56c78a716a396bb45751549ea88c8ba1d47c837 Mon Sep 17 00:00:00 2001 From: Arkadiusz Bokowy Date: Wed, 24 Jan 2024 11:41:41 +0100 Subject: [PATCH 01/14] Use ScheduleLambda() instead of ScheduleWork --- src/platform/Linux/BLEManagerImpl.cpp | 18 ++++-------------- src/platform/Linux/BLEManagerImpl.h | 4 ++-- 2 files changed, 6 insertions(+), 16 deletions(-) diff --git a/src/platform/Linux/BLEManagerImpl.cpp b/src/platform/Linux/BLEManagerImpl.cpp index e46e9c5d21edf2..93a896c47b0c92 100644 --- a/src/platform/Linux/BLEManagerImpl.cpp +++ b/src/platform/Linux/BLEManagerImpl.cpp @@ -91,7 +91,7 @@ CHIP_ERROR BLEManagerImpl::_Init() OnChipBleConnectReceived = HandleIncomingBleConnection; - PlatformMgr().ScheduleWork(DriveBLEState, 0); + DeviceLayer::SystemLayer().ScheduleLambda([this] { DriveBLEState(); }); exit: return err; @@ -119,7 +119,7 @@ CHIP_ERROR BLEManagerImpl::_SetAdvertisingEnabled(bool val) mFlags.Set(Flags::kAdvertisingEnabled, val); } - PlatformMgr().ScheduleWork(DriveBLEState, 0); + DeviceLayer::SystemLayer().ScheduleLambda([this] { DriveBLEState(); }); return err; } @@ -138,7 +138,7 @@ CHIP_ERROR BLEManagerImpl::_SetAdvertisingMode(BLEAdvertisingMode mode) return CHIP_ERROR_INVALID_ARGUMENT; } mFlags.Set(Flags::kAdvertisingRefreshNeeded); - PlatformMgr().ScheduleWork(DriveBLEState, 0); + DeviceLayer::SystemLayer().ScheduleLambda([this] { DriveBLEState(); }); return CHIP_NO_ERROR; } @@ -627,11 +627,6 @@ void BLEManagerImpl::DriveBLEState() } } -void BLEManagerImpl::DriveBLEState(intptr_t arg) -{ - sInstance.DriveBLEState(); -} - void BLEManagerImpl::NotifyChipConnectionClosed(BLE_CONNECTION_OBJECT conId) { ChipLogProgress(Ble, "Got notification regarding chip connection closure"); @@ -695,18 +690,13 @@ void BLEManagerImpl::CleanScanConfig() mBLEScanConfig.mBleScanState = BleScanState::kNotScanning; } -void BLEManagerImpl::InitiateScan(intptr_t arg) -{ - sInstance.InitiateScan(static_cast(arg)); -} - void BLEManagerImpl::NewConnection(BleLayer * bleLayer, void * appState, const SetupDiscriminator & connDiscriminator) { mBLEScanConfig.mDiscriminator = connDiscriminator; mBLEScanConfig.mAppState = appState; // Scan initiation performed async, to ensure that the BLE subsystem is initialized. - PlatformMgr().ScheduleWork(InitiateScan, static_cast(BleScanState::kScanForDiscriminator)); + DeviceLayer::SystemLayer().ScheduleLambda([this] { InitiateScan(BleScanState::kScanForDiscriminator); }); } CHIP_ERROR BLEManagerImpl::CancelConnection() diff --git a/src/platform/Linux/BLEManagerImpl.h b/src/platform/Linux/BLEManagerImpl.h index 5cd3ed2460adf9..d2432917af6744 100644 --- a/src/platform/Linux/BLEManagerImpl.h +++ b/src/platform/Linux/BLEManagerImpl.h @@ -141,6 +141,7 @@ class BLEManagerImpl final : public BLEManager, CHIP_ERROR CancelConnection() override; // ===== Members that implement virtual methods on ChipDeviceScannerDelegate + void OnDeviceScanned(BluezDevice1 & device, const chip::Ble::ChipBLEDeviceIdentificationInfo & info) override; void OnScanComplete() override; @@ -152,6 +153,7 @@ class BLEManagerImpl final : public BLEManager, static BLEManagerImpl sInstance; // ===== Private members reserved for use by this class only. + enum class Flags : uint16_t { kAsyncInitCompleted = 0x0001, /**< One-time asynchronous initialization actions have been performed. */ @@ -174,10 +176,8 @@ class BLEManagerImpl final : public BLEManager, }; void DriveBLEState(); - static void DriveBLEState(intptr_t arg); void InitiateScan(BleScanState scanType); - static void InitiateScan(intptr_t arg); void CleanScanConfig(); CHIPoBLEServiceMode mServiceMode; From aa9ab72bad27e373bbdbe41769acbced4ba4c66c Mon Sep 17 00:00:00 2001 From: Arkadiusz Bokowy Date: Wed, 24 Jan 2024 14:05:38 +0100 Subject: [PATCH 02/14] Set min/max advertisement interval --- src/platform/Linux/BLEManagerImpl.cpp | 10 +++++++++- src/platform/Linux/BLEManagerImpl.h | 2 +- .../Linux/bluez/BluezAdvertisement.cpp | 20 +++++++++++-------- src/platform/Linux/bluez/BluezAdvertisement.h | 8 +++++++- src/platform/Linux/dbus/bluez/DbusBluez.xml | 2 ++ 5 files changed, 31 insertions(+), 11 deletions(-) diff --git a/src/platform/Linux/BLEManagerImpl.cpp b/src/platform/Linux/BLEManagerImpl.cpp index 93a896c47b0c92..e78ca03dd11a09 100644 --- a/src/platform/Linux/BLEManagerImpl.cpp +++ b/src/platform/Linux/BLEManagerImpl.cpp @@ -595,7 +595,8 @@ void BLEManagerImpl::DriveBLEState() // Configure advertising data if it hasn't been done yet. if (!mFlags.Has(Flags::kAdvertisingConfigured)) { - SuccessOrExit(err = mBLEAdvertisement.Init(mEndpoint, mBLEAdvType, mpBLEAdvUUID, mBLEAdvDurationMs)); + SuccessOrExit(err = mBLEAdvertisement.Init(mEndpoint, mBLEAdvType, mpBLEAdvUUID, mBLEAdvDurationMs, + GetAdvertisingIntervals())); mFlags.Set(Flags::kAdvertisingConfigured); } @@ -636,6 +637,13 @@ void BLEManagerImpl::NotifyChipConnectionClosed(BLE_CONNECTION_OBJECT conId) #endif } +BluezAdvertisement::AdvertisingIntervals BLEManagerImpl::GetAdvertisingIntervals() const +{ + if (mFlags.Has(Flags::kFastAdvertisingEnabled)) + return { CHIP_DEVICE_CONFIG_BLE_FAST_ADVERTISING_INTERVAL_MIN, CHIP_DEVICE_CONFIG_BLE_FAST_ADVERTISING_INTERVAL_MAX }; + return { CHIP_DEVICE_CONFIG_BLE_SLOW_ADVERTISING_INTERVAL_MIN, CHIP_DEVICE_CONFIG_BLE_SLOW_ADVERTISING_INTERVAL_MAX }; +} + void BLEManagerImpl::InitiateScan(BleScanState scanType) { DriveBLEState(); diff --git a/src/platform/Linux/BLEManagerImpl.h b/src/platform/Linux/BLEManagerImpl.h index d2432917af6744..3f214ee6dee7ca 100644 --- a/src/platform/Linux/BLEManagerImpl.h +++ b/src/platform/Linux/BLEManagerImpl.h @@ -176,7 +176,7 @@ class BLEManagerImpl final : public BLEManager, }; void DriveBLEState(); - + BluezAdvertisement::AdvertisingIntervals GetAdvertisingIntervals() const; void InitiateScan(BleScanState scanType); void CleanScanConfig(); diff --git a/src/platform/Linux/bluez/BluezAdvertisement.cpp b/src/platform/Linux/bluez/BluezAdvertisement.cpp index 19212fbe717475..d1f9910721d5d3 100644 --- a/src/platform/Linux/bluez/BluezAdvertisement.cpp +++ b/src/platform/Linux/bluez/BluezAdvertisement.cpp @@ -76,6 +76,7 @@ BluezLEAdvertisement1 * BluezAdvertisement::CreateLEAdvertisement() ChipLogDetail(DeviceLayer, "SET service data to %s", StringOrNullMarker(debugStr.get())); bluez_leadvertisement1_set_type_(adv, (mAdvType & BLUEZ_ADV_TYPE_CONNECTABLE) ? "peripheral" : "broadcast"); + bluez_leadvertisement1_set_service_uuids(adv, serviceUUID); // empty manufacturer data // empty solicit UUIDs bluez_leadvertisement1_set_service_data(adv, serviceData); @@ -85,21 +86,23 @@ BluezLEAdvertisement1 * BluezAdvertisement::CreateLEAdvertisement() // Bluez to set "BR/EDR Not Supported" flag. Bluez doesn't provide API to do that explicitly // and the flag is necessary to force using LE transport. bluez_leadvertisement1_set_discoverable(adv, (mAdvType & BLUEZ_ADV_TYPE_SCANNABLE) ? TRUE : FALSE); - if (mAdvType & BLUEZ_ADV_TYPE_SCANNABLE) - bluez_leadvertisement1_set_discoverable_timeout(adv, UINT16_MAX); - // advertising name corresponding to the PID and object path, for debug purposes - bluez_leadvertisement1_set_local_name(adv, localNamePtr); - bluez_leadvertisement1_set_service_uuids(adv, serviceUUID); + // The discoverable timeout shall NOT be set when type is set to "broadcast". + if (mAdvType & BLUEZ_ADV_TYPE_CONNECTABLE) + bluez_leadvertisement1_set_discoverable_timeout(adv, 0 /* infinite */); - // 0xffff means no appearance - bluez_leadvertisement1_set_appearance(adv, 0xffff); + // empty includes + bluez_leadvertisement1_set_local_name(adv, localNamePtr); + bluez_leadvertisement1_set_appearance(adv, 0xffff /* no appearance */); bluez_leadvertisement1_set_duration(adv, mAdvDurationMs); // empty duration, we don't have a clear notion what it would mean to timeslice between toble and anyone else bluez_leadvertisement1_set_timeout(adv, 0); // empty secondary channel for now + bluez_leadvertisement1_set_min_interval(adv, mAdvIntervals.first * 0.625); + bluez_leadvertisement1_set_max_interval(adv, mAdvIntervals.second * 0.625); + bluez_object_skeleton_set_leadvertisement1(object, adv); g_signal_connect(adv, "handle-release", G_CALLBACK(+[](BluezLEAdvertisement1 * aAdv, GDBusMethodInvocation * aInv, BluezAdvertisement * self) { @@ -134,7 +137,7 @@ CHIP_ERROR BluezAdvertisement::InitImpl() } CHIP_ERROR BluezAdvertisement::Init(const BluezEndpoint & aEndpoint, ChipAdvType aAdvType, const char * aAdvUUID, - uint32_t aAdvDurationMs) + uint32_t aAdvDurationMs, AdvertisingIntervals aAdvIntervals) { GAutoPtr rootPath; CHIP_ERROR err; @@ -151,6 +154,7 @@ CHIP_ERROR BluezAdvertisement::Init(const BluezEndpoint & aEndpoint, ChipAdvType mAdvType = aAdvType; mpAdvUUID = g_strdup(aAdvUUID); mAdvDurationMs = aAdvDurationMs; + mAdvIntervals = aAdvIntervals; err = ConfigurationMgr().GetBLEDeviceIdentificationInfo(mDeviceIdInfo); ReturnErrorOnFailure(err); diff --git a/src/platform/Linux/bluez/BluezAdvertisement.h b/src/platform/Linux/bluez/BluezAdvertisement.h index 6ae2974d706b35..7314f8879b6db8 100644 --- a/src/platform/Linux/bluez/BluezAdvertisement.h +++ b/src/platform/Linux/bluez/BluezAdvertisement.h @@ -18,6 +18,7 @@ #pragma once #include +#include #include #include @@ -38,10 +39,14 @@ class BluezEndpoint; class BluezAdvertisement { public: + // Minimum and maximum advertising intervals in units of 0.625ms. + using AdvertisingIntervals = std::pair; + BluezAdvertisement() = default; ~BluezAdvertisement() { Shutdown(); } - CHIP_ERROR Init(const BluezEndpoint & aEndpoint, ChipAdvType aAdvType, const char * aAdvUUID, uint32_t aAdvDurationMs); + CHIP_ERROR Init(const BluezEndpoint & aEndpoint, ChipAdvType aAdvType, const char * aAdvUUID, uint32_t aAdvDurationMs, + AdvertisingIntervals aAdvIntervals); void Shutdown(); /// Start BLE advertising. @@ -82,6 +87,7 @@ class BluezAdvertisement char * mpAdvUUID = nullptr; ChipAdvType mAdvType; uint16_t mAdvDurationMs = 0; + AdvertisingIntervals mAdvIntervals; }; } // namespace Internal diff --git a/src/platform/Linux/dbus/bluez/DbusBluez.xml b/src/platform/Linux/dbus/bluez/DbusBluez.xml index ac0952bcc30284..3e381f77d87a68 100644 --- a/src/platform/Linux/dbus/bluez/DbusBluez.xml +++ b/src/platform/Linux/dbus/bluez/DbusBluez.xml @@ -190,6 +190,8 @@ + + From 7e69339166f9d7dbafd7b3774543d394ff2f8e47 Mon Sep 17 00:00:00 2001 From: Arkadiusz Bokowy Date: Wed, 24 Jan 2024 14:55:02 +0100 Subject: [PATCH 03/14] Matter BLE advertisement type shall be peripheral --- src/platform/Linux/BLEManagerImpl.cpp | 4 +--- src/platform/Linux/BLEManagerImpl.h | 1 - src/platform/Linux/bluez/BluezAdvertisement.cpp | 14 +++++--------- src/platform/Linux/bluez/BluezAdvertisement.h | 9 ++++----- src/platform/Linux/bluez/Types.h | 17 ----------------- 5 files changed, 10 insertions(+), 35 deletions(-) diff --git a/src/platform/Linux/BLEManagerImpl.cpp b/src/platform/Linux/BLEManagerImpl.cpp index e78ca03dd11a09..0614f3d2bedef3 100644 --- a/src/platform/Linux/BLEManagerImpl.cpp +++ b/src/platform/Linux/BLEManagerImpl.cpp @@ -190,7 +190,6 @@ CHIP_ERROR BLEManagerImpl::ConfigureBle(uint32_t aAdapterId, bool aIsCentral) mAdapterId = aAdapterId; mIsCentral = aIsCentral; - mBLEAdvType = ChipAdvType::BLUEZ_ADV_TYPE_UNDIRECTED_CONNECTABLE_SCANNABLE; mBLEAdvDurationMs = 2; mpBLEAdvUUID = "0xFFF6"; @@ -595,8 +594,7 @@ void BLEManagerImpl::DriveBLEState() // Configure advertising data if it hasn't been done yet. if (!mFlags.Has(Flags::kAdvertisingConfigured)) { - SuccessOrExit(err = mBLEAdvertisement.Init(mEndpoint, mBLEAdvType, mpBLEAdvUUID, mBLEAdvDurationMs, - GetAdvertisingIntervals())); + SuccessOrExit(err = mBLEAdvertisement.Init(mEndpoint, mpBLEAdvUUID, mBLEAdvDurationMs, GetAdvertisingIntervals())); mFlags.Set(Flags::kAdvertisingConfigured); } diff --git a/src/platform/Linux/BLEManagerImpl.h b/src/platform/Linux/BLEManagerImpl.h index 3f214ee6dee7ca..6c2087504e1e9d 100644 --- a/src/platform/Linux/BLEManagerImpl.h +++ b/src/platform/Linux/BLEManagerImpl.h @@ -189,7 +189,6 @@ class BLEManagerImpl final : public BLEManager, BluezEndpoint mEndpoint; BluezAdvertisement mBLEAdvertisement; - ChipAdvType mBLEAdvType = ChipAdvType::BLUEZ_ADV_TYPE_UNDIRECTED_CONNECTABLE_SCANNABLE; uint16_t mBLEAdvDurationMs = 20; const char * mpBLEAdvUUID = nullptr; diff --git a/src/platform/Linux/bluez/BluezAdvertisement.cpp b/src/platform/Linux/bluez/BluezAdvertisement.cpp index d1f9910721d5d3..ddfdd3b8e6814b 100644 --- a/src/platform/Linux/bluez/BluezAdvertisement.cpp +++ b/src/platform/Linux/bluez/BluezAdvertisement.cpp @@ -75,7 +75,7 @@ BluezLEAdvertisement1 * BluezAdvertisement::CreateLEAdvertisement() debugStr = GAutoPtr(g_variant_print(serviceData, TRUE)); ChipLogDetail(DeviceLayer, "SET service data to %s", StringOrNullMarker(debugStr.get())); - bluez_leadvertisement1_set_type_(adv, (mAdvType & BLUEZ_ADV_TYPE_CONNECTABLE) ? "peripheral" : "broadcast"); + bluez_leadvertisement1_set_type_(adv, "peripheral"); bluez_leadvertisement1_set_service_uuids(adv, serviceUUID); // empty manufacturer data // empty solicit UUIDs @@ -85,11 +85,8 @@ BluezLEAdvertisement1 * BluezAdvertisement::CreateLEAdvertisement() // Setting "Discoverable" to False on the adapter and to True on the advertisement convinces // Bluez to set "BR/EDR Not Supported" flag. Bluez doesn't provide API to do that explicitly // and the flag is necessary to force using LE transport. - bluez_leadvertisement1_set_discoverable(adv, (mAdvType & BLUEZ_ADV_TYPE_SCANNABLE) ? TRUE : FALSE); - - // The discoverable timeout shall NOT be set when type is set to "broadcast". - if (mAdvType & BLUEZ_ADV_TYPE_CONNECTABLE) - bluez_leadvertisement1_set_discoverable_timeout(adv, 0 /* infinite */); + bluez_leadvertisement1_set_discoverable(adv, TRUE); + bluez_leadvertisement1_set_discoverable_timeout(adv, 0 /* infinite */); // empty includes bluez_leadvertisement1_set_local_name(adv, localNamePtr); @@ -136,8 +133,8 @@ CHIP_ERROR BluezAdvertisement::InitImpl() return CHIP_NO_ERROR; } -CHIP_ERROR BluezAdvertisement::Init(const BluezEndpoint & aEndpoint, ChipAdvType aAdvType, const char * aAdvUUID, - uint32_t aAdvDurationMs, AdvertisingIntervals aAdvIntervals) +CHIP_ERROR BluezAdvertisement::Init(const BluezEndpoint & aEndpoint, const char * aAdvUUID, uint32_t aAdvDurationMs, + AdvertisingIntervals aAdvIntervals) { GAutoPtr rootPath; CHIP_ERROR err; @@ -151,7 +148,6 @@ CHIP_ERROR BluezAdvertisement::Init(const BluezEndpoint & aEndpoint, ChipAdvType g_object_get(G_OBJECT(mpRoot), "object-path", &MakeUniquePointerReceiver(rootPath).Get(), nullptr); mpAdvPath = g_strdup_printf("%s/advertising", rootPath.get()); - mAdvType = aAdvType; mpAdvUUID = g_strdup(aAdvUUID); mAdvDurationMs = aAdvDurationMs; mAdvIntervals = aAdvIntervals; diff --git a/src/platform/Linux/bluez/BluezAdvertisement.h b/src/platform/Linux/bluez/BluezAdvertisement.h index 7314f8879b6db8..2c76ab6a6259f4 100644 --- a/src/platform/Linux/bluez/BluezAdvertisement.h +++ b/src/platform/Linux/bluez/BluezAdvertisement.h @@ -45,7 +45,7 @@ class BluezAdvertisement BluezAdvertisement() = default; ~BluezAdvertisement() { Shutdown(); } - CHIP_ERROR Init(const BluezEndpoint & aEndpoint, ChipAdvType aAdvType, const char * aAdvUUID, uint32_t aAdvDurationMs, + CHIP_ERROR Init(const BluezEndpoint & aEndpoint, const char * aAdvUUID, uint32_t aAdvDurationMs, AdvertisingIntervals aAdvIntervals); void Shutdown(); @@ -82,10 +82,9 @@ class BluezAdvertisement bool mIsAdvertising = false; Ble::ChipBLEDeviceIdentificationInfo mDeviceIdInfo; - char * mpAdvPath = nullptr; - char * mpAdapterName = nullptr; - char * mpAdvUUID = nullptr; - ChipAdvType mAdvType; + char * mpAdvPath = nullptr; + char * mpAdapterName = nullptr; + char * mpAdvUUID = nullptr; uint16_t mAdvDurationMs = 0; AdvertisingIntervals mAdvIntervals; }; diff --git a/src/platform/Linux/bluez/Types.h b/src/platform/Linux/bluez/Types.h index 0153492b5b0e32..f7be4d858d079a 100644 --- a/src/platform/Linux/bluez/Types.h +++ b/src/platform/Linux/bluez/Types.h @@ -63,23 +63,6 @@ struct GAutoPtrDeleter namespace DeviceLayer { namespace Internal { -enum ChipAdvType -{ - BLUEZ_ADV_TYPE_CONNECTABLE = 0x01, - BLUEZ_ADV_TYPE_SCANNABLE = 0x02, - BLUEZ_ADV_TYPE_DIRECTED = 0x04, - - BLUEZ_ADV_TYPE_UNDIRECTED_NONCONNECTABLE_NONSCANNABLE = 0, - BLUEZ_ADV_TYPE_UNDIRECTED_CONNECTABLE_NONSCANNABLE = BLUEZ_ADV_TYPE_CONNECTABLE, - BLUEZ_ADV_TYPE_UNDIRECTED_NONCONNECTABLE_SCANNABLE = BLUEZ_ADV_TYPE_SCANNABLE, - BLUEZ_ADV_TYPE_UNDIRECTED_CONNECTABLE_SCANNABLE = BLUEZ_ADV_TYPE_CONNECTABLE | BLUEZ_ADV_TYPE_SCANNABLE, - - BLUEZ_ADV_TYPE_DIRECTED_NONCONNECTABLE_NONSCANNABLE = BLUEZ_ADV_TYPE_DIRECTED, - BLUEZ_ADV_TYPE_DIRECTED_CONNECTABLE_NONSCANNABLE = BLUEZ_ADV_TYPE_DIRECTED | BLUEZ_ADV_TYPE_CONNECTABLE, - BLUEZ_ADV_TYPE_DIRECTED_NONCONNECTABLE_SCANNABLE = BLUEZ_ADV_TYPE_DIRECTED | BLUEZ_ADV_TYPE_SCANNABLE, - BLUEZ_ADV_TYPE_DIRECTED_CONNECTABLE_SCANNABLE = BLUEZ_ADV_TYPE_DIRECTED | BLUEZ_ADV_TYPE_CONNECTABLE | BLUEZ_ADV_TYPE_SCANNABLE, -}; - #define BLUEZ_ADDRESS_SIZE 6 ///< BLE address size (in bytes) #define BLUEZ_PATH "/org/bluez" #define BLUEZ_INTERFACE "org.bluez" From 8550ccd8c33291dd96bbc36805ee57d7761b0576 Mon Sep 17 00:00:00 2001 From: Arkadiusz Bokowy Date: Wed, 24 Jan 2024 15:54:40 +0100 Subject: [PATCH 04/14] Allow intervals to be set after initialization --- src/platform/Linux/BLEManagerImpl.cpp | 3 ++- src/platform/Linux/bluez/BluezAdvertisement.cpp | 17 +++++++++++------ src/platform/Linux/bluez/BluezAdvertisement.h | 5 ++--- 3 files changed, 15 insertions(+), 10 deletions(-) diff --git a/src/platform/Linux/BLEManagerImpl.cpp b/src/platform/Linux/BLEManagerImpl.cpp index 0614f3d2bedef3..f3e46742a1297f 100644 --- a/src/platform/Linux/BLEManagerImpl.cpp +++ b/src/platform/Linux/BLEManagerImpl.cpp @@ -594,7 +594,8 @@ void BLEManagerImpl::DriveBLEState() // Configure advertising data if it hasn't been done yet. if (!mFlags.Has(Flags::kAdvertisingConfigured)) { - SuccessOrExit(err = mBLEAdvertisement.Init(mEndpoint, mpBLEAdvUUID, mBLEAdvDurationMs, GetAdvertisingIntervals())); + SuccessOrExit(err = mBLEAdvertisement.Init(mEndpoint, mpBLEAdvUUID, mBLEAdvDurationMs)); + SuccessOrExit(err = mBLEAdvertisement.SetIntervals(GetAdvertisingIntervals())); mFlags.Set(Flags::kAdvertisingConfigured); } diff --git a/src/platform/Linux/bluez/BluezAdvertisement.cpp b/src/platform/Linux/bluez/BluezAdvertisement.cpp index ddfdd3b8e6814b..0010bf97bcfdc6 100644 --- a/src/platform/Linux/bluez/BluezAdvertisement.cpp +++ b/src/platform/Linux/bluez/BluezAdvertisement.cpp @@ -97,9 +97,6 @@ BluezLEAdvertisement1 * BluezAdvertisement::CreateLEAdvertisement() bluez_leadvertisement1_set_timeout(adv, 0); // empty secondary channel for now - bluez_leadvertisement1_set_min_interval(adv, mAdvIntervals.first * 0.625); - bluez_leadvertisement1_set_max_interval(adv, mAdvIntervals.second * 0.625); - bluez_object_skeleton_set_leadvertisement1(object, adv); g_signal_connect(adv, "handle-release", G_CALLBACK(+[](BluezLEAdvertisement1 * aAdv, GDBusMethodInvocation * aInv, BluezAdvertisement * self) { @@ -133,8 +130,7 @@ CHIP_ERROR BluezAdvertisement::InitImpl() return CHIP_NO_ERROR; } -CHIP_ERROR BluezAdvertisement::Init(const BluezEndpoint & aEndpoint, const char * aAdvUUID, uint32_t aAdvDurationMs, - AdvertisingIntervals aAdvIntervals) +CHIP_ERROR BluezAdvertisement::Init(const BluezEndpoint & aEndpoint, const char * aAdvUUID, uint32_t aAdvDurationMs) { GAutoPtr rootPath; CHIP_ERROR err; @@ -150,7 +146,6 @@ CHIP_ERROR BluezAdvertisement::Init(const BluezEndpoint & aEndpoint, const char mpAdvPath = g_strdup_printf("%s/advertising", rootPath.get()); mpAdvUUID = g_strdup(aAdvUUID); mAdvDurationMs = aAdvDurationMs; - mAdvIntervals = aAdvIntervals; err = ConfigurationMgr().GetBLEDeviceIdentificationInfo(mDeviceIdInfo); ReturnErrorOnFailure(err); @@ -170,6 +165,16 @@ CHIP_ERROR BluezAdvertisement::Init(const BluezEndpoint & aEndpoint, const char return err; } +CHIP_ERROR BluezAdvertisement::SetIntervals(AdvertisingIntervals aAdvIntervals) +{ + VerifyOrReturnError(mpAdv != nullptr, CHIP_ERROR_UNINITIALIZED); + // If the advertisement is already running, BlueZ will update the intervals + // automatically. There is no need to stop and restart the advertisement. + bluez_leadvertisement1_set_min_interval(mpAdv, aAdvIntervals.first * 0.625); + bluez_leadvertisement1_set_max_interval(mpAdv, aAdvIntervals.second * 0.625); + return CHIP_NO_ERROR; +} + void BluezAdvertisement::Shutdown() { VerifyOrReturn(mIsInitialized); diff --git a/src/platform/Linux/bluez/BluezAdvertisement.h b/src/platform/Linux/bluez/BluezAdvertisement.h index 2c76ab6a6259f4..66af3667a15af4 100644 --- a/src/platform/Linux/bluez/BluezAdvertisement.h +++ b/src/platform/Linux/bluez/BluezAdvertisement.h @@ -45,8 +45,8 @@ class BluezAdvertisement BluezAdvertisement() = default; ~BluezAdvertisement() { Shutdown(); } - CHIP_ERROR Init(const BluezEndpoint & aEndpoint, const char * aAdvUUID, uint32_t aAdvDurationMs, - AdvertisingIntervals aAdvIntervals); + CHIP_ERROR Init(const BluezEndpoint & aEndpoint, const char * aAdvUUID, uint32_t aAdvDurationMs); + CHIP_ERROR SetIntervals(AdvertisingIntervals aAdvIntervals); void Shutdown(); /// Start BLE advertising. @@ -86,7 +86,6 @@ class BluezAdvertisement char * mpAdapterName = nullptr; char * mpAdvUUID = nullptr; uint16_t mAdvDurationMs = 0; - AdvertisingIntervals mAdvIntervals; }; } // namespace Internal From 146ab5e4463d61abc93934538aa395e82c5e98c3 Mon Sep 17 00:00:00 2001 From: Arkadiusz Bokowy Date: Wed, 24 Jan 2024 16:05:46 +0100 Subject: [PATCH 05/14] Keep BlueZ default for adv slicing duration --- src/platform/Linux/BLEManagerImpl.cpp | 12 ++++-------- src/platform/Linux/BLEManagerImpl.h | 3 +-- src/platform/Linux/bluez/BluezAdvertisement.cpp | 11 ++++------- src/platform/Linux/bluez/BluezAdvertisement.h | 3 +-- src/platform/Linux/dbus/bluez/DbusBluez.xml | 2 +- 5 files changed, 11 insertions(+), 20 deletions(-) diff --git a/src/platform/Linux/BLEManagerImpl.cpp b/src/platform/Linux/BLEManagerImpl.cpp index f3e46742a1297f..02297fe2457850 100644 --- a/src/platform/Linux/BLEManagerImpl.cpp +++ b/src/platform/Linux/BLEManagerImpl.cpp @@ -186,13 +186,9 @@ uint16_t BLEManagerImpl::_NumConnections() CHIP_ERROR BLEManagerImpl::ConfigureBle(uint32_t aAdapterId, bool aIsCentral) { - - mAdapterId = aAdapterId; - mIsCentral = aIsCentral; - - mBLEAdvDurationMs = 2; - mpBLEAdvUUID = "0xFFF6"; - + mAdapterId = aAdapterId; + mIsCentral = aIsCentral; + mpBLEAdvUUID = "0xFFF6"; return CHIP_NO_ERROR; } @@ -594,7 +590,7 @@ void BLEManagerImpl::DriveBLEState() // Configure advertising data if it hasn't been done yet. if (!mFlags.Has(Flags::kAdvertisingConfigured)) { - SuccessOrExit(err = mBLEAdvertisement.Init(mEndpoint, mpBLEAdvUUID, mBLEAdvDurationMs)); + SuccessOrExit(err = mBLEAdvertisement.Init(mEndpoint, mpBLEAdvUUID)); SuccessOrExit(err = mBLEAdvertisement.SetIntervals(GetAdvertisingIntervals())); mFlags.Set(Flags::kAdvertisingConfigured); } diff --git a/src/platform/Linux/BLEManagerImpl.h b/src/platform/Linux/BLEManagerImpl.h index 6c2087504e1e9d..4e04366798169c 100644 --- a/src/platform/Linux/BLEManagerImpl.h +++ b/src/platform/Linux/BLEManagerImpl.h @@ -189,8 +189,7 @@ class BLEManagerImpl final : public BLEManager, BluezEndpoint mEndpoint; BluezAdvertisement mBLEAdvertisement; - uint16_t mBLEAdvDurationMs = 20; - const char * mpBLEAdvUUID = nullptr; + const char * mpBLEAdvUUID = nullptr; ChipDeviceScanner mDeviceScanner; BLEScanConfig mBLEScanConfig; diff --git a/src/platform/Linux/bluez/BluezAdvertisement.cpp b/src/platform/Linux/bluez/BluezAdvertisement.cpp index 0010bf97bcfdc6..8c79a92b1dcfd1 100644 --- a/src/platform/Linux/bluez/BluezAdvertisement.cpp +++ b/src/platform/Linux/bluez/BluezAdvertisement.cpp @@ -91,9 +91,7 @@ BluezLEAdvertisement1 * BluezAdvertisement::CreateLEAdvertisement() // empty includes bluez_leadvertisement1_set_local_name(adv, localNamePtr); bluez_leadvertisement1_set_appearance(adv, 0xffff /* no appearance */); - - bluez_leadvertisement1_set_duration(adv, mAdvDurationMs); - // empty duration, we don't have a clear notion what it would mean to timeslice between toble and anyone else + // empty duration bluez_leadvertisement1_set_timeout(adv, 0); // empty secondary channel for now @@ -130,7 +128,7 @@ CHIP_ERROR BluezAdvertisement::InitImpl() return CHIP_NO_ERROR; } -CHIP_ERROR BluezAdvertisement::Init(const BluezEndpoint & aEndpoint, const char * aAdvUUID, uint32_t aAdvDurationMs) +CHIP_ERROR BluezAdvertisement::Init(const BluezEndpoint & aEndpoint, const char * aAdvUUID) { GAutoPtr rootPath; CHIP_ERROR err; @@ -143,9 +141,8 @@ CHIP_ERROR BluezAdvertisement::Init(const BluezEndpoint & aEndpoint, const char mpAdapterName = g_strdup(aEndpoint.GetAdapterName()); g_object_get(G_OBJECT(mpRoot), "object-path", &MakeUniquePointerReceiver(rootPath).Get(), nullptr); - mpAdvPath = g_strdup_printf("%s/advertising", rootPath.get()); - mpAdvUUID = g_strdup(aAdvUUID); - mAdvDurationMs = aAdvDurationMs; + mpAdvPath = g_strdup_printf("%s/advertising", rootPath.get()); + mpAdvUUID = g_strdup(aAdvUUID); err = ConfigurationMgr().GetBLEDeviceIdentificationInfo(mDeviceIdInfo); ReturnErrorOnFailure(err); diff --git a/src/platform/Linux/bluez/BluezAdvertisement.h b/src/platform/Linux/bluez/BluezAdvertisement.h index 66af3667a15af4..673c455e955b24 100644 --- a/src/platform/Linux/bluez/BluezAdvertisement.h +++ b/src/platform/Linux/bluez/BluezAdvertisement.h @@ -45,7 +45,7 @@ class BluezAdvertisement BluezAdvertisement() = default; ~BluezAdvertisement() { Shutdown(); } - CHIP_ERROR Init(const BluezEndpoint & aEndpoint, const char * aAdvUUID, uint32_t aAdvDurationMs); + CHIP_ERROR Init(const BluezEndpoint & aEndpoint, const char * aAdvUUID); CHIP_ERROR SetIntervals(AdvertisingIntervals aAdvIntervals); void Shutdown(); @@ -85,7 +85,6 @@ class BluezAdvertisement char * mpAdvPath = nullptr; char * mpAdapterName = nullptr; char * mpAdvUUID = nullptr; - uint16_t mAdvDurationMs = 0; }; } // namespace Internal diff --git a/src/platform/Linux/dbus/bluez/DbusBluez.xml b/src/platform/Linux/dbus/bluez/DbusBluez.xml index 3e381f77d87a68..e6539ff6d94562 100644 --- a/src/platform/Linux/dbus/bluez/DbusBluez.xml +++ b/src/platform/Linux/dbus/bluez/DbusBluez.xml @@ -187,7 +187,7 @@ - + From 2fd677e3054e66b4228b0994cf481d2c4c38267d Mon Sep 17 00:00:00 2001 From: Arkadiusz Bokowy Date: Wed, 24 Jan 2024 16:50:36 +0100 Subject: [PATCH 06/14] Allow to update intervals on the fly - fast/slow --- src/platform/Linux/BLEManagerImpl.cpp | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/src/platform/Linux/BLEManagerImpl.cpp b/src/platform/Linux/BLEManagerImpl.cpp index 02297fe2457850..a698a6a758a5c5 100644 --- a/src/platform/Linux/BLEManagerImpl.cpp +++ b/src/platform/Linux/BLEManagerImpl.cpp @@ -273,16 +273,10 @@ void BLEManagerImpl::HandlePlatformSpecificBLEEvent(const ChipDeviceEvent * apEv case DeviceEventType::kPlatformLinuxBLEPeripheralAdvStartComplete: VerifyOrExit(apEvent->Platform.BLEPeripheralAdvStartComplete.mIsSuccess, err = CHIP_ERROR_INCORRECT_STATE); sInstance.mFlags.Clear(Flags::kControlOpInProgress).Clear(Flags::kAdvertisingRefreshNeeded); - - if (!sInstance.mFlags.Has(Flags::kAdvertising)) - { - sInstance.mFlags.Set(Flags::kAdvertising); - } - + sInstance.mFlags.Set(Flags::kAdvertising); break; case DeviceEventType::kPlatformLinuxBLEPeripheralAdvStopComplete: VerifyOrExit(apEvent->Platform.BLEPeripheralAdvStopComplete.mIsSuccess, err = CHIP_ERROR_INCORRECT_STATE); - sInstance.mFlags.Clear(Flags::kControlOpInProgress).Clear(Flags::kAdvertisingRefreshNeeded); // Transition to the not Advertising state... @@ -591,15 +585,20 @@ void BLEManagerImpl::DriveBLEState() if (!mFlags.Has(Flags::kAdvertisingConfigured)) { SuccessOrExit(err = mBLEAdvertisement.Init(mEndpoint, mpBLEAdvUUID)); - SuccessOrExit(err = mBLEAdvertisement.SetIntervals(GetAdvertisingIntervals())); mFlags.Set(Flags::kAdvertisingConfigured); } - // Start advertising. This is an asynchronous step. BLE manager will be notified of - // advertising start completion via a call to NotifyBLEPeripheralAdvStartComplete. - SuccessOrExit(err = mBLEAdvertisement.Start()); - mFlags.Set(Flags::kControlOpInProgress); - ExitNow(); + // Set or update the advertising intervals. + SuccessOrExit(err = mBLEAdvertisement.SetIntervals(GetAdvertisingIntervals())); + + if (!mFlags.Has(Flags::kAdvertising)) + { + // Start advertising. This is an asynchronous step. BLE manager will be notified of + // advertising start completion via a call to NotifyBLEPeripheralAdvStartComplete. + SuccessOrExit(err = mBLEAdvertisement.Start()); + mFlags.Set(Flags::kControlOpInProgress); + ExitNow(); + } } } From ab1ea0c3aac370b3088112680ec52feb266886b6 Mon Sep 17 00:00:00 2001 From: Arkadiusz Bokowy Date: Wed, 24 Jan 2024 17:59:35 +0100 Subject: [PATCH 07/14] Transition to slow advertising after timeout --- src/platform/Linux/BLEManagerImpl.cpp | 16 ++++++++++++++++ src/platform/Linux/BLEManagerImpl.h | 1 + 2 files changed, 17 insertions(+) diff --git a/src/platform/Linux/BLEManagerImpl.cpp b/src/platform/Linux/BLEManagerImpl.cpp index a698a6a758a5c5..2c23df08c7f0a3 100644 --- a/src/platform/Linux/BLEManagerImpl.cpp +++ b/src/platform/Linux/BLEManagerImpl.cpp @@ -54,6 +54,8 @@ namespace { static constexpr System::Clock::Timeout kNewConnectionScanTimeout = System::Clock::Seconds16(20); static constexpr System::Clock::Timeout kConnectTimeout = System::Clock::Seconds16(20); +static constexpr System::Clock::Timeout kFastAdvertiseTimeout = + System::Clock::Milliseconds32(CHIP_DEVICE_CONFIG_BLE_ADVERTISING_INTERVAL_CHANGE_TIME); const ChipBleUUID ChipUUID_CHIPoBLEChar_RX = { { 0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F, 0x9D, 0x11 } }; @@ -273,11 +275,14 @@ void BLEManagerImpl::HandlePlatformSpecificBLEEvent(const ChipDeviceEvent * apEv case DeviceEventType::kPlatformLinuxBLEPeripheralAdvStartComplete: VerifyOrExit(apEvent->Platform.BLEPeripheralAdvStartComplete.mIsSuccess, err = CHIP_ERROR_INCORRECT_STATE); sInstance.mFlags.Clear(Flags::kControlOpInProgress).Clear(Flags::kAdvertisingRefreshNeeded); + // Start a timer to make sure that the fast advertising is stopped after specified timeout. + SuccessOrExit(err = DeviceLayer::SystemLayer().StartTimer(kFastAdvertiseTimeout, HandleAdvertisingTimer, this)); sInstance.mFlags.Set(Flags::kAdvertising); break; case DeviceEventType::kPlatformLinuxBLEPeripheralAdvStopComplete: VerifyOrExit(apEvent->Platform.BLEPeripheralAdvStopComplete.mIsSuccess, err = CHIP_ERROR_INCORRECT_STATE); sInstance.mFlags.Clear(Flags::kControlOpInProgress).Clear(Flags::kAdvertisingRefreshNeeded); + DeviceLayer::SystemLayer().CancelTimer(HandleAdvertisingTimer, this); // Transition to the not Advertising state... if (sInstance.mFlags.Has(Flags::kAdvertising)) @@ -638,6 +643,17 @@ BluezAdvertisement::AdvertisingIntervals BLEManagerImpl::GetAdvertisingIntervals return { CHIP_DEVICE_CONFIG_BLE_SLOW_ADVERTISING_INTERVAL_MIN, CHIP_DEVICE_CONFIG_BLE_SLOW_ADVERTISING_INTERVAL_MAX }; } +void BLEManagerImpl::HandleAdvertisingTimer(chip::System::Layer *, void * appState) +{ + auto * self = static_cast(appState); + + if (self->mFlags.Has(Flags::kFastAdvertisingEnabled)) + { + ChipLogDetail(DeviceLayer, "bleAdv Timeout : Start slow advertisement"); + self->_SetAdvertisingMode(BLEAdvertisingMode::kSlowAdvertising); + } +} + void BLEManagerImpl::InitiateScan(BleScanState scanType) { DriveBLEState(); diff --git a/src/platform/Linux/BLEManagerImpl.h b/src/platform/Linux/BLEManagerImpl.h index 4e04366798169c..faa9e5d250c20e 100644 --- a/src/platform/Linux/BLEManagerImpl.h +++ b/src/platform/Linux/BLEManagerImpl.h @@ -177,6 +177,7 @@ class BLEManagerImpl final : public BLEManager, void DriveBLEState(); BluezAdvertisement::AdvertisingIntervals GetAdvertisingIntervals() const; + static void HandleAdvertisingTimer(chip::System::Layer *, void * appState); void InitiateScan(BleScanState scanType); void CleanScanConfig(); From ce327094fe7953cf54e1a549781a1698c16e3652 Mon Sep 17 00:00:00 2001 From: Arkadiusz Bokowy Date: Wed, 24 Jan 2024 18:03:43 +0100 Subject: [PATCH 08/14] Fix advertisement typos in all places in the codebase --- examples/lock-app/esp32/main/AppTask.cpp | 4 ++-- examples/platform/silabs/BaseApplication.cpp | 4 ++-- src/app/server/Dnssd.cpp | 2 +- src/lib/dnssd/minimal_mdns/tests/TestAdvertiser.cpp | 2 +- src/platform/Infineon/PSOC6/BLEManagerImpl.cpp | 2 +- src/platform/mt793x/BLEManagerImpl.cpp | 2 +- src/platform/silabs/efr32/BLEManagerImpl.cpp | 6 +++--- src/platform/silabs/rs911x/BLEManagerImpl.cpp | 4 ++-- src/platform/stm32/BLEManagerImpl.cpp | 4 ++-- 9 files changed, 15 insertions(+), 15 deletions(-) diff --git a/examples/lock-app/esp32/main/AppTask.cpp b/examples/lock-app/esp32/main/AppTask.cpp index 52650e5c2d2652..e6a8519b782c18 100644 --- a/examples/lock-app/esp32/main/AppTask.cpp +++ b/examples/lock-app/esp32/main/AppTask.cpp @@ -322,7 +322,7 @@ void AppTask::FunctionHandler(AppEvent * aEvent) } else { - // If the button was released before factory reset got initiated, start BLE advertissement in fast mode + // If the button was released before factory reset got initiated, start BLE advertisement in fast mode if (sAppTask.mFunctionTimerActive && sAppTask.mFunction == kFunction_StartBleAdv) { sAppTask.CancelTimer(); @@ -336,7 +336,7 @@ void AppTask::FunctionHandler(AppEvent * aEvent) } else { - ESP_LOGI(TAG, "Network is already provisioned, Ble advertissement not enabled"); + ESP_LOGI(TAG, "Network is already provisioned, Ble advertisement not enabled"); } } else if (sAppTask.mFunctionTimerActive && sAppTask.mFunction == kFunction_FactoryReset) diff --git a/examples/platform/silabs/BaseApplication.cpp b/examples/platform/silabs/BaseApplication.cpp index 99acb26d9bd26e..3677c1bed72b83 100644 --- a/examples/platform/silabs/BaseApplication.cpp +++ b/examples/platform/silabs/BaseApplication.cpp @@ -453,7 +453,7 @@ void BaseApplication::ButtonHandler(AppEvent * aEvent) { // The factory reset sequence was not initiated, // Press and Release: - // - Open the commissioning window and start BLE advertissement in fast mode when not commissioned + // - Open the commissioning window and start BLE advertisement in fast mode when not commissioned // - Output qr code in logs // - Cycle LCD screen CancelFunctionTimer(); @@ -477,7 +477,7 @@ void BaseApplication::ButtonHandler(AppEvent * aEvent) } else { - SILABS_LOG("Network is already provisioned, Ble advertissement not enabled"); + SILABS_LOG("Network is already provisioned, Ble advertisement not enabled"); #if CHIP_CONFIG_ENABLE_ICD_SERVER // Temporarily claim network activity, until we implement a "user trigger" reason for ICD wakeups. PlatformMgr().LockChipStack(); diff --git a/src/app/server/Dnssd.cpp b/src/app/server/Dnssd.cpp index e91ef563007cfb..93d25c5b30720c 100644 --- a/src/app/server/Dnssd.cpp +++ b/src/app/server/Dnssd.cpp @@ -499,7 +499,7 @@ CHIP_ERROR DnssdServer::GenerateRotatingDeviceId(char rotatingDeviceIdHexBuffer[ void DnssdServer::OnICDModeChange() { // ICDMode changed, restart DNS-SD advertising, because SII and ICD key are affected by this change. - // StartServer will take care of setting the operational and commissionable advertissements + // StartServer will take care of setting the operational and commissionable advertisements StartServer(); } diff --git a/src/lib/dnssd/minimal_mdns/tests/TestAdvertiser.cpp b/src/lib/dnssd/minimal_mdns/tests/TestAdvertiser.cpp index c265d1802d3073..560b013dfea133 100644 --- a/src/lib/dnssd/minimal_mdns/tests/TestAdvertiser.cpp +++ b/src/lib/dnssd/minimal_mdns/tests/TestAdvertiser.cpp @@ -210,7 +210,7 @@ CommissionAdvertisingParameters commissionableNodeParamsEnhancedAsICDLIT = .SetTcpSupported(chip::Optional(true)) .SetICDOperatingAsLIT(chip::Optional(true)) .SetLocalMRPConfig(Optional::Value(3600000_ms32, 3600000_ms32, 65535_ms16)); -// With ICD Operation as LIT, SII key will not be added to the advertissement +// With ICD Operation as LIT, SII key will not be added to the advertisement QNamePart txtCommissionableNodeParamsEnhancedAsICDLITParts[] = { "D=22", "VP=555+897", "CM=2", "DT=70000", "DN=testy-test", "PI=Pair me", "PH=3", "SAI=3600000", "SAT=65535", "T=1", "ICD=1" }; diff --git a/src/platform/Infineon/PSOC6/BLEManagerImpl.cpp b/src/platform/Infineon/PSOC6/BLEManagerImpl.cpp index 9d380a7124ae8a..917cdc267e4d24 100644 --- a/src/platform/Infineon/PSOC6/BLEManagerImpl.cpp +++ b/src/platform/Infineon/PSOC6/BLEManagerImpl.cpp @@ -426,7 +426,7 @@ void BLEManagerImpl::DriveBLEState(void) ChipLogProgress(DeviceLayer, "CHIPoBLE stop advertising"); wiced_bt_start_advertisements(BTM_BLE_ADVERT_OFF, BLE_ADDR_PUBLIC, NULL); - /* Delete the heap allocated during BLE Advertisment Stop */ + /* Delete the heap allocated during BLE Advertisement Stop */ if (p_heap) { wiced_bt_delete_heap(p_heap); diff --git a/src/platform/mt793x/BLEManagerImpl.cpp b/src/platform/mt793x/BLEManagerImpl.cpp index d1f92e1b2977ac..f1ac9bfa707b88 100644 --- a/src/platform/mt793x/BLEManagerImpl.cpp +++ b/src/platform/mt793x/BLEManagerImpl.cpp @@ -656,7 +656,7 @@ void BLEManagerImpl::BleAdvTimeoutHandler(TimerHandle_t xTimer) else if (BLEMgrImpl().mFlags.Has(Flags::kAdvertising)) { // Advertisement time expired. Stop advertising - ChipLogDetail(DeviceLayer, "bleAdv Timeout : Stop advertissement"); + ChipLogDetail(DeviceLayer, "bleAdv Timeout : Stop advertisement"); BLEMgr().SetAdvertisingEnabled(false); } } diff --git a/src/platform/silabs/efr32/BLEManagerImpl.cpp b/src/platform/silabs/efr32/BLEManagerImpl.cpp index 193d15bb018d6b..bd4aee39cf8160 100644 --- a/src/platform/silabs/efr32/BLEManagerImpl.cpp +++ b/src/platform/silabs/efr32/BLEManagerImpl.cpp @@ -545,7 +545,7 @@ CHIP_ERROR BLEManagerImpl::StartAdvertising(void) } else { - ChipLogDetail(DeviceLayer, "Start BLE advertissement"); + ChipLogDetail(DeviceLayer, "Start BLE advertisement"); } const uint8_t kResolvableRandomAddrType = 2; // Private resolvable random address type @@ -976,7 +976,7 @@ void BLEManagerImpl::BleAdvTimeoutHandler(TimerHandle_t xTimer) { if (BLEMgrImpl().mFlags.Has(Flags::kFastAdvertisingEnabled)) { - ChipLogDetail(DeviceLayer, "bleAdv Timeout : Start slow advertissment"); + ChipLogDetail(DeviceLayer, "bleAdv Timeout : Start slow advertisement"); BLEMgrImpl().mFlags.Set(Flags::kAdvertising); BLEMgr().SetAdvertisingMode(BLEAdvertisingMode::kSlowAdvertising); #if CHIP_DEVICE_CONFIG_BLE_EXT_ADVERTISING @@ -987,7 +987,7 @@ void BLEManagerImpl::BleAdvTimeoutHandler(TimerHandle_t xTimer) #if CHIP_DEVICE_CONFIG_BLE_EXT_ADVERTISING else { - ChipLogDetail(DeviceLayer, "bleAdv Timeout : Start extended advertisment"); + ChipLogDetail(DeviceLayer, "bleAdv Timeout : Start extended advertisement"); BLEMgrImpl().mFlags.Set(Flags::kAdvertising); BLEMgrImpl().mFlags.Set(Flags::kExtAdvertisingEnabled); BLEMgr().SetAdvertisingMode(BLEAdvertisingMode::kSlowAdvertising); diff --git a/src/platform/silabs/rs911x/BLEManagerImpl.cpp b/src/platform/silabs/rs911x/BLEManagerImpl.cpp index a32d46b30f2715..d7e79f59dc8318 100644 --- a/src/platform/silabs/rs911x/BLEManagerImpl.cpp +++ b/src/platform/silabs/rs911x/BLEManagerImpl.cpp @@ -672,7 +672,7 @@ CHIP_ERROR BLEManagerImpl::StartAdvertising(void) } else { - ChipLogDetail(DeviceLayer, "Start BLE advertissement"); + ChipLogDetail(DeviceLayer, "Start BLE advertisement"); } if (!(mFlags.Has(Flags::kAdvertising))) @@ -1072,7 +1072,7 @@ void BLEManagerImpl::BleAdvTimeoutHandler(TimerHandle_t xTimer) { if (BLEMgrImpl().mFlags.Has(Flags::kFastAdvertisingEnabled)) { - ChipLogDetail(DeviceLayer, "bleAdv Timeout : Start slow advertissment"); + ChipLogDetail(DeviceLayer, "bleAdv Timeout : Start slow advertisement"); BLEMgr().SetAdvertisingMode(BLEAdvertisingMode::kSlowAdvertising); } } diff --git a/src/platform/stm32/BLEManagerImpl.cpp b/src/platform/stm32/BLEManagerImpl.cpp index 1cffd11b783487..60863a2da6a698 100644 --- a/src/platform/stm32/BLEManagerImpl.cpp +++ b/src/platform/stm32/BLEManagerImpl.cpp @@ -702,14 +702,14 @@ void BLEManagerImpl::BleAdvTimeoutHandler(TimerHandle_t xTimer) if (BLEMgrImpl().mFlags.Has(Flags::kFastAdvertisingEnabled)) { /* Stop advertising and defer restart for when stop confirmation is received from the stack */ - ChipLogDetail(DeviceLayer, "bleAdv Timeout : Stop advertissement"); + ChipLogDetail(DeviceLayer, "bleAdv Timeout : Stop advertisement"); sInstance.StopAdvertising(); sInstance.mFlags.Set(Flags::kRestartAdvertising); } else if (BLEMgrImpl().mFlags.Has(Flags::kAdvertising)) { // Advertisement time expired. Stop advertising - ChipLogDetail(DeviceLayer, "bleAdv Timeout : Stop advertissement"); + ChipLogDetail(DeviceLayer, "bleAdv Timeout : Stop advertisement"); BLEMgr().SetAdvertisingEnabled(false); } } From bc98a6a1e336d2228ad39368f8b07dbb59b93f47 Mon Sep 17 00:00:00 2001 From: Arkadiusz Bokowy Date: Wed, 24 Jan 2024 20:00:10 +0100 Subject: [PATCH 09/14] Do not specify advertisement timeout in BlueZ --- src/platform/Linux/bluez/BluezAdvertisement.cpp | 2 +- src/platform/Linux/dbus/bluez/DbusBluez.xml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/platform/Linux/bluez/BluezAdvertisement.cpp b/src/platform/Linux/bluez/BluezAdvertisement.cpp index 8c79a92b1dcfd1..e5050ed714c8ad 100644 --- a/src/platform/Linux/bluez/BluezAdvertisement.cpp +++ b/src/platform/Linux/bluez/BluezAdvertisement.cpp @@ -92,7 +92,7 @@ BluezLEAdvertisement1 * BluezAdvertisement::CreateLEAdvertisement() bluez_leadvertisement1_set_local_name(adv, localNamePtr); bluez_leadvertisement1_set_appearance(adv, 0xffff /* no appearance */); // empty duration - bluez_leadvertisement1_set_timeout(adv, 0); + // empty timeout // empty secondary channel for now bluez_object_skeleton_set_leadvertisement1(object, adv); diff --git a/src/platform/Linux/dbus/bluez/DbusBluez.xml b/src/platform/Linux/dbus/bluez/DbusBluez.xml index e6539ff6d94562..00887dc5e147a9 100644 --- a/src/platform/Linux/dbus/bluez/DbusBluez.xml +++ b/src/platform/Linux/dbus/bluez/DbusBluez.xml @@ -188,7 +188,7 @@ - + From d454113bfc7fed2cc1db9e2a5fc4978481aeb88f Mon Sep 17 00:00:00 2001 From: Arkadiusz Bokowy Date: Wed, 24 Jan 2024 20:13:06 +0100 Subject: [PATCH 10/14] Add support for extended advertisement --- src/platform/Linux/BLEManagerImpl.cpp | 26 +++++++++ src/platform/Linux/BLEManagerImpl.h | 1 + .../Linux/bluez/BluezAdvertisement.cpp | 56 ++++++++++++------- src/platform/Linux/bluez/BluezAdvertisement.h | 8 +-- 4 files changed, 68 insertions(+), 23 deletions(-) diff --git a/src/platform/Linux/BLEManagerImpl.cpp b/src/platform/Linux/BLEManagerImpl.cpp index 2c23df08c7f0a3..90007099ba0a01 100644 --- a/src/platform/Linux/BLEManagerImpl.cpp +++ b/src/platform/Linux/BLEManagerImpl.cpp @@ -56,6 +56,13 @@ static constexpr System::Clock::Timeout kNewConnectionScanTimeout = System::Cloc static constexpr System::Clock::Timeout kConnectTimeout = System::Clock::Seconds16(20); static constexpr System::Clock::Timeout kFastAdvertiseTimeout = System::Clock::Milliseconds32(CHIP_DEVICE_CONFIG_BLE_ADVERTISING_INTERVAL_CHANGE_TIME); +#if CHIP_DEVICE_CONFIG_BLE_EXT_ADVERTISING +// The CHIP_DEVICE_CONFIG_BLE_EXT_ADVERTISING_INTERVAL_CHANGE_TIME_MS specifies the transition time +// starting from advertisement commencement. Since the extended advertisement timer is started after +// the fast-to-slow transition, we have to subtract the time spent in fast advertising. +static constexpr System::Clock::Timeout kSlowAdvertiseTimeout = System::Clock::Milliseconds32( + CHIP_DEVICE_CONFIG_BLE_EXT_ADVERTISING_INTERVAL_CHANGE_TIME_MS - CHIP_DEVICE_CONFIG_BLE_ADVERTISING_INTERVAL_CHANGE_TIME); +#endif const ChipBleUUID ChipUUID_CHIPoBLEChar_RX = { { 0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F, 0x9D, 0x11 } }; @@ -593,6 +600,8 @@ void BLEManagerImpl::DriveBLEState() mFlags.Set(Flags::kAdvertisingConfigured); } + // Setup service data for advertising. + SuccessOrExit(err = mBLEAdvertisement.SetupServiceData(mFlags.Has(Flags::kExtAdvertisingEnabled))); // Set or update the advertising intervals. SuccessOrExit(err = mBLEAdvertisement.SetIntervals(GetAdvertisingIntervals())); @@ -640,6 +649,10 @@ BluezAdvertisement::AdvertisingIntervals BLEManagerImpl::GetAdvertisingIntervals { if (mFlags.Has(Flags::kFastAdvertisingEnabled)) return { CHIP_DEVICE_CONFIG_BLE_FAST_ADVERTISING_INTERVAL_MIN, CHIP_DEVICE_CONFIG_BLE_FAST_ADVERTISING_INTERVAL_MAX }; +#if CHIP_DEVICE_CONFIG_BLE_EXT_ADVERTISING + if (mFlags.Has(Flags::kExtAdvertisingEnabled)) + return { CHIP_DEVICE_CONFIG_BLE_EXT_ADVERTISING_INTERVAL_MIN, CHIP_DEVICE_CONFIG_BLE_EXT_ADVERTISING_INTERVAL_MAX }; +#endif return { CHIP_DEVICE_CONFIG_BLE_SLOW_ADVERTISING_INTERVAL_MIN, CHIP_DEVICE_CONFIG_BLE_SLOW_ADVERTISING_INTERVAL_MAX }; } @@ -651,7 +664,20 @@ void BLEManagerImpl::HandleAdvertisingTimer(chip::System::Layer *, void * appSta { ChipLogDetail(DeviceLayer, "bleAdv Timeout : Start slow advertisement"); self->_SetAdvertisingMode(BLEAdvertisingMode::kSlowAdvertising); +#if CHIP_DEVICE_CONFIG_BLE_EXT_ADVERTISING + self->mFlags.Clear(Flags::kExtAdvertisingEnabled); + DeviceLayer::SystemLayer().StartTimer(kSlowAdvertiseTimeout, HandleAdvertisingTimer, self); +#endif + } +#if CHIP_DEVICE_CONFIG_BLE_EXT_ADVERTISING + else + { + ChipLogDetail(DeviceLayer, "bleAdv Timeout : Start extended advertisement"); + self->mFlags.Set(Flags::kExtAdvertisingEnabled); + // This should trigger advertising update/refresh. + self->_SetAdvertisingMode(BLEAdvertisingMode::kSlowAdvertising); } +#endif } void BLEManagerImpl::InitiateScan(BleScanState scanType) diff --git a/src/platform/Linux/BLEManagerImpl.h b/src/platform/Linux/BLEManagerImpl.h index faa9e5d250c20e..1441f2e6573573 100644 --- a/src/platform/Linux/BLEManagerImpl.h +++ b/src/platform/Linux/BLEManagerImpl.h @@ -166,6 +166,7 @@ class BLEManagerImpl final : public BLEManager, kFastAdvertisingEnabled = 0x0080, /**< The application has enabled fast advertising. */ kUseCustomDeviceName = 0x0100, /**< The application has configured a custom BLE device name. */ kAdvertisingRefreshNeeded = 0x0200, /**< The advertising configuration/state in BLE layer needs to be updated. */ + kExtAdvertisingEnabled = 0x0400, /**< The application has enabled CHIPoBLE extended advertising. */ }; enum diff --git a/src/platform/Linux/bluez/BluezAdvertisement.cpp b/src/platform/Linux/bluez/BluezAdvertisement.cpp index e5050ed714c8ad..456f90dbc0a34d 100644 --- a/src/platform/Linux/bluez/BluezAdvertisement.cpp +++ b/src/platform/Linux/bluez/BluezAdvertisement.cpp @@ -42,11 +42,8 @@ BluezLEAdvertisement1 * BluezAdvertisement::CreateLEAdvertisement() { BluezLEAdvertisement1 * adv; BluezObjectSkeleton * object; - GVariant * serviceData; GVariant * serviceUUID; - GVariantBuilder serviceDataBuilder; GVariantBuilder serviceUUIDsBuilder; - GAutoPtr debugStr; const char * localNamePtr; char localName[32]; @@ -55,11 +52,7 @@ BluezLEAdvertisement1 * BluezAdvertisement::CreateLEAdvertisement() adv = bluez_leadvertisement1_skeleton_new(); - g_variant_builder_init(&serviceDataBuilder, G_VARIANT_TYPE("a{sv}")); g_variant_builder_init(&serviceUUIDsBuilder, G_VARIANT_TYPE("as")); - - g_variant_builder_add(&serviceDataBuilder, "{sv}", mpAdvUUID, - g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, &mDeviceIdInfo, sizeof(mDeviceIdInfo), sizeof(uint8_t))); g_variant_builder_add(&serviceUUIDsBuilder, "s", mpAdvUUID); localNamePtr = mpAdapterName; @@ -69,17 +62,12 @@ BluezLEAdvertisement1 * BluezAdvertisement::CreateLEAdvertisement() localNamePtr = localName; } - serviceData = g_variant_builder_end(&serviceDataBuilder); serviceUUID = g_variant_builder_end(&serviceUUIDsBuilder); - debugStr = GAutoPtr(g_variant_print(serviceData, TRUE)); - ChipLogDetail(DeviceLayer, "SET service data to %s", StringOrNullMarker(debugStr.get())); - bluez_leadvertisement1_set_type_(adv, "peripheral"); bluez_leadvertisement1_set_service_uuids(adv, serviceUUID); // empty manufacturer data // empty solicit UUIDs - bluez_leadvertisement1_set_service_data(adv, serviceData); // empty data // Setting "Discoverable" to False on the adapter and to True on the advertisement convinces @@ -144,13 +132,6 @@ CHIP_ERROR BluezAdvertisement::Init(const BluezEndpoint & aEndpoint, const char mpAdvPath = g_strdup_printf("%s/advertising", rootPath.get()); mpAdvUUID = g_strdup(aAdvUUID); - err = ConfigurationMgr().GetBLEDeviceIdentificationInfo(mDeviceIdInfo); - ReturnErrorOnFailure(err); - -#if CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING - mDeviceIdInfo.SetAdditionalDataFlag(true); -#endif - err = PlatformMgrImpl().GLibMatterContextInvokeSync( +[](BluezAdvertisement * self) { return self->InitImpl(); }, this); VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_INCORRECT_STATE, @@ -172,6 +153,43 @@ CHIP_ERROR BluezAdvertisement::SetIntervals(AdvertisingIntervals aAdvIntervals) return CHIP_NO_ERROR; } +CHIP_ERROR BluezAdvertisement::SetupServiceData(bool aExtendedAnnouncement) +{ + VerifyOrReturnError(mpAdv != nullptr, CHIP_ERROR_UNINITIALIZED); + + Ble::ChipBLEDeviceIdentificationInfo deviceInfo; + ReturnErrorOnFailure(ConfigurationMgr().GetBLEDeviceIdentificationInfo(deviceInfo)); + +#if CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING + deviceInfo.SetAdditionalDataFlag(true); +#endif + +#if CHIP_DEVICE_CONFIG_BLE_EXT_ADVERTISING + if (aExtendedAnnouncement) + { + deviceInfo.SetExtendedAnnouncementFlag(true); + // In case of extended advertisement, specification requires that + // the vendor ID and product ID are set to 0. + deviceInfo.SetVendorId(0); + deviceInfo.SetProductId(0); + } +#endif + + GVariantBuilder serviceDataBuilder; + g_variant_builder_init(&serviceDataBuilder, G_VARIANT_TYPE("a{sv}")); + g_variant_builder_add(&serviceDataBuilder, "{sv}", mpAdvUUID, + g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, &deviceInfo, sizeof(deviceInfo), sizeof(uint8_t))); + + GVariant * serviceData = g_variant_builder_end(&serviceDataBuilder); + + GAutoPtr debugStr(g_variant_print(serviceData, TRUE)); + ChipLogDetail(DeviceLayer, "SET service data to %s", StringOrNullMarker(debugStr.get())); + + bluez_leadvertisement1_set_service_data(mpAdv, serviceData); + + return CHIP_NO_ERROR; +} + void BluezAdvertisement::Shutdown() { VerifyOrReturn(mIsInitialized); diff --git a/src/platform/Linux/bluez/BluezAdvertisement.h b/src/platform/Linux/bluez/BluezAdvertisement.h index 673c455e955b24..52cc967439eeba 100644 --- a/src/platform/Linux/bluez/BluezAdvertisement.h +++ b/src/platform/Linux/bluez/BluezAdvertisement.h @@ -46,6 +46,7 @@ class BluezAdvertisement ~BluezAdvertisement() { Shutdown(); } CHIP_ERROR Init(const BluezEndpoint & aEndpoint, const char * aAdvUUID); + CHIP_ERROR SetupServiceData(bool aExtendedAnnouncement); CHIP_ERROR SetIntervals(AdvertisingIntervals aAdvIntervals); void Shutdown(); @@ -81,10 +82,9 @@ class BluezAdvertisement bool mIsInitialized = false; bool mIsAdvertising = false; - Ble::ChipBLEDeviceIdentificationInfo mDeviceIdInfo; - char * mpAdvPath = nullptr; - char * mpAdapterName = nullptr; - char * mpAdvUUID = nullptr; + char * mpAdvPath = nullptr; + char * mpAdapterName = nullptr; + char * mpAdvUUID = nullptr; }; } // namespace Internal From 246e80c44fc9bf4af141537a9c08d974e0961ff6 Mon Sep 17 00:00:00 2001 From: Arkadiusz Bokowy Date: Thu, 25 Jan 2024 09:12:13 +0100 Subject: [PATCH 11/14] Post review changes - add manual how to enable experimental features in BlueZ --- docs/guides/BUILDING.md | 27 +++++++++++++++++++ src/platform/Linux/BLEManagerImpl.cpp | 14 ++++++---- .../Linux/bluez/BluezAdvertisement.cpp | 4 +-- src/platform/Linux/bluez/BluezAdvertisement.h | 6 ++++- 4 files changed, 43 insertions(+), 8 deletions(-) diff --git a/docs/guides/BUILDING.md b/docs/guides/BUILDING.md index 89e657f834a350..74de46dae549dd 100644 --- a/docs/guides/BUILDING.md +++ b/docs/guides/BUILDING.md @@ -94,6 +94,33 @@ Complete the following steps: 1. Reboot your Raspberry Pi after installing `pi-bluetooth`. +#### Enable experimental Bluetooth support in BlueZ + +The Matter application on Linux uses BlueZ to communicate with the Bluetooth +controller. The BlueZ version that comes with Ubuntu 22.04 does not support +all the features required by the Matter application by default. To enable these +features, you need to enable experimental Bluetooth support in BlueZ. + +1. Edit the `bluetooth.service` unit by running the following command: + + ```sh + sudo systemctl edit bluetooth.service + ``` + +1. Add the following content to the override file: + + ```ini + [Service] + ExecStart= + ExecStart=/usr/lib/bluetooth/bluetoothd -E + ``` + +1. Restart the Bluetooth service by running the following command: + + ```sh + sudo systemctl restart bluetooth.service + ``` + #### Configuring wpa_supplicant for storing permanent changes By default, wpa_supplicant is not allowed to update (overwrite) configuration. diff --git a/src/platform/Linux/BLEManagerImpl.cpp b/src/platform/Linux/BLEManagerImpl.cpp index 90007099ba0a01..1ae62db48438f3 100644 --- a/src/platform/Linux/BLEManagerImpl.cpp +++ b/src/platform/Linux/BLEManagerImpl.cpp @@ -601,7 +601,13 @@ void BLEManagerImpl::DriveBLEState() } // Setup service data for advertising. - SuccessOrExit(err = mBLEAdvertisement.SetupServiceData(mFlags.Has(Flags::kExtAdvertisingEnabled))); + auto serviceDataFlags = BluezAdvertisement::kServiceDataNone; +#if CHIP_DEVICE_CONFIG_BLE_EXT_ADVERTISING + if (mFlags.Has(Flags::kExtAdvertisingEnabled)) + serviceDataFlags |= BluezAdvertisement::kServiceDataExtendedAnnouncement; +#endif + SuccessOrExit(err = mBLEAdvertisement.SetupServiceData(serviceDataFlags)); + // Set or update the advertising intervals. SuccessOrExit(err = mBLEAdvertisement.SetIntervals(GetAdvertisingIntervals())); @@ -667,17 +673,15 @@ void BLEManagerImpl::HandleAdvertisingTimer(chip::System::Layer *, void * appSta #if CHIP_DEVICE_CONFIG_BLE_EXT_ADVERTISING self->mFlags.Clear(Flags::kExtAdvertisingEnabled); DeviceLayer::SystemLayer().StartTimer(kSlowAdvertiseTimeout, HandleAdvertisingTimer, self); -#endif } -#if CHIP_DEVICE_CONFIG_BLE_EXT_ADVERTISING else { ChipLogDetail(DeviceLayer, "bleAdv Timeout : Start extended advertisement"); self->mFlags.Set(Flags::kExtAdvertisingEnabled); - // This should trigger advertising update/refresh. + // This will trigger advertising intervals update in the DriveBLEState() function. self->_SetAdvertisingMode(BLEAdvertisingMode::kSlowAdvertising); - } #endif + } } void BLEManagerImpl::InitiateScan(BleScanState scanType) diff --git a/src/platform/Linux/bluez/BluezAdvertisement.cpp b/src/platform/Linux/bluez/BluezAdvertisement.cpp index 456f90dbc0a34d..cc4bed5f485241 100644 --- a/src/platform/Linux/bluez/BluezAdvertisement.cpp +++ b/src/platform/Linux/bluez/BluezAdvertisement.cpp @@ -153,7 +153,7 @@ CHIP_ERROR BluezAdvertisement::SetIntervals(AdvertisingIntervals aAdvIntervals) return CHIP_NO_ERROR; } -CHIP_ERROR BluezAdvertisement::SetupServiceData(bool aExtendedAnnouncement) +CHIP_ERROR BluezAdvertisement::SetupServiceData(ServiceDataFlags aFlags) { VerifyOrReturnError(mpAdv != nullptr, CHIP_ERROR_UNINITIALIZED); @@ -165,7 +165,7 @@ CHIP_ERROR BluezAdvertisement::SetupServiceData(bool aExtendedAnnouncement) #endif #if CHIP_DEVICE_CONFIG_BLE_EXT_ADVERTISING - if (aExtendedAnnouncement) + if (aFlags & kServiceDataExtendedAnnouncement) { deviceInfo.SetExtendedAnnouncementFlag(true); // In case of extended advertisement, specification requires that diff --git a/src/platform/Linux/bluez/BluezAdvertisement.h b/src/platform/Linux/bluez/BluezAdvertisement.h index 52cc967439eeba..a82a024fcea1fe 100644 --- a/src/platform/Linux/bluez/BluezAdvertisement.h +++ b/src/platform/Linux/bluez/BluezAdvertisement.h @@ -39,14 +39,18 @@ class BluezEndpoint; class BluezAdvertisement { public: + using ServiceDataFlags = uint16_t; // Minimum and maximum advertising intervals in units of 0.625ms. using AdvertisingIntervals = std::pair; + static constexpr ServiceDataFlags kServiceDataNone = 0; + static constexpr ServiceDataFlags kServiceDataExtendedAnnouncement = 1 << 0; + BluezAdvertisement() = default; ~BluezAdvertisement() { Shutdown(); } CHIP_ERROR Init(const BluezEndpoint & aEndpoint, const char * aAdvUUID); - CHIP_ERROR SetupServiceData(bool aExtendedAnnouncement); + CHIP_ERROR SetupServiceData(ServiceDataFlags aFlags); CHIP_ERROR SetIntervals(AdvertisingIntervals aAdvIntervals); void Shutdown(); From 91c8d20d9b2ecb31d65a2a98016870fca239efb7 Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Thu, 25 Jan 2024 08:13:59 +0000 Subject: [PATCH 12/14] Restyled by prettier-markdown --- docs/guides/BUILDING.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/guides/BUILDING.md b/docs/guides/BUILDING.md index 74de46dae549dd..8e32d6dc4a3c66 100644 --- a/docs/guides/BUILDING.md +++ b/docs/guides/BUILDING.md @@ -97,8 +97,8 @@ Complete the following steps: #### Enable experimental Bluetooth support in BlueZ The Matter application on Linux uses BlueZ to communicate with the Bluetooth -controller. The BlueZ version that comes with Ubuntu 22.04 does not support -all the features required by the Matter application by default. To enable these +controller. The BlueZ version that comes with Ubuntu 22.04 does not support all +the features required by the Matter application by default. To enable these features, you need to enable experimental Bluetooth support in BlueZ. 1. Edit the `bluetooth.service` unit by running the following command: From 6c8137ffbb235adf46d6d0df5c0b04adf2d2d3d9 Mon Sep 17 00:00:00 2001 From: Arkadiusz Bokowy Date: Mon, 29 Jan 2024 09:16:54 +0100 Subject: [PATCH 13/14] Assert that extended adv interval is >= fast adv interval --- src/platform/Linux/BLEManagerImpl.cpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/platform/Linux/BLEManagerImpl.cpp b/src/platform/Linux/BLEManagerImpl.cpp index 1ae62db48438f3..2b5c4ad166aa42 100644 --- a/src/platform/Linux/BLEManagerImpl.cpp +++ b/src/platform/Linux/BLEManagerImpl.cpp @@ -62,6 +62,9 @@ static constexpr System::Clock::Timeout kFastAdvertiseTimeout = // the fast-to-slow transition, we have to subtract the time spent in fast advertising. static constexpr System::Clock::Timeout kSlowAdvertiseTimeout = System::Clock::Milliseconds32( CHIP_DEVICE_CONFIG_BLE_EXT_ADVERTISING_INTERVAL_CHANGE_TIME_MS - CHIP_DEVICE_CONFIG_BLE_ADVERTISING_INTERVAL_CHANGE_TIME); +static_assert(CHIP_DEVICE_CONFIG_BLE_EXT_ADVERTISING_INTERVAL_CHANGE_TIME_MS >= + CHIP_DEVICE_CONFIG_BLE_ADVERTISING_INTERVAL_CHANGE_TIME, + "The extended advertising interval change time must be greater than the fast advertising interval change time"); #endif const ChipBleUUID ChipUUID_CHIPoBLEChar_RX = { { 0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F, From ef2ced020965498bf45dca89a0adf30a43f94128 Mon Sep 17 00:00:00 2001 From: Arkadiusz Bokowy Date: Mon, 29 Jan 2024 09:24:01 +0100 Subject: [PATCH 14/14] Cancel HandleAdvertisingTimer timer in case of error --- src/platform/Linux/BLEManagerImpl.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/platform/Linux/BLEManagerImpl.cpp b/src/platform/Linux/BLEManagerImpl.cpp index 2b5c4ad166aa42..e1ce775d071901 100644 --- a/src/platform/Linux/BLEManagerImpl.cpp +++ b/src/platform/Linux/BLEManagerImpl.cpp @@ -315,6 +315,7 @@ void BLEManagerImpl::HandlePlatformSpecificBLEEvent(const ChipDeviceEvent * apEv { ChipLogError(DeviceLayer, "Disabling CHIPoBLE service due to error: %s", ErrorStr(err)); mServiceMode = ConnectivityManager::kCHIPoBLEServiceMode_Disabled; + DeviceLayer::SystemLayer().CancelTimer(HandleAdvertisingTimer, this); sInstance.mFlags.Clear(Flags::kControlOpInProgress); }