| // 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> |
| |
| #if WEAVE_DEVICE_CONFIG_ENABLE_WOBLE |
| |
| #define MAX_CHARACTERISTIC_UUID_SIZE 40 |
| |
| using namespace ::nl; |
| using namespace ::nl::Ble; |
| |
| namespace nl { |
| namespace Weave { |
| namespace DeviceLayer { |
| namespace Internal { |
| |
| namespace { |
| |
| /// UUID of weave service obtained from SIG, in canonical 8-4-4-4-12 string format. |
| constexpr char kServiceUuid[] = "0000FEAF-0000-1000-8000-00805F9B34FB"; |
| |
| // Define structure that holds both the canonical and WeaveBLEUUID format. |
| struct BLECharUUID { |
| const char canonical_uuid[MAX_CHARACTERISTIC_UUID_SIZE]; |
| const WeaveBleUUID weave_uuid; |
| }; |
| |
| // Offsets into |kWeaveBleChars| for specific characteristic. |
| enum WeaveBleChar { |
| // Weave service characteristic C1(write) |
| kWeaveBleCharWrite = 0, |
| // Weave service characteristic C2(indicate) |
| kWeaveBleCharIndicate = 1, |
| }; |
| |
| // An array that holds the UUID for each |WeaveBleChar| |
| constexpr BLECharUUID kWeaveBleChars[] = { |
| // UUID for |kWeaveBleCharWrite| |
| {"18EE2EF5-263D-4559-959F-4F9C429F9D11", |
| {{0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F, 0x9D, |
| 0x11}}}, |
| // UUID for |kWeaveBleCharIndicate| |
| {"18EE2EF5-263D-4559-959F-4F9C429F9D12", |
| {{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_binding_(this) { |
| // BleLayer does not initialize this callback, set it NULL to avoid accessing location pointed by |
| // garbage value when not set explicitly. |
| OnWeaveBleConnectReceived = NULL; |
| } |
| |
| 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 " << fuchsia::bluetooth::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(fxbug.dev/52734): 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 != NULL && 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 == NULL) { |
| // Ignore null weave device event. |
| return; |
| } |
| switch (event->Type) { |
| case DeviceEventType::kWoBLESubscribe: |
| connection_state = static_cast<WoBLEConState*>(event->WoBLESubscribe.ConId); |
| ZX_ASSERT_MSG(connection_state != NULL, |
| "Received WoBLE subscribe event without connection state"); |
| instance = connection_state->instance; |
| ZX_ASSERT_MSG(instance != NULL, "Received WoBLE subscribe event with NULL instance"); |
| instance->HandleSubscribeReceived( |
| event->WoBLESubscribe.ConId, &WEAVE_BLE_SVC_ID, |
| &kWeaveBleChars[WeaveBleChar::kWeaveBleCharIndicate].weave_uuid); |
| |
| // Post a WoBLEConnectionEstablished event to the DeviceLayer |
| WeaveDeviceEvent connection_established_event; |
| connection_established_event.Type = DeviceEventType::kWoBLEConnectionEstablished; |
| PlatformMgr().PostEvent(&connection_established_event); |
| |
| break; |
| |
| case DeviceEventType::kWoBLEUnsubscribe: |
| connection_state = static_cast<WoBLEConState*>(event->WoBLEUnsubscribe.ConId); |
| ZX_ASSERT_MSG(connection_state != NULL, |
| "Received WoBLE unsubscribe event without connection state"); |
| instance = connection_state->instance; |
| ZX_ASSERT_MSG(instance != NULL, "Received WoBLE unsubscribe event with NULL instance"); |
| instance->HandleUnsubscribeReceived( |
| event->WoBLEUnsubscribe.ConId, &WEAVE_BLE_SVC_ID, |
| &kWeaveBleChars[WeaveBleChar::kWeaveBleCharIndicate].weave_uuid); |
| break; |
| case DeviceEventType::kWoBLEWriteReceived: |
| connection_state = static_cast<WoBLEConState*>(event->WoBLEWriteReceived.ConId); |
| ZX_ASSERT_MSG(connection_state != NULL, |
| "Received WoBLE write event without connection state"); |
| instance = connection_state->instance; |
| ZX_ASSERT_MSG(instance != NULL, "Received WoBLE write event with NULL instance"); |
| instance->HandleWriteReceived(event->WoBLEWriteReceived.ConId, &WEAVE_BLE_SVC_ID, |
| &kWeaveBleChars[WeaveBleChar::kWeaveBleCharWrite].weave_uuid, |
| event->WoBLEWriteReceived.Data); |
| break; |
| case DeviceEventType::kWoBLEIndicateConfirm: |
| connection_state = static_cast<WoBLEConState*>(event->WoBLEIndicateConfirm.ConId); |
| ZX_ASSERT_MSG(connection_state != NULL, |
| "Received WoBLE indication confirmation event without connection state"); |
| instance = connection_state->instance; |
| ZX_ASSERT_MSG(instance != NULL, |
| "Received WoBLE indication confirmation event with NULL instance"); |
| instance->HandleIndicationConfirmation( |
| event->WoBLEIndicateConfirm.ConId, &WEAVE_BLE_SVC_ID, |
| &kWeaveBleChars[WeaveBleChar::kWeaveBleCharIndicate].weave_uuid); |
| break; |
| case DeviceEventType::kWoBLEConnectionError: |
| connection_state = static_cast<WoBLEConState*>(event->WoBLEConnectionError.ConId); |
| ZX_ASSERT(connection_state != NULL); |
| instance = connection_state->instance; |
| ZX_ASSERT(instance != NULL); |
| instance->HandleConnectionError(event->WoBLEConnectionError.ConId, |
| event->WoBLEConnectionError.Reason); |
| break; |
| default: |
| // Ignore events not intended for BLEManager. |
| break; |
| } |
| } |
| |
| uint16_t BLEManagerImpl::_NumConnections(void) { return 0; } |
| |
| bool BLEManagerImpl::SubscribeCharacteristic(BLE_CONNECTION_OBJECT conId, const WeaveBleUUID* svcId, |
| const WeaveBleUUID* charId) { |
| return false; |
| } |
| |
| bool BLEManagerImpl::UnsubscribeCharacteristic(BLE_CONNECTION_OBJECT conId, |
| const WeaveBleUUID* svcId, |
| const WeaveBleUUID* charId) { |
| return false; |
| } |
| |
| bool BLEManagerImpl::CloseConnection(BLE_CONNECTION_OBJECT conId) { return false; } |
| |
| uint16_t BLEManagerImpl::GetMTU(BLE_CONNECTION_OBJECT conId) const { return 0; } |
| |
| bool BLEManagerImpl::SendIndication(BLE_CONNECTION_OBJECT conId, const WeaveBleUUID* svcId, |
| const WeaveBleUUID* charId, PacketBuffer* data) { |
| 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()); |
| |
| WEAVE_ERROR err = |
| service_->NotifyValue(kWeaveBleCharIndicate, connection_state->peer_id, value, true); |
| if (err != WEAVE_NO_ERROR) { |
| FX_LOGS(ERROR) << "SendIndication failed: " << err; |
| PacketBuffer::Free(data); |
| return false; |
| } |
| |
| // Save a reference to the buffer until we get a indication for the notification. |
| connection_state->pending_ind_buf = data; |
| data = NULL; |
| |
| // TODO(fxbug.dev/53070, fxbug.dev/53966): 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; |
| } |
| |
| bool BLEManagerImpl::SendWriteRequest(BLE_CONNECTION_OBJECT conId, const WeaveBleUUID* svcId, |
| const WeaveBleUUID* charId, PacketBuffer* pBuf) { |
| return false; |
| } |
| |
| bool BLEManagerImpl::SendReadRequest(BLE_CONNECTION_OBJECT conId, const WeaveBleUUID* svcId, |
| const WeaveBleUUID* charId, PacketBuffer* pBuf) { |
| return false; |
| } |
| |
| bool BLEManagerImpl::SendReadResponse(BLE_CONNECTION_OBJECT conId, |
| BLE_READ_REQUEST_CONTEXT requestContext, |
| const WeaveBleUUID* svcId, const WeaveBleUUID* charId) { |
| return false; |
| } |
| |
| void BLEManagerImpl::NotifyWeaveConnectionClosed(BLE_CONNECTION_OBJECT conId) {} |
| |
| 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)) { |
| service_->RemoveService(); |
| ClearFlag(flags_, kFlag_GATTServicePublished); |
| } |
| return; |
| } |
| |
| if (!GetFlag(flags_, kFlag_GATTServicePublished)) { |
| fuchsia::bluetooth::Status out_status; |
| fuchsia::bluetooth::gatt::ServiceInfo gatt_service_info; |
| |
| fuchsia::bluetooth::gatt::Characteristic weave_characteristic_c1; |
| weave_characteristic_c1.id = WeaveBleChar::kWeaveBleCharWrite; |
| weave_characteristic_c1.type = kWeaveBleChars[WeaveBleChar::kWeaveBleCharWrite].canonical_uuid; |
| weave_characteristic_c1.properties = fuchsia::bluetooth::gatt::kPropertyWrite; |
| weave_characteristic_c1.permissions = fuchsia::bluetooth::gatt::AttributePermissions::New(); |
| weave_characteristic_c1.permissions->write = |
| fuchsia::bluetooth::gatt::SecurityRequirements::New(); |
| |
| fuchsia::bluetooth::gatt::Characteristic weave_characteristic_c2; |
| weave_characteristic_c2.id = WeaveBleChar::kWeaveBleCharIndicate; |
| weave_characteristic_c2.type = |
| kWeaveBleChars[WeaveBleChar::kWeaveBleCharIndicate].canonical_uuid; |
| weave_characteristic_c2.properties = |
| fuchsia::bluetooth::gatt::kPropertyRead | fuchsia::bluetooth::gatt::kPropertyIndicate; |
| weave_characteristic_c2.permissions = fuchsia::bluetooth::gatt::AttributePermissions::New(); |
| weave_characteristic_c2.permissions->read = |
| fuchsia::bluetooth::gatt::SecurityRequirements::New(); |
| weave_characteristic_c2.permissions->update = |
| fuchsia::bluetooth::gatt::SecurityRequirements::New(); |
| |
| std::vector<fuchsia::bluetooth::gatt::Characteristic> characteristics; |
| characteristics.push_back(std::move(weave_characteristic_c1)); |
| characteristics.push_back(std::move(weave_characteristic_c2)); |
| |
| gatt_service_info.primary = true; |
| gatt_service_info.type = kServiceUuid; |
| gatt_service_info.characteristics = std::move(characteristics); |
| gatt_server_->PublishService(std::move(gatt_service_info), gatt_binding_.NewBinding(), |
| service_.NewRequest(), &out_status); |
| if (out_status.error) { |
| FX_LOGS(ERROR) << "Failed to publish GATT service for Weave. Error: " |
| << (bool)out_status.error->error_code << " (" << out_status.error->description |
| << "). 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, |
| (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, Error: " |
| << (uint32_t)advertising_result.err() << ". Disabling WoBLE service"; |
| 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::OnCharacteristicConfiguration(uint64_t characteristic_id, std::string peer_id, |
| bool notify, bool indicate) { |
| FX_LOGS(INFO) << "CharacteristicConfiguration on peer " << peer_id << " (notify: " << notify |
| << ", indicate: " << indicate << ") characteristic id " << characteristic_id; |
| |
| // 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::OnReadValue(uint64_t id, int32_t offset, OnReadValueCallback callback) { |
| callback({}, fuchsia::bluetooth::gatt::ErrorCode::NOT_PERMITTED); |
| } |
| |
| void BLEManagerImpl::OnWriteValue(uint64_t id, uint16_t offset, std::vector<uint8_t> value, |
| OnWriteValueCallback callback) { |
| PacketBuffer* buf = NULL; |
| FX_LOGS(INFO) << "Write request received for characteristic id " << id << " at offset " << offset |
| << " length " << value.size(); |
| if (id != kWeaveBleCharWrite) { |
| FX_LOGS(WARNING) << "Ignoring writes to characteristic other than weave characteristic " |
| "C1(write). Expected characteristic: " |
| << kWeaveBleCharWrite; |
| callback(fuchsia::bluetooth::gatt::ErrorCode::NOT_PERMITTED); |
| return; |
| } |
| if (offset != 0) { |
| FX_LOGS(ERROR) << "No offset expected on write to control point"; |
| callback(fuchsia::bluetooth::gatt::ErrorCode::INVALID_OFFSET); |
| return; |
| } |
| |
| // Copy the data to a PacketBuffer. |
| buf = PacketBuffer::New(0); |
| if (!buf || buf->AvailableDataLength() < value.size()) { |
| FX_LOGS(ERROR) << "Buffer not available"; |
| callback(fuchsia::bluetooth::gatt::ErrorCode::INVALID_VALUE_LENGTH); |
| PacketBuffer::Free(buf); |
| return; |
| } |
| |
| std::copy(value.begin(), value.end(), buf->Start()); |
| buf->SetDataLength(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 = NULL; |
| |
| callback(fuchsia::bluetooth::gatt::ErrorCode::NO_ERROR); |
| } |
| |
| void BLEManagerImpl::OnWriteWithoutResponse(uint64_t id, uint16_t offset, |
| std::vector<uint8_t> value) {} |
| |
| } // namespace Internal |
| } // namespace DeviceLayer |
| } // namespace Weave |
| } // namespace nl |
| |
| #endif // WEAVE_DEVICE_CONFIG_ENABLE_WOBLE |
