[Linux] Wrap BlueZ endpoint functions in a class

src/platform/Linux/BLEManagerImpl.cpp

@@ -32,7 +32,6 @@
  *       platform/<PLATFORM>/BLEManagerImpl.h after defining interface class. */
 #include "platform/internal/BLEManager.h"
 
-#include <cassert>
 #include <type_traits>
 #include <utility>
 
@@ -63,9 +62,8 @@ const ChipBleUUID ChipUUID_CHIPoBLEChar_TX = { { 0x18, 0xEE, 0x2E, 0xF5, 0x26, 0
 
 void HandleConnectTimeout(chip::System::Layer *, void * apEndpoint)
 {
-    assert(apEndpoint != nullptr);
-
-    CancelConnect(static_cast<BluezEndpoint *>(apEndpoint));
+    VerifyOrDie(apEndpoint != nullptr);
+    static_cast<BluezEndpoint *>(apEndpoint)->CancelConnect();
     BLEManagerImpl::HandleConnectFailed(CHIP_ERROR_TIMEOUT);
 }
 
@@ -105,8 +103,10 @@ void BLEManagerImpl::_Shutdown()
     mDeviceScanner.Shutdown();
     // Stop advertising and free resources.
     mBLEAdvertisement.Shutdown();
+    // Make sure that the endpoint is not used by the timer.
+    DeviceLayer::SystemLayer().CancelTimer(HandleConnectTimeout, &mEndpoint);
     // Release BLE connection resources (unregister from BlueZ).
-    ShutdownBluezBleLayer(mpEndpoint);
+    mEndpoint.Shutdown();
     mFlags.Clear(Flags::kBluezBLELayerInitialized);
 }
 
@@ -571,16 +571,14 @@ void BLEManagerImpl::DriveBLEState()
     // Initializes the Bluez BLE layer if needed.
     if (mServiceMode == ConnectivityManager::kCHIPoBLEServiceMode_Enabled && !mFlags.Has(Flags::kBluezBLELayerInitialized))
     {
-        err = InitBluezBleLayer(mAdapterId, mIsCentral, nullptr, mDeviceName, mpEndpoint);
-        SuccessOrExit(err);
+        SuccessOrExit(err = mEndpoint.Init(mAdapterId, mIsCentral, nullptr, mDeviceName));
         mFlags.Set(Flags::kBluezBLELayerInitialized);
     }
 
     // Register the CHIPoBLE application with the Bluez BLE layer if needed.
     if (!mIsCentral && mServiceMode == ConnectivityManager::kCHIPoBLEServiceMode_Enabled && !mFlags.Has(Flags::kAppRegistered))
     {
-        err = BluezGattsAppRegister(mpEndpoint);
-        SuccessOrExit(err);
+        SuccessOrExit(err = mEndpoint.RegisterGattApplication());
         mFlags.Set(Flags::kControlOpInProgress);
         ExitNow();
     }
@@ -597,15 +595,13 @@ void BLEManagerImpl::DriveBLEState()
             // Configure advertising data if it hasn't been done yet.
             if (!mFlags.Has(Flags::kAdvertisingConfigured))
             {
-                err = mBLEAdvertisement.Init(mpEndpoint, mBLEAdvType, mpBLEAdvUUID, mBLEAdvDurationMs);
-                SuccessOrExit(err);
+                SuccessOrExit(err = mBLEAdvertisement.Init(mEndpoint, mBLEAdvType, mpBLEAdvUUID, mBLEAdvDurationMs));
                 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.
-            err = mBLEAdvertisement.Start();
-            SuccessOrExit(err);
+            SuccessOrExit(err = mBLEAdvertisement.Start());
             mFlags.Set(Flags::kControlOpInProgress);
             ExitNow();
         }
@@ -616,8 +612,7 @@ void BLEManagerImpl::DriveBLEState()
     {
         if (mFlags.Has(Flags::kAdvertising))
         {
-            err = mBLEAdvertisement.Stop();
-            SuccessOrExit(err);
+            SuccessOrExit(err = mBLEAdvertisement.Stop());
             mFlags.Set(Flags::kControlOpInProgress);
 
             ExitNow();
@@ -653,14 +648,14 @@ void BLEManagerImpl::InitiateScan(BleScanState scanType)
         return;
     }
 
-    if (mpEndpoint == nullptr)
+    if (!mFlags.Has(Flags::kBluezBLELayerInitialized))
     {
         BleConnectionDelegate::OnConnectionError(mBLEScanConfig.mAppState, CHIP_ERROR_INCORRECT_STATE);
         ChipLogError(Ble, "BLE Layer is not yet initialized");
         return;
     }
 
-    if (mpEndpoint->mpAdapter == nullptr)
+    if (mEndpoint.GetAdapter() == nullptr)
     {
         BleConnectionDelegate::OnConnectionError(mBLEScanConfig.mAppState, CHIP_ERROR_INCORRECT_STATE);
         ChipLogError(Ble, "No adapter available for new connection establishment");
@@ -669,7 +664,7 @@ void BLEManagerImpl::InitiateScan(BleScanState scanType)
 
     mBLEScanConfig.mBleScanState = scanType;
 
-    CHIP_ERROR err = mDeviceScanner.Init(mpEndpoint->mpAdapter, this);
+    CHIP_ERROR err = mDeviceScanner.Init(mEndpoint.GetAdapter(), this);
     if (err != CHIP_NO_ERROR)
     {
         mBLEScanConfig.mBleScanState = BleScanState::kNotScanning;
@@ -691,7 +686,7 @@ void BLEManagerImpl::InitiateScan(BleScanState scanType)
 void BLEManagerImpl::CleanScanConfig()
 {
     if (mBLEScanConfig.mBleScanState == BleScanState::kConnecting)
-        DeviceLayer::SystemLayer().CancelTimer(HandleConnectTimeout, mpEndpoint);
+        DeviceLayer::SystemLayer().CancelTimer(HandleConnectTimeout, &mEndpoint);
 
     mBLEScanConfig.mBleScanState = BleScanState::kNotScanning;
 }
@@ -713,7 +708,7 @@ void BLEManagerImpl::NewConnection(BleLayer * bleLayer, void * appState, const S
 CHIP_ERROR BLEManagerImpl::CancelConnection()
 {
     if (mBLEScanConfig.mBleScanState == BleScanState::kConnecting)
-        CancelConnect(mpEndpoint);
+        mEndpoint.CancelConnect();
     // If in discovery mode, stop scan.
     else if (mBLEScanConfig.mBleScanState != BleScanState::kNotScanning)
         mDeviceScanner.StopScan();
@@ -777,12 +772,12 @@ void BLEManagerImpl::OnDeviceScanned(BluezDevice1 & device, const chip::Ble::Chi
     mBLEScanConfig.mBleScanState = BleScanState::kConnecting;
 
     chip::DeviceLayer::PlatformMgr().LockChipStack();
-    DeviceLayer::SystemLayer().StartTimer(kConnectTimeout, HandleConnectTimeout, mpEndpoint);
+    DeviceLayer::SystemLayer().StartTimer(kConnectTimeout, HandleConnectTimeout, &mEndpoint);
     chip::DeviceLayer::PlatformMgr().UnlockChipStack();
 
     mDeviceScanner.StopScan();
 
-    ConnectDevice(device, mpEndpoint);
+    mEndpoint.ConnectDevice(device);
 }
 
 void BLEManagerImpl::OnScanComplete()

src/platform/Linux/BLEManagerImpl.h

@@ -185,8 +185,8 @@ class BLEManagerImpl final : public BLEManager,
 
     uint32_t mAdapterId = 0;
     char mDeviceName[kMaxDeviceNameLength + 1];
-    bool mIsCentral            = false;
-    BluezEndpoint * mpEndpoint = nullptr;
+    bool mIsCentral = false;
+    BluezEndpoint mEndpoint;
 
     BluezAdvertisement mBLEAdvertisement;
     ChipAdvType mBLEAdvType    = ChipAdvType::BLUEZ_ADV_TYPE_UNDIRECTED_CONNECTABLE_SCANNABLE;

src/platform/Linux/bluez/BluezAdvertisement.cpp

@@ -133,20 +133,18 @@ CHIP_ERROR BluezAdvertisement::InitImpl()
     return CHIP_NO_ERROR;
 }
 
-CHIP_ERROR BluezAdvertisement::Init(BluezEndpoint * apEndpoint, ChipAdvType aAdvType, const char * aAdvUUID,
+CHIP_ERROR BluezAdvertisement::Init(const BluezEndpoint & aEndpoint, ChipAdvType aAdvType, const char * aAdvUUID,
                                     uint32_t aAdvDurationMs)
 {
     GAutoPtr<char> rootPath;
     CHIP_ERROR err;
 
-    VerifyOrExit(apEndpoint != nullptr, err = CHIP_ERROR_INCORRECT_STATE;
-                 ChipLogError(DeviceLayer, "FAIL: NULL endpoint in %s", __func__));
     VerifyOrExit(mpAdv == nullptr, err = CHIP_ERROR_INCORRECT_STATE;
                  ChipLogError(DeviceLayer, "FAIL: BLE advertisement already initialized in %s", __func__));
 
-    mpRoot        = reinterpret_cast<GDBusObjectManagerServer *>(g_object_ref(apEndpoint->mpRoot));
-    mpAdapter     = reinterpret_cast<BluezAdapter1 *>(g_object_ref(apEndpoint->mpAdapter));
-    mpAdapterName = g_strdup(apEndpoint->mpAdapterName);
+    mpRoot        = reinterpret_cast<GDBusObjectManagerServer *>(g_object_ref(aEndpoint.GetGattApplicationObjectManager()));
+    mpAdapter     = reinterpret_cast<BluezAdapter1 *>(g_object_ref(aEndpoint.GetAdapter()));
+    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());

src/platform/Linux/bluez/BluezAdvertisement.h

@@ -33,15 +33,15 @@ namespace chip {
 namespace DeviceLayer {
 namespace Internal {
 
-struct BluezEndpoint;
+class BluezEndpoint;
 
 class BluezAdvertisement
 {
 public:
     BluezAdvertisement() = default;
     ~BluezAdvertisement() { Shutdown(); }
 
-    CHIP_ERROR Init(BluezEndpoint * apEndpoint, ChipAdvType aAdvType, const char * aAdvUUID, uint32_t aAdvDurationMs);
+    CHIP_ERROR Init(const BluezEndpoint & aEndpoint, ChipAdvType aAdvType, const char * aAdvUUID, uint32_t aAdvDurationMs);
     void Shutdown();
 
     /// Start BLE advertising.

src/platform/Linux/bluez/BluezConnection.cpp

@@ -59,10 +59,10 @@ gboolean BluezIsCharOnService(BluezGattCharacteristic1 * aChar, BluezGattService
 
 } // namespace
 
-BluezConnection::BluezConnection(BluezEndpoint * apEndpoint, BluezDevice1 * apDevice) :
-    mpEndpoint(apEndpoint), mpDevice(BLUEZ_DEVICE1(g_object_ref(apDevice)))
+BluezConnection::BluezConnection(const BluezEndpoint & aEndpoint, BluezDevice1 * apDevice) :
+    mpDevice(BLUEZ_DEVICE1(g_object_ref(apDevice)))
 {
-    Init();
+    Init(aEndpoint);
 }
 
 BluezConnection::~BluezConnection()
@@ -93,21 +93,21 @@ BluezConnection::ConnectionDataBundle::ConnectionDataBundle(const BluezConnectio
     mData(g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, aBuf->Start(), aBuf->DataLength(), sizeof(uint8_t)))
 {}
 
-CHIP_ERROR BluezConnection::Init()
+CHIP_ERROR BluezConnection::Init(const BluezEndpoint & aEndpoint)
 {
     // populate the service and the characteristics
     GList * objects = nullptr;
     GList * l;
 
-    if (!mpEndpoint->mIsCentral)
+    if (!aEndpoint.mIsCentral)
     {
-        mpService = BLUEZ_GATT_SERVICE1(g_object_ref(mpEndpoint->mpService));
-        mpC1      = BLUEZ_GATT_CHARACTERISTIC1(g_object_ref(mpEndpoint->mpC1));
-        mpC2      = BLUEZ_GATT_CHARACTERISTIC1(g_object_ref(mpEndpoint->mpC2));
+        mpService = BLUEZ_GATT_SERVICE1(g_object_ref(aEndpoint.mpService));
+        mpC1      = BLUEZ_GATT_CHARACTERISTIC1(g_object_ref(aEndpoint.mpC1));
+        mpC2      = BLUEZ_GATT_CHARACTERISTIC1(g_object_ref(aEndpoint.mpC2));
     }
     else
     {
-        objects = g_dbus_object_manager_get_objects(mpEndpoint->mpObjMgr);
+        objects = g_dbus_object_manager_get_objects(aEndpoint.mpObjMgr);
 
         for (l = objects; l != nullptr; l = l->next)
         {

src/platform/Linux/bluez/BluezConnection.h

@@ -32,12 +32,12 @@ namespace chip {
 namespace DeviceLayer {
 namespace Internal {
 
-struct BluezEndpoint;
+class BluezEndpoint;
 
 class BluezConnection
 {
 public:
-    BluezConnection(BluezEndpoint * apEndpoint, BluezDevice1 * apDevice);
+    BluezConnection(const BluezEndpoint & aEndpoint, BluezDevice1 * apDevice);
     ~BluezConnection();
 
     const char * GetPeerAddress() const;
@@ -95,7 +95,7 @@ class BluezConnection
         GAutoPtr<GVariant> mData;
     };
 
-    CHIP_ERROR Init();
+    CHIP_ERROR Init(const BluezEndpoint & aEndpoint);
 
     static CHIP_ERROR BluezDisconnect(BluezConnection * apConn);
 
@@ -115,7 +115,6 @@ class BluezConnection
     static void UnsubscribeCharacteristicDone(GObject * aObject, GAsyncResult * aResult, gpointer apConn);
     static CHIP_ERROR UnsubscribeCharacteristicImpl(BluezConnection * apConn);
 
-    BluezEndpoint * mpEndpoint;
     BluezDevice1 * mpDevice;
 
     bool mNotifyAcquired = false;