Merge 7fba468 into f59323b

src/controller/python/chip/ble/LinuxImpl.cpp

@@ -93,7 +93,13 @@ class ScannerDelegateImpl : public ChipDeviceScannerDelegate
         mScanCallback(scanCallback), mCompleteCallback(completeCallback), mErrorCallback(errorCallback)
     {}
 
-    CHIP_ERROR ScannerInit(BluezAdapter1 * adapter) { return mScanner.Init(adapter, this); }
+    CHIP_ERROR ScannerInit(BluezAdapter1 * adapter)
+    {
+        // It's a hack of sorts on how the python API works.
+        // One more thing to consider is what should the api implementation look like with BLEManager running?
+        mEndpoint.SetAdapter(adapter);
+        return mScanner.Init(this);
+    }
     CHIP_ERROR ScannerStartScan(chip::System::Clock::Timeout timeout) { return mScanner.StartScan(timeout); }
 
     void OnDeviceScanned(BluezDevice1 & device, const chip::Ble::ChipBLEDeviceIdentificationInfo & info) override
@@ -124,7 +130,8 @@ class ScannerDelegateImpl : public ChipDeviceScannerDelegate
     }
 
 private:
-    ChipDeviceScanner mScanner;
+    BluezEndpoint mEndpoint;
+    ChipDeviceScanner mScanner{ mEndpoint };
     PyObject * const mContext;
     const DeviceScannedCallback mScanCallback;
     const ScanCompleteCallback mCompleteCallback;
@@ -142,6 +149,7 @@ extern "C" void * pychip_ble_start_scanning(PyObject * context, void * adapter,
         std::make_unique<ScannerDelegateImpl>(context, scanCallback, completeCallback, errorCallback);
 
     CHIP_ERROR err = delegate->ScannerInit(static_cast<BluezAdapter1 *>(adapter));
+
     VerifyOrReturnError(err == CHIP_NO_ERROR, nullptr);
 
     chip::DeviceLayer::PlatformMgr().LockChipStack();

src/platform/GLibTypeDeleter.h

@@ -114,6 +114,24 @@ struct GAutoPtrDeleter<GDBusConnection>
     using deleter = GObjectDeleter;
 };
 
+template <>
+struct GAutoPtrDeleter<GDBusObjectManager>
+{
+    using deleter = GObjectDeleter;
+};
+
+template <>
+struct GAutoPtrDeleter<GDBusObjectManagerServer>
+{
+    using deleter = GObjectDeleter;
+};
+
+template <>
+struct GAutoPtrDeleter<GCancellable>
+{
+    using deleter = GObjectDeleter;
+};
+
 template <>
 struct GAutoPtrDeleter<GError>
 {

src/platform/Linux/BLEManagerImpl.cpp

@@ -595,7 +595,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));
+                SuccessOrExit(err = mBLEAdvertisement.Init(mBLEAdvType, mpBLEAdvUUID, mBLEAdvDurationMs));
                 mFlags.Set(Flags::kAdvertisingConfigured);
             }
 
@@ -668,7 +668,7 @@ void BLEManagerImpl::InitiateScan(BleScanState scanType)
 
     mBLEScanConfig.mBleScanState = scanType;
 
-    CHIP_ERROR err = mDeviceScanner.Init(mEndpoint.GetAdapter(), this);
+    CHIP_ERROR err = mDeviceScanner.Init(this);
     if (err != CHIP_NO_ERROR)
     {
         mBLEScanConfig.mBleScanState = BleScanState::kNotScanning;

src/platform/Linux/BLEManagerImpl.h

@@ -188,12 +188,12 @@ class BLEManagerImpl final : public BLEManager,
     bool mIsCentral = false;
     BluezEndpoint mEndpoint;
 
-    BluezAdvertisement mBLEAdvertisement;
+    BluezAdvertisement mBLEAdvertisement{ mEndpoint };
     ChipAdvType mBLEAdvType    = ChipAdvType::BLUEZ_ADV_TYPE_UNDIRECTED_CONNECTABLE_SCANNABLE;
     uint16_t mBLEAdvDurationMs = 20;
     const char * mpBLEAdvUUID  = nullptr;
 
-    ChipDeviceScanner mDeviceScanner;
+    ChipDeviceScanner mDeviceScanner{ mEndpoint };
     BLEScanConfig mBLEScanConfig;
 };
 

src/platform/Linux/bluez/AdapterIterator.cpp

