src/platform/Linux/bluez/BluezAdvertisement.cpp - third_party/github/project-chip/connectedhomeip - Git at Google

 /*
  *
  *    Copyright (c) 2020-2023 Project CHIP Authors
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
  *    You may obtain a copy of the License at
  *
  *        http://www.apache.org/licenses/LICENSE-2.0
  *
  *    Unless required by applicable law or agreed to in writing, software
  *    distributed under the License is distributed on an "AS IS" BASIS,
  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */

 #include "BluezAdvertisement.h"

 #include <memory>
 #include <unistd.h>

 #include <gio/gio.h>
 #include <glib-object.h>
 #include <glib.h>

 #include <ble/Ble.h>
 #include <lib/support/CodeUtils.h>
 #include <lib/support/logging/CHIPLogging.h>
 #include <platform/ConfigurationManager.h>
 #include <platform/GLibTypeDeleter.h>
 #include <platform/Linux/dbus/bluez/DbusBluez.h>
 #include <platform/PlatformManager.h>

 #include "BluezEndpoint.h"
 #include "Types.h"

 namespace chip {
 namespace DeviceLayer {
 namespace Internal {

 BluezLEAdvertisement1 * BluezAdvertisement::CreateLEAdvertisement()
 {
     BluezLEAdvertisement1 * adv;
     BluezObjectSkeleton * object;
     GVariant * serviceUUID;
     GVariantBuilder serviceUUIDsBuilder;

     ChipLogDetail(DeviceLayer, "Create BLE adv object at %s", mAdvPath);
     object = bluez_object_skeleton_new(mAdvPath);

     adv = bluez_leadvertisement1_skeleton_new();

     g_variant_builder_init(&serviceUUIDsBuilder, G_VARIANT_TYPE("as"));
     g_variant_builder_add(&serviceUUIDsBuilder, "s", mAdvUUID);

     serviceUUID = g_variant_builder_end(&serviceUUIDsBuilder);

     bluez_leadvertisement1_set_type_(adv, "peripheral");
     bluez_leadvertisement1_set_service_uuids(adv, serviceUUID);
     // empty manufacturer data
     // empty solicit UUIDs
     // empty data

     // 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, TRUE);
     // empty discoverable timeout for infinite discoverability

     // empty includes
     bluez_leadvertisement1_set_local_name(adv, mAdvName);
     bluez_leadvertisement1_set_appearance(adv, 0xffff /* no appearance */);
     // empty duration
     // empty timeout
     // empty secondary channel for now

     bluez_object_skeleton_set_leadvertisement1(object, adv);
     g_signal_connect(adv, "handle-release",
                      G_CALLBACK(+[](BluezLEAdvertisement1 * aAdv, GDBusMethodInvocation * aInv, BluezAdvertisement * self) {
                          return self->BluezLEAdvertisement1Release(aAdv, aInv);
                      }),
                      this);

     g_dbus_object_manager_server_export(mEndpoint.GetGattApplicationObjectManager(), G_DBUS_OBJECT_SKELETON(object));
     g_object_unref(object);

     return adv;
 }

 gboolean BluezAdvertisement::BluezLEAdvertisement1Release(BluezLEAdvertisement1 * aAdv, GDBusMethodInvocation * aInvocation)
 {
     // This method is called when the advertisement is stopped (released) by BlueZ.
     // We can use it to update the state of the advertisement in the CHIP layer.
     ChipLogDetail(DeviceLayer, "BLE advertisement stopped by BlueZ");
     mIsAdvertising = false;
     bluez_leadvertisement1_complete_release(aAdv, aInvocation);
     BLEManagerImpl::NotifyBLEPeripheralAdvReleased();
     return TRUE;
 }

 CHIP_ERROR BluezAdvertisement::InitImpl()
 {
     // When creating D-Bus proxy object, the thread default context must be initialized. Otherwise,
     // all D-Bus signals will be delivered to the GLib global default main context.
     VerifyOrDie(g_main_context_get_thread_default() != nullptr);

     mAdv.reset(CreateLEAdvertisement());
     return CHIP_NO_ERROR;
 }

 CHIP_ERROR BluezAdvertisement::Init(BluezAdapter1 * apAdapter, const char * aAdvUUID, const char * aAdvName)
 {
     VerifyOrReturnError(!mAdv, CHIP_ERROR_INCORRECT_STATE,
                         ChipLogError(DeviceLayer, "FAIL: BLE advertisement already initialized in %s", __func__));

     mAdapter.reset(reinterpret_cast<BluezAdapter1 *>(g_object_ref(apAdapter)));

     GAutoPtr<char> rootPath;
     g_object_get(G_OBJECT(mEndpoint.GetGattApplicationObjectManager()), "object-path", &rootPath.GetReceiver(), nullptr);
     g_snprintf(mAdvPath, sizeof(mAdvPath), "%s/advertising", rootPath.get());
     g_strlcpy(mAdvUUID, aAdvUUID, sizeof(mAdvUUID));

     if (aAdvName != nullptr)
     {
         g_strlcpy(mAdvName, aAdvName, sizeof(mAdvName));
     }
     else
     {
         // Advertising name corresponding to the PID, for debug purposes.
         g_snprintf(mAdvName, sizeof(mAdvName), "%s%04x", CHIP_DEVICE_CONFIG_BLE_DEVICE_NAME_PREFIX, getpid() & 0xffff);
     }

     CHIP_ERROR err = PlatformMgrImpl().GLibMatterContextInvokeSync(
         +[](BluezAdvertisement * self) { return self->InitImpl(); }, this);
     VerifyOrReturnError(err == CHIP_NO_ERROR, err,
                         ChipLogError(Ble, "Failed to schedule BLE advertisement Init() on CHIPoBluez thread"));

     mIsInitialized = true;
     return CHIP_NO_ERROR;
 }

 CHIP_ERROR BluezAdvertisement::SetIntervals(AdvertisingIntervals aAdvIntervals)
 {
     VerifyOrReturnError(mAdv, 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(mAdv.get(), aAdvIntervals.first * 0.625);
     bluez_leadvertisement1_set_max_interval(mAdv.get(), aAdvIntervals.second * 0.625);
     return CHIP_NO_ERROR;
 }

 CHIP_ERROR BluezAdvertisement::SetupServiceData(ServiceDataFlags aFlags)
 {
     VerifyOrReturnError(mAdv, CHIP_ERROR_UNINITIALIZED);

     Ble::ChipBLEDeviceIdentificationInfo deviceInfo;
     ReturnErrorOnFailure(ConfigurationMgr().GetBLEDeviceIdentificationInfo(deviceInfo));

 #if CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING
     deviceInfo.SetAdditionalDataFlag(true);
 #endif

 #if CHIP_DEVICE_CONFIG_EXT_ADVERTISING
     if (aFlags & kServiceDataExtendedAnnouncement)
     {
         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}", mAdvUUID,
                           g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, &deviceInfo, sizeof(deviceInfo), sizeof(uint8_t)));

     GVariant * serviceData = g_variant_builder_end(&serviceDataBuilder);

     GAutoPtr<char> debugStr(g_variant_print(serviceData, TRUE));
     ChipLogDetail(DeviceLayer, "SET service data to %s", StringOrNullMarker(debugStr.get()));

     bluez_leadvertisement1_set_service_data(mAdv.get(), serviceData);

     return CHIP_NO_ERROR;
 }

 void BluezAdvertisement::Shutdown()
 {
     VerifyOrReturn(mIsInitialized);

     // Make sure that the advertisement is stopped before we start cleaning up.
     if (mIsAdvertising)
     {
         CHIP_ERROR err = Stop();
         if (err != CHIP_NO_ERROR)
         {
             ChipLogError(DeviceLayer, "Failed to stop BLE advertisement before shutdown: %" CHIP_ERROR_FORMAT, err.Format());
         }
     }

     // Release resources on the glib thread to synchronize with potential signal handlers
     // attached to the advertising object that may run on the glib thread.
     PlatformMgrImpl().GLibMatterContextInvokeSync(
         +[](BluezAdvertisement * self) {
             // The application object manager might not be released right away (it may be held
             // by other BLE layer objects). We need to unexport the advertisement object in the
             // explicit way to make sure that we can export it again in the Init() method.
             g_dbus_object_manager_server_unexport(self->mEndpoint.GetGattApplicationObjectManager(), self->mAdvPath);
             self->mAdapter.reset();
             self->mAdv.reset();
             return CHIP_NO_ERROR;
         },
         this);

     mIsInitialized = false;
 }

 void BluezAdvertisement::StartDone(GObject * aObject, GAsyncResult * aResult)
 {
     GAutoPtr<GError> error;
     if (!bluez_leadvertising_manager1_call_register_advertisement_finish(reinterpret_cast<BluezLEAdvertisingManager1 *>(aObject),
                                                                          aResult, &error.GetReceiver()))
     {
         ChipLogError(DeviceLayer, "FAIL: RegisterAdvertisement: %s", error->message);
         BLEManagerImpl::NotifyBLEPeripheralAdvStartComplete(BluezCallToChipError(error.get()));
         return;
     }

     mIsAdvertising = true;

     ChipLogDetail(DeviceLayer, "BLE advertisement started successfully");
     BLEManagerImpl::NotifyBLEPeripheralAdvStartComplete(CHIP_NO_ERROR);
 }

 CHIP_ERROR BluezAdvertisement::StartImpl()
 {
     VerifyOrReturnError(mAdapter, CHIP_ERROR_UNINITIALIZED);

     // If the adapter configured in the Init() was unplugged, the g_dbus_interface_get_object()
     // or bluez_object_get_leadvertising_manager1() might return nullptr (depending on the timing,
     // since the D-Bus communication is handled on a separate thread). In such case, we should not
     // report internal error, but adapter unavailable, so the application can handle the situation
     // properly.

     GDBusObject * adapterObject = g_dbus_interface_get_object(reinterpret_cast<GDBusInterface *>(mAdapter.get()));
     VerifyOrReturnError(adapterObject != nullptr, BLE_ERROR_ADAPTER_UNAVAILABLE);
     GAutoPtr<BluezLEAdvertisingManager1> advMgr(
         bluez_object_get_leadvertising_manager1(reinterpret_cast<BluezObject *>(adapterObject)));
     VerifyOrReturnError(advMgr, BLE_ERROR_ADAPTER_UNAVAILABLE);

     GVariantBuilder optionsBuilder;
     g_variant_builder_init(&optionsBuilder, G_VARIANT_TYPE("a{sv}"));
     GVariant * options = g_variant_builder_end(&optionsBuilder);

     bluez_leadvertising_manager1_call_register_advertisement(
         advMgr.get(), mAdvPath, options, nullptr,
         [](GObject * aObject, GAsyncResult * aResult, void * aData) {
             reinterpret_cast<BluezAdvertisement *>(aData)->StartDone(aObject, aResult);
         },
         this);

     return CHIP_NO_ERROR;
 }

 CHIP_ERROR BluezAdvertisement::Start()
 {
     VerifyOrReturnError(mIsInitialized, CHIP_ERROR_INCORRECT_STATE);
     VerifyOrReturnValue(!mIsAdvertising, CHIP_NO_ERROR, ChipLogDetail(DeviceLayer, "BLE advertising already started"));
     return PlatformMgrImpl().GLibMatterContextInvokeSync(
         +[](BluezAdvertisement * self) { return self->StartImpl(); }, this);
 }

 void BluezAdvertisement::StopDone(GObject * aObject, GAsyncResult * aResult)
 {
     GAutoPtr<GError> error;
     if (!bluez_leadvertising_manager1_call_unregister_advertisement_finish(reinterpret_cast<BluezLEAdvertisingManager1 *>(aObject),
                                                                            aResult, &error.GetReceiver()))
     {
         ChipLogError(DeviceLayer, "FAIL: UnregisterAdvertisement: %s", error->message);
         BLEManagerImpl::NotifyBLEPeripheralAdvStopComplete(BluezCallToChipError(error.get()));
         return;
     }

     mIsAdvertising = false;

     ChipLogDetail(DeviceLayer, "BLE advertisement stopped successfully");
     BLEManagerImpl::NotifyBLEPeripheralAdvStopComplete(CHIP_NO_ERROR);
 }

 CHIP_ERROR BluezAdvertisement::StopImpl()
 {
     VerifyOrReturnError(mAdapter, CHIP_ERROR_UNINITIALIZED);

     // If the adapter configured in the Init() was unplugged, the g_dbus_interface_get_object()
     // or bluez_object_get_leadvertising_manager1() might return nullptr (depending on the timing,
     // since the D-Bus communication is handled on a separate thread). In such case, we should not
     // report internal error, but adapter unavailable, so the application can handle the situation
     // properly.

     GDBusObject * adapterObject = g_dbus_interface_get_object(reinterpret_cast<GDBusInterface *>(mAdapter.get()));
     VerifyOrReturnError(adapterObject != nullptr, BLE_ERROR_ADAPTER_UNAVAILABLE);
     GAutoPtr<BluezLEAdvertisingManager1> advMgr(
         bluez_object_get_leadvertising_manager1(reinterpret_cast<BluezObject *>(adapterObject)));
     VerifyOrReturnError(advMgr, BLE_ERROR_ADAPTER_UNAVAILABLE);

     bluez_leadvertising_manager1_call_unregister_advertisement(
         advMgr.get(), mAdvPath, nullptr,
         [](GObject * aObject, GAsyncResult * aResult, void * aData) {
             reinterpret_cast<BluezAdvertisement *>(aData)->StopDone(aObject, aResult);
         },
         this);

     return CHIP_NO_ERROR;
 }

 CHIP_ERROR BluezAdvertisement::Stop()
 {
     VerifyOrReturnError(mIsInitialized, CHIP_ERROR_INCORRECT_STATE);
     VerifyOrReturnValue(mIsAdvertising, CHIP_NO_ERROR, ChipLogDetail(DeviceLayer, "BLE advertising already stopped"));
     return PlatformMgrImpl().GLibMatterContextInvokeSync(
         +[](BluezAdvertisement * self) { return self->StopImpl(); }, this);
 }

 } // namespace Internal
 } // namespace DeviceLayer
 } // namespace chip
	/*
	*
	* Copyright (c) 2020-2023 Project CHIP Authors
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "BluezAdvertisement.h"

	#include <memory>
	#include <unistd.h>

	#include <gio/gio.h>
	#include <glib-object.h>
	#include <glib.h>

	#include <ble/Ble.h>
	#include <lib/support/CodeUtils.h>
	#include <lib/support/logging/CHIPLogging.h>
	#include <platform/ConfigurationManager.h>
	#include <platform/GLibTypeDeleter.h>
	#include <platform/Linux/dbus/bluez/DbusBluez.h>
	#include <platform/PlatformManager.h>

	#include "BluezEndpoint.h"
	#include "Types.h"

	namespace chip {
	namespace DeviceLayer {
	namespace Internal {

	BluezLEAdvertisement1 * BluezAdvertisement::CreateLEAdvertisement()
	{
	BluezLEAdvertisement1 * adv;
	BluezObjectSkeleton * object;
	GVariant * serviceUUID;
	GVariantBuilder serviceUUIDsBuilder;

	ChipLogDetail(DeviceLayer, "Create BLE adv object at %s", mAdvPath);
	object = bluez_object_skeleton_new(mAdvPath);

	adv = bluez_leadvertisement1_skeleton_new();

	g_variant_builder_init(&serviceUUIDsBuilder, G_VARIANT_TYPE("as"));
	g_variant_builder_add(&serviceUUIDsBuilder, "s", mAdvUUID);

	serviceUUID = g_variant_builder_end(&serviceUUIDsBuilder);

	bluez_leadvertisement1_set_type_(adv, "peripheral");
	bluez_leadvertisement1_set_service_uuids(adv, serviceUUID);
	// empty manufacturer data
	// empty solicit UUIDs
	// empty data

	// 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, TRUE);
	// empty discoverable timeout for infinite discoverability

	// empty includes
	bluez_leadvertisement1_set_local_name(adv, mAdvName);
	bluez_leadvertisement1_set_appearance(adv, 0xffff /* no appearance */);
	// empty duration
	// empty timeout
	// empty secondary channel for now

	bluez_object_skeleton_set_leadvertisement1(object, adv);
	g_signal_connect(adv, "handle-release",
	G_CALLBACK(+[](BluezLEAdvertisement1 * aAdv, GDBusMethodInvocation * aInv, BluezAdvertisement * self) {
	return self->BluezLEAdvertisement1Release(aAdv, aInv);
	}),
	this);

	g_dbus_object_manager_server_export(mEndpoint.GetGattApplicationObjectManager(), G_DBUS_OBJECT_SKELETON(object));
	g_object_unref(object);

	return adv;
	}

	gboolean BluezAdvertisement::BluezLEAdvertisement1Release(BluezLEAdvertisement1 * aAdv, GDBusMethodInvocation * aInvocation)
	{
	// This method is called when the advertisement is stopped (released) by BlueZ.
	// We can use it to update the state of the advertisement in the CHIP layer.
	ChipLogDetail(DeviceLayer, "BLE advertisement stopped by BlueZ");
	mIsAdvertising = false;
	bluez_leadvertisement1_complete_release(aAdv, aInvocation);
	BLEManagerImpl::NotifyBLEPeripheralAdvReleased();
	return TRUE;
	}

	CHIP_ERROR BluezAdvertisement::InitImpl()
	{
	// When creating D-Bus proxy object, the thread default context must be initialized. Otherwise,
	// all D-Bus signals will be delivered to the GLib global default main context.
	VerifyOrDie(g_main_context_get_thread_default() != nullptr);

	mAdv.reset(CreateLEAdvertisement());
	return CHIP_NO_ERROR;
	}

	CHIP_ERROR BluezAdvertisement::Init(BluezAdapter1 * apAdapter, const char * aAdvUUID, const char * aAdvName)
	{
	VerifyOrReturnError(!mAdv, CHIP_ERROR_INCORRECT_STATE,
	ChipLogError(DeviceLayer, "FAIL: BLE advertisement already initialized in %s", __func__));

	mAdapter.reset(reinterpret_cast<BluezAdapter1 *>(g_object_ref(apAdapter)));

	GAutoPtr<char> rootPath;
	g_object_get(G_OBJECT(mEndpoint.GetGattApplicationObjectManager()), "object-path", &rootPath.GetReceiver(), nullptr);
	g_snprintf(mAdvPath, sizeof(mAdvPath), "%s/advertising", rootPath.get());
	g_strlcpy(mAdvUUID, aAdvUUID, sizeof(mAdvUUID));

	if (aAdvName != nullptr)
	{
	g_strlcpy(mAdvName, aAdvName, sizeof(mAdvName));
	}
	else
	{
	// Advertising name corresponding to the PID, for debug purposes.
	g_snprintf(mAdvName, sizeof(mAdvName), "%s%04x", CHIP_DEVICE_CONFIG_BLE_DEVICE_NAME_PREFIX, getpid() & 0xffff);
	}

	CHIP_ERROR err = PlatformMgrImpl().GLibMatterContextInvokeSync(
	+[](BluezAdvertisement * self) { return self->InitImpl(); }, this);
	VerifyOrReturnError(err == CHIP_NO_ERROR, err,
	ChipLogError(Ble, "Failed to schedule BLE advertisement Init() on CHIPoBluez thread"));

	mIsInitialized = true;
	return CHIP_NO_ERROR;
	}

	CHIP_ERROR BluezAdvertisement::SetIntervals(AdvertisingIntervals aAdvIntervals)
	{
	VerifyOrReturnError(mAdv, 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(mAdv.get(), aAdvIntervals.first * 0.625);
	bluez_leadvertisement1_set_max_interval(mAdv.get(), aAdvIntervals.second * 0.625);
	return CHIP_NO_ERROR;
	}

	CHIP_ERROR BluezAdvertisement::SetupServiceData(ServiceDataFlags aFlags)
	{
	VerifyOrReturnError(mAdv, CHIP_ERROR_UNINITIALIZED);

	Ble::ChipBLEDeviceIdentificationInfo deviceInfo;
	ReturnErrorOnFailure(ConfigurationMgr().GetBLEDeviceIdentificationInfo(deviceInfo));

	#if CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING
	deviceInfo.SetAdditionalDataFlag(true);
	#endif

	#if CHIP_DEVICE_CONFIG_EXT_ADVERTISING
	if (aFlags & kServiceDataExtendedAnnouncement)
	{
	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}", mAdvUUID,
	g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, &deviceInfo, sizeof(deviceInfo), sizeof(uint8_t)));

	GVariant * serviceData = g_variant_builder_end(&serviceDataBuilder);

	GAutoPtr<char> debugStr(g_variant_print(serviceData, TRUE));
	ChipLogDetail(DeviceLayer, "SET service data to %s", StringOrNullMarker(debugStr.get()));

	bluez_leadvertisement1_set_service_data(mAdv.get(), serviceData);

	return CHIP_NO_ERROR;
	}

	void BluezAdvertisement::Shutdown()
	{
	VerifyOrReturn(mIsInitialized);

	// Make sure that the advertisement is stopped before we start cleaning up.
	if (mIsAdvertising)
	{
	CHIP_ERROR err = Stop();
	if (err != CHIP_NO_ERROR)
	{
	ChipLogError(DeviceLayer, "Failed to stop BLE advertisement before shutdown: %" CHIP_ERROR_FORMAT, err.Format());
	}
	}

	// Release resources on the glib thread to synchronize with potential signal handlers
	// attached to the advertising object that may run on the glib thread.
	PlatformMgrImpl().GLibMatterContextInvokeSync(
	+[](BluezAdvertisement * self) {
	// The application object manager might not be released right away (it may be held
	// by other BLE layer objects). We need to unexport the advertisement object in the
	// explicit way to make sure that we can export it again in the Init() method.
	g_dbus_object_manager_server_unexport(self->mEndpoint.GetGattApplicationObjectManager(), self->mAdvPath);
	self->mAdapter.reset();
	self->mAdv.reset();
	return CHIP_NO_ERROR;
	},
	this);

	mIsInitialized = false;
	}

	void BluezAdvertisement::StartDone(GObject * aObject, GAsyncResult * aResult)
	{
	GAutoPtr<GError> error;
	if (!bluez_leadvertising_manager1_call_register_advertisement_finish(reinterpret_cast<BluezLEAdvertisingManager1 *>(aObject),
	aResult, &error.GetReceiver()))
	{
	ChipLogError(DeviceLayer, "FAIL: RegisterAdvertisement: %s", error->message);
	BLEManagerImpl::NotifyBLEPeripheralAdvStartComplete(BluezCallToChipError(error.get()));
	return;
	}

	mIsAdvertising = true;

	ChipLogDetail(DeviceLayer, "BLE advertisement started successfully");
	BLEManagerImpl::NotifyBLEPeripheralAdvStartComplete(CHIP_NO_ERROR);
	}

	CHIP_ERROR BluezAdvertisement::StartImpl()
	{
	VerifyOrReturnError(mAdapter, CHIP_ERROR_UNINITIALIZED);

	// If the adapter configured in the Init() was unplugged, the g_dbus_interface_get_object()
	// or bluez_object_get_leadvertising_manager1() might return nullptr (depending on the timing,
	// since the D-Bus communication is handled on a separate thread). In such case, we should not
	// report internal error, but adapter unavailable, so the application can handle the situation
	// properly.

	GDBusObject * adapterObject = g_dbus_interface_get_object(reinterpret_cast<GDBusInterface *>(mAdapter.get()));
	VerifyOrReturnError(adapterObject != nullptr, BLE_ERROR_ADAPTER_UNAVAILABLE);
	GAutoPtr<BluezLEAdvertisingManager1> advMgr(
	bluez_object_get_leadvertising_manager1(reinterpret_cast<BluezObject *>(adapterObject)));
	VerifyOrReturnError(advMgr, BLE_ERROR_ADAPTER_UNAVAILABLE);

	GVariantBuilder optionsBuilder;
	g_variant_builder_init(&optionsBuilder, G_VARIANT_TYPE("a{sv}"));
	GVariant * options = g_variant_builder_end(&optionsBuilder);

	bluez_leadvertising_manager1_call_register_advertisement(
	advMgr.get(), mAdvPath, options, nullptr,
	[](GObject * aObject, GAsyncResult * aResult, void * aData) {
	reinterpret_cast<BluezAdvertisement *>(aData)->StartDone(aObject, aResult);
	},
	this);

	return CHIP_NO_ERROR;
	}

	CHIP_ERROR BluezAdvertisement::Start()
	{
	VerifyOrReturnError(mIsInitialized, CHIP_ERROR_INCORRECT_STATE);
	VerifyOrReturnValue(!mIsAdvertising, CHIP_NO_ERROR, ChipLogDetail(DeviceLayer, "BLE advertising already started"));
	return PlatformMgrImpl().GLibMatterContextInvokeSync(
	+[](BluezAdvertisement * self) { return self->StartImpl(); }, this);
	}

	void BluezAdvertisement::StopDone(GObject * aObject, GAsyncResult * aResult)
	{
	GAutoPtr<GError> error;
	if (!bluez_leadvertising_manager1_call_unregister_advertisement_finish(reinterpret_cast<BluezLEAdvertisingManager1 *>(aObject),
	aResult, &error.GetReceiver()))
	{
	ChipLogError(DeviceLayer, "FAIL: UnregisterAdvertisement: %s", error->message);
	BLEManagerImpl::NotifyBLEPeripheralAdvStopComplete(BluezCallToChipError(error.get()));
	return;
	}

	mIsAdvertising = false;

	ChipLogDetail(DeviceLayer, "BLE advertisement stopped successfully");
	BLEManagerImpl::NotifyBLEPeripheralAdvStopComplete(CHIP_NO_ERROR);
	}

	CHIP_ERROR BluezAdvertisement::StopImpl()
	{
	VerifyOrReturnError(mAdapter, CHIP_ERROR_UNINITIALIZED);

	// If the adapter configured in the Init() was unplugged, the g_dbus_interface_get_object()
	// or bluez_object_get_leadvertising_manager1() might return nullptr (depending on the timing,
	// since the D-Bus communication is handled on a separate thread). In such case, we should not
	// report internal error, but adapter unavailable, so the application can handle the situation
	// properly.

	GDBusObject * adapterObject = g_dbus_interface_get_object(reinterpret_cast<GDBusInterface *>(mAdapter.get()));
	VerifyOrReturnError(adapterObject != nullptr, BLE_ERROR_ADAPTER_UNAVAILABLE);
	GAutoPtr<BluezLEAdvertisingManager1> advMgr(
	bluez_object_get_leadvertising_manager1(reinterpret_cast<BluezObject *>(adapterObject)));
	VerifyOrReturnError(advMgr, BLE_ERROR_ADAPTER_UNAVAILABLE);

	bluez_leadvertising_manager1_call_unregister_advertisement(
	advMgr.get(), mAdvPath, nullptr,
	[](GObject * aObject, GAsyncResult * aResult, void * aData) {
	reinterpret_cast<BluezAdvertisement *>(aData)->StopDone(aObject, aResult);
	},
	this);

	return CHIP_NO_ERROR;
	}

	CHIP_ERROR BluezAdvertisement::Stop()
	{
	VerifyOrReturnError(mIsInitialized, CHIP_ERROR_INCORRECT_STATE);
	VerifyOrReturnValue(mIsAdvertising, CHIP_NO_ERROR, ChipLogDetail(DeviceLayer, "BLE advertising already stopped"));
	return PlatformMgrImpl().GLibMatterContextInvokeSync(
	+[](BluezAdvertisement * self) { return self->StopImpl(); }, this);
	}

	} // namespace Internal
	} // namespace DeviceLayer
	} // namespace chip