src/connectivity/weave/adaptation/ble_manager_impl.cpp - fuchsia - Git at Google

 // Copyright 2020 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 // clang-format off
 #include <Weave/DeviceLayer/internal/WeaveDeviceLayerInternal.h>
 #include <Weave/DeviceLayer/internal/BLEManager.h>
 // clang-format on

 #include <lib/syslog/cpp/macros.h>

 #include "fuchsia/bluetooth/cpp/fidl.h"
 #include "lib/fpromise/result.h"
 #include "weave_inspector.h"

 #if WEAVE_DEVICE_CONFIG_ENABLE_WOBLE

 namespace gatt = fuchsia::bluetooth::gatt2;

 namespace nl::Weave::DeviceLayer::Internal {
 namespace {
 using nl::Weave::WeaveInspector;

 constexpr gatt::ServiceHandle kServiceHandle{1};
 /// UUID of weave service obtained from SIG, in canonical 8-4-4-4-12 string format.
 constexpr char kServiceUuid[] = "0000FEAF-0000-1000-8000-00805F9B34FB";

 // Offsets into |kWeaveBleChars| for specific characteristic.
 enum WeaveBleChar {
   // Weave service characteristic C1(write)
   kWeaveBleCharWrite = 0,
   // Weave service characteristic C2(indicate)
   kWeaveBleCharIndicate = 1,
 };

 // Type definitions for the Write & Indicate characteristics.
 constexpr gatt::Handle kWeaveBleCharWriteHandle{WeaveBleChar::kWeaveBleCharWrite};
 constexpr gatt::Handle kWeaveBleCharIndicateHandle{WeaveBleChar::kWeaveBleCharIndicate};

 // An array that holds the UUID for each |WeaveBleChar|
 constexpr WeaveBleUUID kWeaveBleChars[] = {
     // UUID for |kWeaveBleCharWrite|
     {{0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F, 0x9D,
       0x11}},
     // UUID for |kWeaveBleCharIndicate|
     {{0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F, 0x9D,
       0x12}}};

 }  // unnamed namespace

 BLEManagerImpl BLEManagerImpl::sInstance;

 BLEManagerImpl::BLEManagerImpl() : woble_connection_(this), gatt_service_(this) {
   // BleLayer does not initialize this callback, set it NULL to avoid accessing location pointed by
   // garbage value when not set explicitly.
   OnWeaveBleConnectReceived = nullptr;
 }

 WEAVE_ERROR BLEManagerImpl::_Init() {
   WEAVE_ERROR err;
   auto svc = PlatformMgrImpl().GetComponentContextForProcess()->svc();

   FX_CHECK(svc->Connect(gatt_server_.NewRequest()) == ZX_OK)
       << "Failed to connect to " << gatt::Server::Name_;
   FX_CHECK(svc->Connect(peripheral_.NewRequest()) == ZX_OK)
       << "Failed to connect to " << fuchsia::bluetooth::le::Peripheral::Name_;

   adv_handle_.set_error_handler(
       [](zx_status_t status) { FX_LOGS(INFO) << "LE advertising was stopped: " << status; });

   if (ConfigurationMgrImpl().IsWoBLEEnabled()) {
     service_mode_ = ConnectivityManager::kWoBLEServiceMode_Enabled;
   }

   memset(device_name_, 0, sizeof(device_name_));

   flags_ = 0;
   if (ConfigurationMgrImpl().IsWoBLEAdvertisementEnabled()) {
     flags_ = kFlag_AdvertisingEnabled;
   }

   // Initialize the Weave BleLayer.
   err = BleLayer::Init(this, this, &SystemLayer);
   if (err != BLE_NO_ERROR) {
     FX_LOGS(ERROR) << "BLE Layer init failed: " << ErrorStr(err);
     return err;
   }

   PlatformMgr().ScheduleWork(DriveBLEState, reinterpret_cast<intptr_t>(this));
   return WEAVE_NO_ERROR;
 }

 WEAVE_ERROR BLEManagerImpl::_SetWoBLEServiceMode(WoBLEServiceMode service_mode) {
   if (service_mode == ConnectivityManager::kWoBLEServiceMode_NotSupported) {
     return WEAVE_ERROR_INVALID_ARGUMENT;
   }
   if (service_mode_ == ConnectivityManager::kWoBLEServiceMode_NotSupported) {
     return WEAVE_ERROR_UNSUPPORTED_WEAVE_FEATURE;
   }
   if (service_mode != service_mode_) {
     service_mode_ = service_mode;
     PlatformMgr().ScheduleWork(DriveBLEState, reinterpret_cast<intptr_t>(this));
   }
   return WEAVE_NO_ERROR;
 }

 WEAVE_ERROR BLEManagerImpl::_SetAdvertisingEnabled(bool advertising_enable) {
   if (service_mode_ == ConnectivityManager::kWoBLEServiceMode_NotSupported) {
     return WEAVE_ERROR_UNSUPPORTED_WEAVE_FEATURE;
   }

   if (GetFlag(flags_, kFlag_AdvertisingEnabled) != advertising_enable) {
     SetFlag(flags_, kFlag_AdvertisingEnabled, advertising_enable);
     PlatformMgr().ScheduleWork(DriveBLEState, reinterpret_cast<intptr_t>(this));
   }
   return WEAVE_NO_ERROR;
 }

 WEAVE_ERROR BLEManagerImpl::_SetFastAdvertisingEnabled(bool fast_advertising_enable) {
   if (service_mode_ == ConnectivityManager::kWoBLEServiceMode_NotSupported) {
     return WEAVE_ERROR_UNSUPPORTED_WEAVE_FEATURE;
   }
   // TODO(https://fxbug.dev/42130069): Enable bluetooth fast advertising when needed
   return WEAVE_NO_ERROR;
 }

 WEAVE_ERROR BLEManagerImpl::_GetDeviceName(char* device_name, size_t device_name_size) {
   if (strlen(device_name_) >= device_name_size) {
     return WEAVE_ERROR_BUFFER_TOO_SMALL;
   }
   strncpy(device_name, device_name_, device_name_size);
   return WEAVE_NO_ERROR;
 }

 WEAVE_ERROR BLEManagerImpl::_SetDeviceName(const char* device_name) {
   if (service_mode_ == ConnectivityManager::kWoBLEServiceMode_NotSupported) {
     return WEAVE_ERROR_UNSUPPORTED_WEAVE_FEATURE;
   }
   if (device_name != nullptr && device_name[0] != 0) {
     if (strlen(device_name) >= kMaxDeviceNameLength) {
       return WEAVE_ERROR_INVALID_ARGUMENT;
     }
     strcpy(device_name_, device_name);
     SetFlag(flags_, kFlag_UseCustomDeviceName);
   } else {
     device_name_[0] = 0;
     ClearFlag(flags_, kFlag_UseCustomDeviceName);
   }
   return WEAVE_NO_ERROR;
 }

 void BLEManagerImpl::_OnPlatformEvent(const WeaveDeviceEvent* event) {
   BLEManagerImpl* instance;
   WoBLEConState* connection_state;
   if (event == nullptr) {
     // Ignore null weave device event.
     return;
   }
   auto& inspector = WeaveInspector::GetWeaveInspector();
   switch (event->Type) {
     case DeviceEventType::kWoBLESubscribe:
       connection_state = static_cast<WoBLEConState*>(event->WoBLESubscribe.ConId);
       ZX_ASSERT_MSG(connection_state != nullptr,
                     "Received WoBLE subscribe event without connection state");
       instance = connection_state->instance;
       ZX_ASSERT_MSG(instance != nullptr, "Received WoBLE subscribe event with NULL instance");
       instance->HandleSubscribeReceived(event->WoBLESubscribe.ConId, &WEAVE_BLE_SVC_ID,
                                         &kWeaveBleChars[WeaveBleChar::kWeaveBleCharIndicate]);

       // Post a WoBLEConnectionEstablished event to the DeviceLayer
       WeaveDeviceEvent connection_established_event;
       connection_established_event.Type = DeviceEventType::kWoBLEConnectionEstablished;
       PlatformMgr().PostEvent(&connection_established_event);
       inspector.NotifySetupStateChange(WeaveInspector::kSetupState_BLEConnected);
       break;

     case DeviceEventType::kWoBLEUnsubscribe:
       connection_state = static_cast<WoBLEConState*>(event->WoBLEUnsubscribe.ConId);
       ZX_ASSERT_MSG(connection_state != nullptr,
                     "Received WoBLE unsubscribe event without connection state");
       instance = connection_state->instance;
       ZX_ASSERT_MSG(instance != nullptr, "Received WoBLE unsubscribe event with NULL instance");
       instance->HandleUnsubscribeReceived(event->WoBLEUnsubscribe.ConId, &WEAVE_BLE_SVC_ID,
                                           &kWeaveBleChars[WeaveBleChar::kWeaveBleCharIndicate]);
       inspector.NotifySetupStateChange(WeaveInspector::kSetupState_Initialized);
       break;
     case DeviceEventType::kWoBLEWriteReceived:
       connection_state = static_cast<WoBLEConState*>(event->WoBLEWriteReceived.ConId);
       ZX_ASSERT_MSG(connection_state != nullptr,
                     "Received WoBLE write event without connection state");
       instance = connection_state->instance;
       ZX_ASSERT_MSG(instance != nullptr, "Received WoBLE write event with NULL instance");
       instance->HandleWriteReceived(event->WoBLEWriteReceived.ConId, &WEAVE_BLE_SVC_ID,
                                     &kWeaveBleChars[WeaveBleChar::kWeaveBleCharWrite],
                                     event->WoBLEWriteReceived.Data);
       break;
     case DeviceEventType::kWoBLEIndicateConfirm:
       connection_state = static_cast<WoBLEConState*>(event->WoBLEIndicateConfirm.ConId);
       ZX_ASSERT_MSG(connection_state != nullptr,
                     "Received WoBLE indication confirmation event without connection state");
       instance = connection_state->instance;
       ZX_ASSERT_MSG(instance != nullptr,
                     "Received WoBLE indication confirmation event with NULL instance");
       instance->HandleIndicationConfirmation(event->WoBLEIndicateConfirm.ConId, &WEAVE_BLE_SVC_ID,
                                              &kWeaveBleChars[WeaveBleChar::kWeaveBleCharIndicate]);
       break;
     case DeviceEventType::kWoBLEConnectionError:
       connection_state = static_cast<WoBLEConState*>(event->WoBLEConnectionError.ConId);
       ZX_ASSERT(connection_state != nullptr);
       instance = connection_state->instance;
       ZX_ASSERT(instance != nullptr);
       instance->HandleConnectionError(event->WoBLEConnectionError.ConId,
                                       event->WoBLEConnectionError.Reason);
       break;
     default:
       // Ignore events not intended for BLEManager.
       break;
   }
 }

 bool BLEManagerImpl::SendIndication(BLE_CONNECTION_OBJECT conId, const WeaveBleUUID* svcId,
                                     const WeaveBleUUID* charId, PacketBuffer* data) {
   FX_LOGS(INFO) << "SendIndication request (service id = " << svcId << ", char id = " << charId
                 << ")";
   auto connection_state = static_cast<WoBLEConState*>(conId);
   if (!connection_state) {
     PacketBuffer::Free(data);
     return false;
   }

   std::vector<uint8_t> value(data->DataLength());
   std::copy(data->Start(), data->Start() + data->DataLength(), value.begin());

   gatt::ValueChangedParameters notification_value;
   notification_value.set_handle(kWeaveBleCharIndicateHandle);
   std::vector<fuchsia::bluetooth::PeerId> peer_ids = {connection_state->peer_id};
   notification_value.set_peer_ids(std::move(peer_ids));
   notification_value.set_value(std::move(value));
   zx::eventpair confirm_ours;
   zx::eventpair confirm_theirs;
   zx::eventpair::create(/*options=*/0, &confirm_ours, &confirm_theirs);
   gatt_service_.events().OnIndicateValue(std::move(notification_value), std::move(confirm_theirs));

   // Save a reference to the buffer until we get a indication for the notification.
   connection_state->pending_ind_buf = data;
   data = nullptr;

   // TODO(https://fxbug.dev/42130443, https://fxbug.dev/42131435): The peer confirmation currently isn't returned to the
   // caller. Proceed as if the confirmation is received, to avoid closing the connection. When the
   // bug is fixed, block until the confirmation is received and handle it.
   PacketBuffer::Free(connection_state->pending_ind_buf);
   // If the confirmation was successful...
   // Post an event to the Weave queue to process the indicate confirmation.
   WeaveDeviceEvent event;
   event.Type = DeviceEventType::kWoBLEIndicateConfirm;
   event.WoBLESubscribe.ConId = conId;
   PlatformMgr().PostEvent(&event);

   return true;
 }

 void BLEManagerImpl::DriveBLEState() {
   if (service_mode_ != ConnectivityManager::kWoBLEServiceMode_Enabled) {
     if (GetFlag(flags_, kFlag_Advertising)) {
       adv_handle_.Unbind();
       ClearFlag(flags_, kFlag_Advertising);
     }
     if (GetFlag(flags_, kFlag_GATTServicePublished)) {
       gatt_service_.Close(ZX_ERR_PEER_CLOSED);
       ClearFlag(flags_, kFlag_GATTServicePublished);
     }
     return;
   }

   if (!GetFlag(flags_, kFlag_GATTServicePublished)) {
     gatt::ServiceInfo gatt_service_info;

     gatt::Characteristic weave_characteristic_c1;
     weave_characteristic_c1.set_handle(kWeaveBleCharWriteHandle);
     fuchsia::bluetooth::Uuid c1_uuid;
     std::copy(std::rbegin(kWeaveBleChars[WeaveBleChar::kWeaveBleCharWrite].bytes),
               std::rend(kWeaveBleChars[WeaveBleChar::kWeaveBleCharWrite].bytes),
               std::begin(c1_uuid.value));
     weave_characteristic_c1.set_type(c1_uuid);
     weave_characteristic_c1.set_properties(gatt::CharacteristicPropertyBits::WRITE);
     weave_characteristic_c1.mutable_permissions()->mutable_write();

     gatt::Characteristic weave_characteristic_c2;
     weave_characteristic_c2.set_handle(kWeaveBleCharIndicateHandle);
     fuchsia::bluetooth::Uuid c2_uuid;
     std::copy(std::rbegin(kWeaveBleChars[WeaveBleChar::kWeaveBleCharIndicate].bytes),
               std::rend(kWeaveBleChars[WeaveBleChar::kWeaveBleCharIndicate].bytes),
               std::begin(c2_uuid.value));
     weave_characteristic_c2.set_type(c2_uuid);
     weave_characteristic_c2.set_properties(gatt::CharacteristicPropertyBits::READ |
                                            gatt::CharacteristicPropertyBits::INDICATE);
     weave_characteristic_c2.mutable_permissions()->mutable_read();
     weave_characteristic_c2.mutable_permissions()->mutable_update();

     std::vector<gatt::Characteristic> characteristics;
     characteristics.push_back(std::move(weave_characteristic_c1));
     characteristics.push_back(std::move(weave_characteristic_c2));

     gatt_service_info.set_handle(kServiceHandle);
     gatt_service_info.set_kind(gatt::ServiceKind::PRIMARY);
     fuchsia::bluetooth::Uuid uuid;
     std::copy(std::rbegin(WEAVE_BLE_SVC_ID.bytes), std::rend(WEAVE_BLE_SVC_ID.bytes),
               std::begin(uuid.value));
     gatt_service_info.set_type(uuid);
     gatt_service_info.set_characteristics(std::move(characteristics));

     gatt::Server_PublishService_Result result;
     gatt_server_->PublishService(std::move(gatt_service_info), gatt_service_.NewBinding(), &result);

     if (result.is_err()) {
       FX_LOGS(ERROR) << "Failed to publish GATT service for Weave. Error: " << result.err()
                      << ". Disabling WoBLE service";
       service_mode_ = ConnectivityManager::kWoBLEServiceMode_Disabled;
       return;
     }

     FX_LOGS(INFO) << "Published GATT service for Weave with UUID: " << kServiceUuid;
     SetFlag(flags_, kFlag_GATTServicePublished);
   }

   if (GetFlag(flags_, kFlag_AdvertisingEnabled) && !GetFlag(flags_, kFlag_Advertising)) {
     fuchsia::bluetooth::le::AdvertisingData advertising_data;
     fuchsia::bluetooth::le::AdvertisingParameters advertising_parameters;
     fuchsia::bluetooth::le::Peripheral_StartAdvertising_Result advertising_result;
     fuchsia::bluetooth::Uuid uuid;
     std::copy(std::rbegin(WEAVE_BLE_SVC_ID.bytes), std::rend(WEAVE_BLE_SVC_ID.bytes),
               std::begin(uuid.value));

     // If a custom device name has not been specified, generate a name based on the
     // configured prefix and bottom digits of the Weave device id.
     if (!GetFlag(flags_, kFlag_UseCustomDeviceName)) {
       size_t out_len;
       char device_name_prefix[kMaxDeviceNameLength - 3] = "";
       WEAVE_ERROR err = ConfigurationMgrImpl().GetBleDeviceNamePrefix(
           device_name_prefix, kMaxDeviceNameLength - 4, &out_len);
       if (err != WEAVE_NO_ERROR) {
         FX_LOGS(ERROR) << "Failed to get BLE device name prefix: " << err;
       }
       snprintf(device_name_, sizeof(device_name_), "%s%04" PRIX32, device_name_prefix,
                static_cast<uint32_t>(FabricState.LocalNodeId));
       device_name_[kMaxDeviceNameLength] = 0;
     }
     advertising_data.set_name(device_name_);
     advertising_data.set_service_uuids({{uuid}});

     advertising_parameters.set_connectable(true);
     advertising_parameters.set_data(std::move(advertising_data));
     advertising_parameters.set_mode_hint(fuchsia::bluetooth::le::AdvertisingModeHint::SLOW);

     peripheral_->StartAdvertising(std::move(advertising_parameters), adv_handle_.NewRequest(),
                                   &advertising_result);

     if (advertising_result.is_err()) {
       FX_LOGS(ERROR) << "Failed to advertise WoBLE service, disabling WoBLE: "
                      << static_cast<uint32_t>(advertising_result.err());
       service_mode_ = ConnectivityManager::kWoBLEServiceMode_Disabled;
       return;
     }
     FX_LOGS(INFO) << "Advertising Weave service for device: " << device_name_;
     SetFlag(flags_, kFlag_Advertising);
   }

   if (!GetFlag(flags_, kFlag_AdvertisingEnabled) && GetFlag(flags_, kFlag_Advertising)) {
     adv_handle_.Unbind();
     ClearFlag(flags_, kFlag_Advertising);
   }
 }

 void BLEManagerImpl::DriveBLEState(intptr_t arg) {
   auto instance = reinterpret_cast<BLEManagerImpl*>(arg);
   if (!instance) {
     FX_LOGS(ERROR) << "DriveBLEState called with NULL";
     return;
   }
   instance->DriveBLEState();
 }

 void BLEManagerImpl::CharacteristicConfiguration(fuchsia::bluetooth::PeerId peer_id,
                                                  gatt::Handle handle, bool notify, bool indicate,
                                                  CharacteristicConfigurationCallback callback) {
   FX_LOGS(INFO) << "CharacteristicConfiguration on peer " << peer_id.value << " (notify: " << notify
                 << ", indicate: " << indicate << ") characteristic id " << handle.value;

   // Post an event to the Weave queue to process either a WoBLE Subscribe or Unsubscribe based on
   // whether the client is enabling or disabling indications.
   WeaveDeviceEvent event;
   event.Type = (indicate) ? DeviceEventType::kWoBLESubscribe : DeviceEventType::kWoBLEUnsubscribe;
   woble_connection_.peer_id = peer_id;
   event.WoBLESubscribe.ConId = static_cast<void*>(&woble_connection_);
   PlatformMgr().PostEvent(&event);
 }

 void BLEManagerImpl::ReadValue(fuchsia::bluetooth::PeerId peer_id, gatt::Handle handle,
                                int32_t offset, ReadValueCallback callback) {
   callback(fpromise::error(gatt::Error::READ_NOT_PERMITTED));
 }

 void BLEManagerImpl::WriteValue(gatt::LocalServiceWriteValueRequest request,
                                 WriteValueCallback callback) {
   PacketBuffer* buf = nullptr;

   if (!request.has_peer_id() || !request.has_handle() || !request.has_offset() ||
       !request.has_value()) {
     FX_LOGS(WARNING) << "Write request is missing mandatory arguments. Ignoring.";
     callback(fpromise::error(gatt::Error::INVALID_PARAMETERS));
     return;
   }

   FX_LOGS(INFO) << "Write request received for peer " << request.peer_id().value
                 << " at characteristic id " << request.handle().value << " at offset "
                 << request.offset() << " length " << request.value().size();
   if (request.handle().value != kWeaveBleCharWriteHandle.value) {
     FX_LOGS(WARNING) << "Ignoring writes to characteristic other than weave characteristic "
                         "C1(write). Expected characteristic: "
                      << kWeaveBleCharWrite;
     callback(fpromise::error(gatt::Error::WRITE_NOT_PERMITTED));
     return;
   }

   if (request.offset() != 0) {
     FX_LOGS(ERROR) << "No offset expected on write to control point";
     callback(fpromise::error(gatt::Error::INVALID_OFFSET));
     return;
   }

   // Copy the data to a PacketBuffer.
   buf = PacketBuffer::New(0);
   if (!buf || buf->AvailableDataLength() < request.value().size()) {
     FX_LOGS(ERROR) << "Buffer not available";
     callback(fpromise::error(gatt::Error::INVALID_ATTRIBUTE_VALUE_LENGTH));
     PacketBuffer::Free(buf);
     return;
   }

   std::copy(request.value().begin(), request.value().end(), buf->Start());
   buf->SetDataLength(request.value().size());

   // Post an event to the Weave queue to deliver the data into the Weave stack.
   WeaveDeviceEvent event;
   event.Type = DeviceEventType::kWoBLEWriteReceived;
   event.WoBLEWriteReceived.ConId = static_cast<void*>(&woble_connection_);
   event.WoBLEWriteReceived.Data = buf;
   PlatformMgr().PostEvent(&event);
   buf = nullptr;

   callback(fpromise::ok());
 }

 }  // namespace nl::Weave::DeviceLayer::Internal

 #endif  // WEAVE_DEVICE_CONFIG_ENABLE_WOBLE
	// Copyright 2020 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	// clang-format off
	#include <Weave/DeviceLayer/internal/WeaveDeviceLayerInternal.h>
	#include <Weave/DeviceLayer/internal/BLEManager.h>
	// clang-format on

	#include <lib/syslog/cpp/macros.h>

	#include "fuchsia/bluetooth/cpp/fidl.h"
	#include "lib/fpromise/result.h"
	#include "weave_inspector.h"

	#if WEAVE_DEVICE_CONFIG_ENABLE_WOBLE

	namespace gatt = fuchsia::bluetooth::gatt2;

	namespace nl::Weave::DeviceLayer::Internal {
	namespace {
	using nl::Weave::WeaveInspector;

	constexpr gatt::ServiceHandle kServiceHandle{1};
	/// UUID of weave service obtained from SIG, in canonical 8-4-4-4-12 string format.
	constexpr char kServiceUuid[] = "0000FEAF-0000-1000-8000-00805F9B34FB";

	// Offsets into \|kWeaveBleChars\| for specific characteristic.
	enum WeaveBleChar {
	// Weave service characteristic C1(write)
	kWeaveBleCharWrite = 0,
	// Weave service characteristic C2(indicate)
	kWeaveBleCharIndicate = 1,
	};

	// Type definitions for the Write & Indicate characteristics.
	constexpr gatt::Handle kWeaveBleCharWriteHandle{WeaveBleChar::kWeaveBleCharWrite};
	constexpr gatt::Handle kWeaveBleCharIndicateHandle{WeaveBleChar::kWeaveBleCharIndicate};

	// An array that holds the UUID for each \|WeaveBleChar\|
	constexpr WeaveBleUUID kWeaveBleChars[] = {
	// UUID for \|kWeaveBleCharWrite\|
	{{0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F, 0x9D,
	0x11}},
	// UUID for \|kWeaveBleCharIndicate\|
	{{0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F, 0x9D,
	0x12}}};

	} // unnamed namespace

	BLEManagerImpl BLEManagerImpl::sInstance;

	BLEManagerImpl::BLEManagerImpl() : woble_connection_(this), gatt_service_(this) {
	// BleLayer does not initialize this callback, set it NULL to avoid accessing location pointed by
	// garbage value when not set explicitly.
	OnWeaveBleConnectReceived = nullptr;
	}

	WEAVE_ERROR BLEManagerImpl::_Init() {
	WEAVE_ERROR err;
	auto svc = PlatformMgrImpl().GetComponentContextForProcess()->svc();

	FX_CHECK(svc->Connect(gatt_server_.NewRequest()) == ZX_OK)
	<< "Failed to connect to " << gatt::Server::Name_;
	FX_CHECK(svc->Connect(peripheral_.NewRequest()) == ZX_OK)
	<< "Failed to connect to " << fuchsia::bluetooth::le::Peripheral::Name_;

	adv_handle_.set_error_handler(
	[](zx_status_t status) { FX_LOGS(INFO) << "LE advertising was stopped: " << status; });

	if (ConfigurationMgrImpl().IsWoBLEEnabled()) {
	service_mode_ = ConnectivityManager::kWoBLEServiceMode_Enabled;
	}

	memset(device_name_, 0, sizeof(device_name_));

	flags_ = 0;
	if (ConfigurationMgrImpl().IsWoBLEAdvertisementEnabled()) {
	flags_ = kFlag_AdvertisingEnabled;
	}

	// Initialize the Weave BleLayer.
	err = BleLayer::Init(this, this, &SystemLayer);
	if (err != BLE_NO_ERROR) {
	FX_LOGS(ERROR) << "BLE Layer init failed: " << ErrorStr(err);
	return err;
	}

	PlatformMgr().ScheduleWork(DriveBLEState, reinterpret_cast<intptr_t>(this));
	return WEAVE_NO_ERROR;
	}

	WEAVE_ERROR BLEManagerImpl::_SetWoBLEServiceMode(WoBLEServiceMode service_mode) {
	if (service_mode == ConnectivityManager::kWoBLEServiceMode_NotSupported) {
	return WEAVE_ERROR_INVALID_ARGUMENT;
	}
	if (service_mode_ == ConnectivityManager::kWoBLEServiceMode_NotSupported) {
	return WEAVE_ERROR_UNSUPPORTED_WEAVE_FEATURE;
	}
	if (service_mode != service_mode_) {
	service_mode_ = service_mode;
	PlatformMgr().ScheduleWork(DriveBLEState, reinterpret_cast<intptr_t>(this));
	}
	return WEAVE_NO_ERROR;
	}

	WEAVE_ERROR BLEManagerImpl::_SetAdvertisingEnabled(bool advertising_enable) {
	if (service_mode_ == ConnectivityManager::kWoBLEServiceMode_NotSupported) {
	return WEAVE_ERROR_UNSUPPORTED_WEAVE_FEATURE;
	}

	if (GetFlag(flags_, kFlag_AdvertisingEnabled) != advertising_enable) {
	SetFlag(flags_, kFlag_AdvertisingEnabled, advertising_enable);
	PlatformMgr().ScheduleWork(DriveBLEState, reinterpret_cast<intptr_t>(this));
	}
	return WEAVE_NO_ERROR;
	}

	WEAVE_ERROR BLEManagerImpl::_SetFastAdvertisingEnabled(bool fast_advertising_enable) {
	if (service_mode_ == ConnectivityManager::kWoBLEServiceMode_NotSupported) {
	return WEAVE_ERROR_UNSUPPORTED_WEAVE_FEATURE;
	}
	// TODO(https://fxbug.dev/42130069): Enable bluetooth fast advertising when needed
	return WEAVE_NO_ERROR;
	}

	WEAVE_ERROR BLEManagerImpl::_GetDeviceName(char* device_name, size_t device_name_size) {
	if (strlen(device_name_) >= device_name_size) {
	return WEAVE_ERROR_BUFFER_TOO_SMALL;
	}
	strncpy(device_name, device_name_, device_name_size);
	return WEAVE_NO_ERROR;
	}

	WEAVE_ERROR BLEManagerImpl::_SetDeviceName(const char* device_name) {
	if (service_mode_ == ConnectivityManager::kWoBLEServiceMode_NotSupported) {
	return WEAVE_ERROR_UNSUPPORTED_WEAVE_FEATURE;
	}
	if (device_name != nullptr && device_name[0] != 0) {
	if (strlen(device_name) >= kMaxDeviceNameLength) {
	return WEAVE_ERROR_INVALID_ARGUMENT;
	}
	strcpy(device_name_, device_name);
	SetFlag(flags_, kFlag_UseCustomDeviceName);
	} else {
	device_name_[0] = 0;
	ClearFlag(flags_, kFlag_UseCustomDeviceName);
	}
	return WEAVE_NO_ERROR;
	}

	void BLEManagerImpl::_OnPlatformEvent(const WeaveDeviceEvent* event) {
	BLEManagerImpl* instance;
	WoBLEConState* connection_state;
	if (event == nullptr) {
	// Ignore null weave device event.
	return;
	}
	auto& inspector = WeaveInspector::GetWeaveInspector();
	switch (event->Type) {
	case DeviceEventType::kWoBLESubscribe:
	connection_state = static_cast<WoBLEConState*>(event->WoBLESubscribe.ConId);
	ZX_ASSERT_MSG(connection_state != nullptr,
	"Received WoBLE subscribe event without connection state");
	instance = connection_state->instance;
	ZX_ASSERT_MSG(instance != nullptr, "Received WoBLE subscribe event with NULL instance");
	instance->HandleSubscribeReceived(event->WoBLESubscribe.ConId, &WEAVE_BLE_SVC_ID,
	&kWeaveBleChars[WeaveBleChar::kWeaveBleCharIndicate]);

	// Post a WoBLEConnectionEstablished event to the DeviceLayer
	WeaveDeviceEvent connection_established_event;
	connection_established_event.Type = DeviceEventType::kWoBLEConnectionEstablished;
	PlatformMgr().PostEvent(&connection_established_event);
	inspector.NotifySetupStateChange(WeaveInspector::kSetupState_BLEConnected);
	break;

	case DeviceEventType::kWoBLEUnsubscribe:
	connection_state = static_cast<WoBLEConState*>(event->WoBLEUnsubscribe.ConId);
	ZX_ASSERT_MSG(connection_state != nullptr,
	"Received WoBLE unsubscribe event without connection state");
	instance = connection_state->instance;
	ZX_ASSERT_MSG(instance != nullptr, "Received WoBLE unsubscribe event with NULL instance");
	instance->HandleUnsubscribeReceived(event->WoBLEUnsubscribe.ConId, &WEAVE_BLE_SVC_ID,
	&kWeaveBleChars[WeaveBleChar::kWeaveBleCharIndicate]);
	inspector.NotifySetupStateChange(WeaveInspector::kSetupState_Initialized);
	break;
	case DeviceEventType::kWoBLEWriteReceived:
	connection_state = static_cast<WoBLEConState*>(event->WoBLEWriteReceived.ConId);
	ZX_ASSERT_MSG(connection_state != nullptr,
	"Received WoBLE write event without connection state");
	instance = connection_state->instance;
	ZX_ASSERT_MSG(instance != nullptr, "Received WoBLE write event with NULL instance");
	instance->HandleWriteReceived(event->WoBLEWriteReceived.ConId, &WEAVE_BLE_SVC_ID,
	&kWeaveBleChars[WeaveBleChar::kWeaveBleCharWrite],
	event->WoBLEWriteReceived.Data);
	break;
	case DeviceEventType::kWoBLEIndicateConfirm:
	connection_state = static_cast<WoBLEConState*>(event->WoBLEIndicateConfirm.ConId);
	ZX_ASSERT_MSG(connection_state != nullptr,
	"Received WoBLE indication confirmation event without connection state");
	instance = connection_state->instance;
	ZX_ASSERT_MSG(instance != nullptr,
	"Received WoBLE indication confirmation event with NULL instance");
	instance->HandleIndicationConfirmation(event->WoBLEIndicateConfirm.ConId, &WEAVE_BLE_SVC_ID,
	&kWeaveBleChars[WeaveBleChar::kWeaveBleCharIndicate]);
	break;
	case DeviceEventType::kWoBLEConnectionError:
	connection_state = static_cast<WoBLEConState*>(event->WoBLEConnectionError.ConId);
	ZX_ASSERT(connection_state != nullptr);
	instance = connection_state->instance;
	ZX_ASSERT(instance != nullptr);
	instance->HandleConnectionError(event->WoBLEConnectionError.ConId,
	event->WoBLEConnectionError.Reason);
	break;
	default:
	// Ignore events not intended for BLEManager.
	break;
	}
	}

	bool BLEManagerImpl::SendIndication(BLE_CONNECTION_OBJECT conId, const WeaveBleUUID* svcId,
	const WeaveBleUUID* charId, PacketBuffer* data) {
	FX_LOGS(INFO) << "SendIndication request (service id = " << svcId << ", char id = " << charId
	<< ")";
	auto connection_state = static_cast<WoBLEConState*>(conId);
	if (!connection_state) {
	PacketBuffer::Free(data);
	return false;
	}

	std::vector<uint8_t> value(data->DataLength());
	std::copy(data->Start(), data->Start() + data->DataLength(), value.begin());

	gatt::ValueChangedParameters notification_value;
	notification_value.set_handle(kWeaveBleCharIndicateHandle);
	std::vector<fuchsia::bluetooth::PeerId> peer_ids = {connection_state->peer_id};
	notification_value.set_peer_ids(std::move(peer_ids));
	notification_value.set_value(std::move(value));
	zx::eventpair confirm_ours;
	zx::eventpair confirm_theirs;
	zx::eventpair::create(/options=/0, &confirm_ours, &confirm_theirs);
	gatt_service_.events().OnIndicateValue(std::move(notification_value), std::move(confirm_theirs));

	// Save a reference to the buffer until we get a indication for the notification.
	connection_state->pending_ind_buf = data;
	data = nullptr;

	// TODO(https://fxbug.dev/42130443, https://fxbug.dev/42131435): The peer confirmation currently isn't returned to the
	// caller. Proceed as if the confirmation is received, to avoid closing the connection. When the
	// bug is fixed, block until the confirmation is received and handle it.
	PacketBuffer::Free(connection_state->pending_ind_buf);
	// If the confirmation was successful...
	// Post an event to the Weave queue to process the indicate confirmation.
	WeaveDeviceEvent event;
	event.Type = DeviceEventType::kWoBLEIndicateConfirm;
	event.WoBLESubscribe.ConId = conId;
	PlatformMgr().PostEvent(&event);

	return true;
	}

	void BLEManagerImpl::DriveBLEState() {
	if (service_mode_ != ConnectivityManager::kWoBLEServiceMode_Enabled) {
	if (GetFlag(flags_, kFlag_Advertising)) {
	adv_handle_.Unbind();
	ClearFlag(flags_, kFlag_Advertising);
	}
	if (GetFlag(flags_, kFlag_GATTServicePublished)) {
	gatt_service_.Close(ZX_ERR_PEER_CLOSED);
	ClearFlag(flags_, kFlag_GATTServicePublished);
	}
	return;
	}

	if (!GetFlag(flags_, kFlag_GATTServicePublished)) {
	gatt::ServiceInfo gatt_service_info;

	gatt::Characteristic weave_characteristic_c1;
	weave_characteristic_c1.set_handle(kWeaveBleCharWriteHandle);
	fuchsia::bluetooth::Uuid c1_uuid;
	std::copy(std::rbegin(kWeaveBleChars[WeaveBleChar::kWeaveBleCharWrite].bytes),
	std::rend(kWeaveBleChars[WeaveBleChar::kWeaveBleCharWrite].bytes),
	std::begin(c1_uuid.value));
	weave_characteristic_c1.set_type(c1_uuid);
	weave_characteristic_c1.set_properties(gatt::CharacteristicPropertyBits::WRITE);
	weave_characteristic_c1.mutable_permissions()->mutable_write();

	gatt::Characteristic weave_characteristic_c2;
	weave_characteristic_c2.set_handle(kWeaveBleCharIndicateHandle);
	fuchsia::bluetooth::Uuid c2_uuid;
	std::copy(std::rbegin(kWeaveBleChars[WeaveBleChar::kWeaveBleCharIndicate].bytes),
	std::rend(kWeaveBleChars[WeaveBleChar::kWeaveBleCharIndicate].bytes),
	std::begin(c2_uuid.value));
	weave_characteristic_c2.set_type(c2_uuid);
	weave_characteristic_c2.set_properties(gatt::CharacteristicPropertyBits::READ \|
	gatt::CharacteristicPropertyBits::INDICATE);
	weave_characteristic_c2.mutable_permissions()->mutable_read();
	weave_characteristic_c2.mutable_permissions()->mutable_update();

	std::vector<gatt::Characteristic> characteristics;
	characteristics.push_back(std::move(weave_characteristic_c1));
	characteristics.push_back(std::move(weave_characteristic_c2));

	gatt_service_info.set_handle(kServiceHandle);
	gatt_service_info.set_kind(gatt::ServiceKind::PRIMARY);
	fuchsia::bluetooth::Uuid uuid;
	std::copy(std::rbegin(WEAVE_BLE_SVC_ID.bytes), std::rend(WEAVE_BLE_SVC_ID.bytes),
	std::begin(uuid.value));
	gatt_service_info.set_type(uuid);
	gatt_service_info.set_characteristics(std::move(characteristics));

	gatt::Server_PublishService_Result result;
	gatt_server_->PublishService(std::move(gatt_service_info), gatt_service_.NewBinding(), &result);

	if (result.is_err()) {
	FX_LOGS(ERROR) << "Failed to publish GATT service for Weave. Error: " << result.err()
	<< ". Disabling WoBLE service";
	service_mode_ = ConnectivityManager::kWoBLEServiceMode_Disabled;
	return;
	}

	FX_LOGS(INFO) << "Published GATT service for Weave with UUID: " << kServiceUuid;
	SetFlag(flags_, kFlag_GATTServicePublished);
	}

	if (GetFlag(flags_, kFlag_AdvertisingEnabled) && !GetFlag(flags_, kFlag_Advertising)) {
	fuchsia::bluetooth::le::AdvertisingData advertising_data;
	fuchsia::bluetooth::le::AdvertisingParameters advertising_parameters;
	fuchsia::bluetooth::le::Peripheral_StartAdvertising_Result advertising_result;
	fuchsia::bluetooth::Uuid uuid;
	std::copy(std::rbegin(WEAVE_BLE_SVC_ID.bytes), std::rend(WEAVE_BLE_SVC_ID.bytes),
	std::begin(uuid.value));

	// If a custom device name has not been specified, generate a name based on the
	// configured prefix and bottom digits of the Weave device id.
	if (!GetFlag(flags_, kFlag_UseCustomDeviceName)) {
	size_t out_len;
	char device_name_prefix[kMaxDeviceNameLength - 3] = "";
	WEAVE_ERROR err = ConfigurationMgrImpl().GetBleDeviceNamePrefix(
	device_name_prefix, kMaxDeviceNameLength - 4, &out_len);
	if (err != WEAVE_NO_ERROR) {
	FX_LOGS(ERROR) << "Failed to get BLE device name prefix: " << err;
	}
	snprintf(device_name_, sizeof(device_name_), "%s%04" PRIX32, device_name_prefix,
	static_cast<uint32_t>(FabricState.LocalNodeId));
	device_name_[kMaxDeviceNameLength] = 0;
	}
	advertising_data.set_name(device_name_);
	advertising_data.set_service_uuids({{uuid}});

	advertising_parameters.set_connectable(true);
	advertising_parameters.set_data(std::move(advertising_data));
	advertising_parameters.set_mode_hint(fuchsia::bluetooth::le::AdvertisingModeHint::SLOW);

	peripheral_->StartAdvertising(std::move(advertising_parameters), adv_handle_.NewRequest(),
	&advertising_result);

	if (advertising_result.is_err()) {
	FX_LOGS(ERROR) << "Failed to advertise WoBLE service, disabling WoBLE: "
	<< static_cast<uint32_t>(advertising_result.err());
	service_mode_ = ConnectivityManager::kWoBLEServiceMode_Disabled;
	return;
	}
	FX_LOGS(INFO) << "Advertising Weave service for device: " << device_name_;
	SetFlag(flags_, kFlag_Advertising);
	}

	if (!GetFlag(flags_, kFlag_AdvertisingEnabled) && GetFlag(flags_, kFlag_Advertising)) {
	adv_handle_.Unbind();
	ClearFlag(flags_, kFlag_Advertising);
	}
	}

	void BLEManagerImpl::DriveBLEState(intptr_t arg) {
	auto instance = reinterpret_cast<BLEManagerImpl*>(arg);
	if (!instance) {
	FX_LOGS(ERROR) << "DriveBLEState called with NULL";
	return;
	}
	instance->DriveBLEState();
	}

	void BLEManagerImpl::CharacteristicConfiguration(fuchsia::bluetooth::PeerId peer_id,
	gatt::Handle handle, bool notify, bool indicate,
	CharacteristicConfigurationCallback callback) {
	FX_LOGS(INFO) << "CharacteristicConfiguration on peer " << peer_id.value << " (notify: " << notify
	<< ", indicate: " << indicate << ") characteristic id " << handle.value;

	// Post an event to the Weave queue to process either a WoBLE Subscribe or Unsubscribe based on
	// whether the client is enabling or disabling indications.
	WeaveDeviceEvent event;
	event.Type = (indicate) ? DeviceEventType::kWoBLESubscribe : DeviceEventType::kWoBLEUnsubscribe;
	woble_connection_.peer_id = peer_id;
	event.WoBLESubscribe.ConId = static_cast<void*>(&woble_connection_);
	PlatformMgr().PostEvent(&event);
	}

	void BLEManagerImpl::ReadValue(fuchsia::bluetooth::PeerId peer_id, gatt::Handle handle,
	int32_t offset, ReadValueCallback callback) {
	callback(fpromise::error(gatt::Error::READ_NOT_PERMITTED));
	}

	void BLEManagerImpl::WriteValue(gatt::LocalServiceWriteValueRequest request,
	WriteValueCallback callback) {
	PacketBuffer* buf = nullptr;

	if (!request.has_peer_id() \|\| !request.has_handle() \|\| !request.has_offset() \|\|
	!request.has_value()) {
	FX_LOGS(WARNING) << "Write request is missing mandatory arguments. Ignoring.";
	callback(fpromise::error(gatt::Error::INVALID_PARAMETERS));
	return;
	}

	FX_LOGS(INFO) << "Write request received for peer " << request.peer_id().value
	<< " at characteristic id " << request.handle().value << " at offset "
	<< request.offset() << " length " << request.value().size();
	if (request.handle().value != kWeaveBleCharWriteHandle.value) {
	FX_LOGS(WARNING) << "Ignoring writes to characteristic other than weave characteristic "
	"C1(write). Expected characteristic: "
	<< kWeaveBleCharWrite;
	callback(fpromise::error(gatt::Error::WRITE_NOT_PERMITTED));
	return;
	}

	if (request.offset() != 0) {
	FX_LOGS(ERROR) << "No offset expected on write to control point";
	callback(fpromise::error(gatt::Error::INVALID_OFFSET));
	return;
	}

	// Copy the data to a PacketBuffer.
	buf = PacketBuffer::New(0);
	if (!buf \|\| buf->AvailableDataLength() < request.value().size()) {
	FX_LOGS(ERROR) << "Buffer not available";
	callback(fpromise::error(gatt::Error::INVALID_ATTRIBUTE_VALUE_LENGTH));
	PacketBuffer::Free(buf);
	return;
	}

	std::copy(request.value().begin(), request.value().end(), buf->Start());
	buf->SetDataLength(request.value().size());

	// Post an event to the Weave queue to deliver the data into the Weave stack.
	WeaveDeviceEvent event;
	event.Type = DeviceEventType::kWoBLEWriteReceived;
	event.WoBLEWriteReceived.ConId = static_cast<void*>(&woble_connection_);
	event.WoBLEWriteReceived.Data = buf;
	PlatformMgr().PostEvent(&event);
	buf = nullptr;

	callback(fpromise::ok());
	}

	} // namespace nl::Weave::DeviceLayer::Internal

	#endif // WEAVE_DEVICE_CONFIG_ENABLE_WOBLE