@@ -28,21 +28,10 @@ namespace Internal {
 
 AdapterIterator::~AdapterIterator()
 {
-    if (mManager != nullptr)
-    {
-        g_object_unref(mManager);
-    }
-
     if (mObjectList != nullptr)
     {
         g_list_free_full(mObjectList, g_object_unref);
     }
-
-    if (mCurrent.adapter != nullptr)
-    {
-        g_object_unref(mCurrent.adapter);
-        mCurrent.adapter = nullptr;
-    }
 }
 
 CHIP_ERROR AdapterIterator::Initialize(AdapterIterator * self)
@@ -54,15 +43,16 @@ CHIP_ERROR AdapterIterator::Initialize(AdapterIterator * self)
     CHIP_ERROR err = CHIP_NO_ERROR;
     GAutoPtr<GError> error;
 
-    self->mManager = g_dbus_object_manager_client_new_for_bus_sync(
+    self->mManager.reset(g_dbus_object_manager_client_new_for_bus_sync(
         G_BUS_TYPE_SYSTEM, G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE, BLUEZ_INTERFACE, "/",
         bluez_object_manager_client_get_proxy_type, nullptr /* unused user data in the Proxy Type Func */,
-        nullptr /*destroy notify */, nullptr /* cancellable */, &MakeUniquePointerReceiver(error).Get());
+        nullptr /*destroy notify */, nullptr /* cancellable */, &MakeUniquePointerReceiver(error).Get()));
 
-    VerifyOrExit(self->mManager != nullptr, ChipLogError(DeviceLayer, "Failed to get DBUS object manager for listing adapters.");
+    VerifyOrExit(self->mManager.get() != nullptr,
+                 ChipLogError(DeviceLayer, "Failed to get DBUS object manager for listing adapters.");
                  err = CHIP_ERROR_INTERNAL);
 
-    self->mObjectList      = g_dbus_object_manager_get_objects(self->mManager);
+    self->mObjectList      = g_dbus_object_manager_get_objects(self->mManager.get());
     self->mCurrentListItem = self->mObjectList;
 
 exit:
@@ -102,18 +92,12 @@ bool AdapterIterator::Advance()
             index = 0;
         }
 
-        if (mCurrent.adapter != nullptr)
-        {
-            g_object_unref(mCurrent.adapter);
-            mCurrent.adapter = nullptr;
-        }
-
         mCurrent.index   = index;
         mCurrent.address = bluez_adapter1_get_address(adapter);
         mCurrent.alias   = bluez_adapter1_get_alias(adapter);
         mCurrent.name    = bluez_adapter1_get_name(adapter);
         mCurrent.powered = bluez_adapter1_get_powered(adapter);
-        mCurrent.adapter = adapter;
+        mCurrent.adapter.reset(adapter);
 
         mCurrentListItem = mCurrentListItem->next;
 

src/platform/Linux/bluez/AdapterIterator.h

@@ -61,7 +61,7 @@ class AdapterIterator
     const char * GetAlias() const { return mCurrent.alias.c_str(); }
     const char * GetName() const { return mCurrent.name.c_str(); }
     bool IsPowered() const { return mCurrent.powered; }
-    BluezAdapter1 * GetAdapter() const { return mCurrent.adapter; }
+    BluezAdapter1 * GetAdapter() const { return mCurrent.adapter.get(); }
 
 private:
     /// Sets up the DBUS manager and loads the list
@@ -76,9 +76,9 @@ class AdapterIterator
     static constexpr size_t kMaxAddressLength = 19; // xx:xx:xx:xx:xx:xx
     static constexpr size_t kMaxNameLength    = 64;
 
-    GDBusObjectManager * mManager = nullptr; // DBus connection
-    GList * mObjectList           = nullptr; // listing of objects on the bus
-    GList * mCurrentListItem      = nullptr; // current item viewed in the list
+    GAutoPtr<GDBusObjectManager> mManager; // DBus connection
+    GList * mObjectList      = nullptr;    // listing of objects on the bus
+    GList * mCurrentListItem = nullptr;    // current item viewed in the list
 
     // data valid only if Next() returns true
     struct
@@ -88,7 +88,7 @@ class AdapterIterator
         std::string alias;
         std::string name;
         bool powered;
-        BluezAdapter1 * adapter;
+        GAutoPtr<BluezAdapter1> adapter;
     } mCurrent = { 0 };
 };
 

src/platform/Linux/bluez/BluezAdvertisement.cpp

@@ -62,7 +62,7 @@ BluezLEAdvertisement1 * BluezAdvertisement::CreateLEAdvertisement()
                           g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, &mDeviceIdInfo, sizeof(mDeviceIdInfo), sizeof(uint8_t)));
     g_variant_builder_add(&serviceUUIDsBuilder, "s", mpAdvUUID);
 
-    localNamePtr = mpAdapterName;
+    localNamePtr = mEndpoint.GetAdapterName();
     if (localNamePtr == nullptr)
     {
         g_snprintf(localName, sizeof(localName), "%s%04x", CHIP_DEVICE_CONFIG_BLE_DEVICE_NAME_PREFIX, getpid() & 0xffff);
@@ -72,7 +72,7 @@ BluezLEAdvertisement1 * BluezAdvertisement::CreateLEAdvertisement()
     serviceData = g_variant_builder_end(&serviceDataBuilder);
     serviceUUID = g_variant_builder_end(&serviceUUIDsBuilder);
 
-    debugStr = GAutoPtr<char>(g_variant_print(serviceData, TRUE));
+    debugStr.reset(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");
@@ -107,7 +107,7 @@ BluezLEAdvertisement1 * BluezAdvertisement::CreateLEAdvertisement()
                      }),
                      this);
 
-    g_dbus_object_manager_server_export(mpRoot, G_DBUS_OBJECT_SKELETON(object));
+    g_dbus_object_manager_server_export(mEndpoint.GetGattApplicationObjectManager(), G_DBUS_OBJECT_SKELETON(object));
     g_object_unref(object);
 
     return adv;
@@ -116,9 +116,8 @@ BluezLEAdvertisement1 * BluezAdvertisement::CreateLEAdvertisement()
 gboolean BluezAdvertisement::BluezLEAdvertisement1Release(BluezLEAdvertisement1 * aAdv, GDBusMethodInvocation * aInvocation)
 {
     ChipLogDetail(DeviceLayer, "Release BLE adv object in %s", __func__);
-    g_dbus_object_manager_server_unexport(mpRoot, mpAdvPath);
-    g_object_unref(mpAdv);
-    mpAdv          = nullptr;
+    g_dbus_object_manager_server_unexport(mEndpoint.GetGattApplicationObjectManager(), mpAdvPath);
+    mpAdv.reset();
     mIsAdvertising = false;
     return TRUE;
 }
@@ -129,24 +128,20 @@ CHIP_ERROR BluezAdvertisement::InitImpl()
     // all D-Bus signals will be delivered to the GLib global default main context.
     VerifyOrDie(g_main_context_get_thread_default() != nullptr);
 
-    mpAdv = CreateLEAdvertisement();
+    mpAdv.reset(CreateLEAdvertisement());
     return CHIP_NO_ERROR;
 }
 
-CHIP_ERROR BluezAdvertisement::Init(const BluezEndpoint & aEndpoint, ChipAdvType aAdvType, const char * aAdvUUID,
-                                    uint32_t aAdvDurationMs)
+CHIP_ERROR BluezAdvertisement::Init(ChipAdvType aAdvType, const char * aAdvUUID, uint32_t aAdvDurationMs)
 {
     GAutoPtr<char> rootPath;
     CHIP_ERROR err;
 
-    VerifyOrExit(mpAdv == nullptr, err = CHIP_ERROR_INCORRECT_STATE;
+    VerifyOrExit(mpAdv.get() == nullptr, err = CHIP_ERROR_INCORRECT_STATE;
                  ChipLogError(DeviceLayer, "FAIL: BLE advertisement already initialized in %s", __func__));
 
-    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);
+    g_object_get(G_OBJECT(mEndpoint.GetGattApplicationObjectManager()), "object-path", &MakeUniquePointerReceiver(rootPath).Get(),
+                 nullptr);
     mpAdvPath      = g_strdup_printf("%s/advertising", rootPath.get());
     mAdvType       = aAdvType;
     mpAdvUUID      = g_strdup(aAdvUUID);
@@ -188,29 +183,14 @@ void BluezAdvertisement::Shutdown()
     // attached to the advertising object that may run on the glib thread.
     PlatformMgrImpl().GLibMatterContextInvokeSync(
         +[](BluezAdvertisement * self) {
-            if (self->mpRoot != nullptr)
-            {
-                g_object_unref(self->mpRoot);
-                self->mpRoot = nullptr;
-            }
-            if (self->mpAdapter != nullptr)
-            {
-                g_object_unref(self->mpAdapter);
-                self->mpAdapter = nullptr;
-            }
-            if (self->mpAdv != nullptr)
-            {
-                g_object_unref(self->mpAdv);
-                self->mpAdv = nullptr;
-            }
+            self->mpAdv.reset();
+
             return CHIP_NO_ERROR;
         },
         this);
 
     g_free(mpAdvPath);
     mpAdvPath = nullptr;
-    g_free(mpAdapterName);
-    mpAdapterName = nullptr;
     g_free(mpAdvUUID);
     mpAdvUUID = nullptr;
 
@@ -227,7 +207,7 @@ void BluezAdvertisement::StartDone(GObject * aObject, GAsyncResult * aResult)
         bluez_leadvertising_manager1_call_register_advertisement_finish(advMgr, aResult, &MakeUniquePointerReceiver(error).Get());
     if (success == FALSE)
     {
-        g_dbus_object_manager_server_unexport(mpRoot, mpAdvPath);
+        g_dbus_object_manager_server_unexport(mEndpoint.GetGattApplicationObjectManager(), mpAdvPath);
     }
     VerifyOrExit(success == TRUE, ChipLogError(DeviceLayer, "FAIL: RegisterAdvertisement : %s", error->message));
 
@@ -247,9 +227,9 @@ CHIP_ERROR BluezAdvertisement::StartImpl()
     GVariant * options;
 
     VerifyOrExit(!mIsAdvertising, ChipLogError(DeviceLayer, "FAIL: Advertising has already been enabled in %s", __func__));
-    VerifyOrExit(mpAdapter != nullptr, ChipLogError(DeviceLayer, "FAIL: NULL mpAdapter in %s", __func__));
+    VerifyOrExit(mEndpoint.GetAdapter() != nullptr, ChipLogError(DeviceLayer, "FAIL: NULL mpAdapter in %s", __func__));
 
-    adapter = g_dbus_interface_get_object(G_DBUS_INTERFACE(mpAdapter));
+    adapter = g_dbus_interface_get_object(G_DBUS_INTERFACE(mEndpoint.GetAdapter()));
     VerifyOrExit(adapter != nullptr, ChipLogError(DeviceLayer, "FAIL: NULL adapter in %s", __func__));
 
     advMgr = bluez_object_get_leadvertising_manager1(BLUEZ_OBJECT(adapter));
@@ -291,7 +271,7 @@ void BluezAdvertisement::StopDone(GObject * aObject, GAsyncResult * aResult)
 
     if (success == FALSE)
     {
-        g_dbus_object_manager_server_unexport(mpRoot, mpAdvPath);
+        g_dbus_object_manager_server_unexport(mEndpoint.GetGattApplicationObjectManager(), mpAdvPath);
     }
     else
     {
@@ -312,9 +292,9 @@ CHIP_ERROR BluezAdvertisement::StopImpl()
     BluezLEAdvertisingManager1 * advMgr = nullptr;
 
     VerifyOrExit(mIsAdvertising, ChipLogError(DeviceLayer, "FAIL: Advertising has already been disabled in %s", __func__));
-    VerifyOrExit(mpAdapter != nullptr, ChipLogError(DeviceLayer, "FAIL: NULL mpAdapter in %s", __func__));
+    VerifyOrExit(mEndpoint.GetAdapter() != nullptr, ChipLogError(DeviceLayer, "FAIL: NULL mpAdapter in %s", __func__));
 
-    adapter = g_dbus_interface_get_object(G_DBUS_INTERFACE(mpAdapter));
+    adapter = g_dbus_interface_get_object(G_DBUS_INTERFACE(mEndpoint.GetAdapter()));
     VerifyOrExit(adapter != nullptr, ChipLogError(DeviceLayer, "FAIL: NULL adapter in %s", __func__));
 
     advMgr = bluez_object_get_leadvertising_manager1(BLUEZ_OBJECT(adapter));

src/platform/Linux/bluez/BluezAdvertisement.h

@@ -38,10 +38,10 @@ class BluezEndpoint;
 class BluezAdvertisement
 {
 public:
-    BluezAdvertisement() = default;
+    BluezAdvertisement(const BluezEndpoint & endpoint) : mEndpoint(endpoint){};
     ~BluezAdvertisement() { Shutdown(); }
 
-    CHIP_ERROR Init(const BluezEndpoint & aEndpoint, ChipAdvType aAdvType, const char * aAdvUUID, uint32_t aAdvDurationMs);
+    CHIP_ERROR Init(ChipAdvType aAdvType, const char * aAdvUUID, uint32_t aAdvDurationMs);
     void Shutdown();
 
     /// Start BLE advertising.
@@ -68,18 +68,15 @@ class BluezAdvertisement
     void StopDone(GObject * aObject, GAsyncResult * aResult);
     CHIP_ERROR StopImpl();
 
-    // Objects (interfaces) used by LE advertisement
-    GDBusObjectManagerServer * mpRoot = nullptr;
-    BluezAdapter1 * mpAdapter         = nullptr;
-    BluezLEAdvertisement1 * mpAdv     = nullptr;
+    const BluezEndpoint & mEndpoint;
+    GAutoPtr<BluezLEAdvertisement1> mpAdv;
 
     bool mIsInitialized = false;
     bool mIsAdvertising = false;
 
     Ble::ChipBLEDeviceIdentificationInfo mDeviceIdInfo;
-    char * mpAdvPath     = nullptr;
-    char * mpAdapterName = nullptr;
-    char * mpAdvUUID     = nullptr;
+    char * mpAdvPath = nullptr;
+    char * mpAdvUUID = nullptr;
     ChipAdvType mAdvType;
     uint16_t mAdvDurationMs = 0;
 };