| // Copyright 2024 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "content/browser/devtools/protocol/bluetooth_emulation_handler.h" |
| |
| #include <map> |
| #include <string> |
| #include <string_view> |
| #include <utility> |
| #include <vector> |
| |
| #include "base/containers/span.h" |
| #include "base/containers/to_vector.h" |
| #include "base/notreached.h" |
| #include "base/strings/strcat.h" |
| #include "base/strings/string_number_conversions.h" |
| #include "content/browser/bluetooth/bluetooth_adapter_factory_wrapper.h" |
| #include "content/browser/devtools/protocol/bluetooth_emulation.h" |
| #include "device/bluetooth/emulation/fake_central.h" |
| |
| using device::BluetoothAdapterFactory; |
| |
| namespace content::protocol { |
| |
| namespace { |
| |
| base::flat_map<uint16_t, std::vector<uint8_t>> ToManufacturerData( |
| protocol::Array<protocol::BluetoothEmulation::ManufacturerData>* |
| in_manufacturer_data) { |
| base::flat_map<uint16_t, std::vector<uint8_t>> out_manufacturer_data; |
| for (auto& data : *in_manufacturer_data) { |
| out_manufacturer_data[data->GetKey()] = base::ToVector(data->GetData()); |
| } |
| return out_manufacturer_data; |
| } |
| |
| std::vector<device::BluetoothUUID> ToBluetoothUUIDs( |
| protocol::Array<protocol::String>* in_bluetooth_ids) { |
| std::vector<device::BluetoothUUID> out_bluetooth_ids; |
| for (auto& uuid : *in_bluetooth_ids) { |
| out_bluetooth_ids.emplace_back(uuid); |
| } |
| return out_bluetooth_ids; |
| } |
| |
| mojo::StructPtr<bluetooth::mojom::ScanRecord> ToScanRecord( |
| BluetoothEmulation::ScanRecord* in_record) { |
| mojo::StructPtr<bluetooth::mojom::ScanRecord> out_record = |
| bluetooth::mojom::ScanRecord::New(); |
| |
| if (in_record->HasUuids()) { |
| out_record->uuids = ToBluetoothUUIDs(in_record->GetUuids(nullptr)); |
| } |
| |
| // Convert Appearance |
| if (in_record->HasAppearance()) { |
| out_record->appearance = bluetooth::mojom::Appearance::New( |
| in_record->HasAppearance(), in_record->GetAppearance(0)); |
| } |
| |
| // Convert TX Power |
| if (in_record->HasTxPower()) { |
| out_record->tx_power = bluetooth::mojom::Power::New( |
| in_record->HasTxPower(), in_record->GetTxPower(0)); |
| } |
| |
| if (in_record->HasManufacturerData()) { |
| out_record->manufacturer_data = |
| ToManufacturerData(in_record->GetManufacturerData(nullptr)); |
| } |
| |
| return out_record; |
| } |
| |
| mojo::StructPtr<bluetooth::mojom::CharacteristicProperties> |
| ToCharacteristicProperties( |
| BluetoothEmulation::CharacteristicProperties* in_properties) { |
| mojo::StructPtr<bluetooth::mojom::CharacteristicProperties> out_properties = |
| bluetooth::mojom::CharacteristicProperties::New(); |
| out_properties->broadcast = in_properties->GetBroadcast().value_or(false); |
| out_properties->read = in_properties->GetRead().value_or(false); |
| out_properties->write_without_response = |
| in_properties->GetWriteWithoutResponse().value_or(false); |
| out_properties->write = in_properties->GetWrite().value_or(false); |
| out_properties->notify = in_properties->GetNotify().value_or(false); |
| out_properties->indicate = in_properties->GetIndicate().value_or(false); |
| out_properties->authenticated_signed_writes = |
| in_properties->GetAuthenticatedSignedWrites().value_or(false); |
| out_properties->extended_properties = |
| in_properties->GetExtendedProperties().value_or(false); |
| return out_properties; |
| } |
| |
| bluetooth::mojom::CentralState ToCentralState(const std::string& state_string) { |
| if (state_string == |
| protocol::BluetoothEmulation::CentralStateEnum::PoweredOff) { |
| return bluetooth::mojom::CentralState::POWERED_OFF; |
| } else if (state_string == |
| protocol::BluetoothEmulation::CentralStateEnum::PoweredOn) { |
| return bluetooth::mojom::CentralState::POWERED_ON; |
| } |
| return bluetooth::mojom::CentralState::ABSENT; |
| } |
| |
| constexpr std::string_view ToGATTOperation( |
| bluetooth::mojom::GATTOperationType type) { |
| switch (type) { |
| case bluetooth::mojom::GATTOperationType::kConnect: |
| return BluetoothEmulation::GATTOperationTypeEnum::Connection; |
| case bluetooth::mojom::GATTOperationType::kDiscovery: |
| return BluetoothEmulation::GATTOperationTypeEnum::Discovery; |
| } |
| } |
| |
| std::optional<bluetooth::mojom::GATTOperationType> ToGATTOperation( |
| std::string_view type) { |
| if (type == BluetoothEmulation::GATTOperationTypeEnum::Connection) { |
| return bluetooth::mojom::GATTOperationType::kConnect; |
| } else if (type == BluetoothEmulation::GATTOperationTypeEnum::Discovery) { |
| return bluetooth::mojom::GATTOperationType::kDiscovery; |
| } else { |
| return std::nullopt; |
| } |
| } |
| |
| constexpr std::string_view ToCharacteristicOperation( |
| bluetooth::mojom::CharacteristicOperationType type) { |
| switch (type) { |
| case bluetooth::mojom::CharacteristicOperationType::kRead: |
| return BluetoothEmulation::CharacteristicOperationTypeEnum::Read; |
| case bluetooth::mojom::CharacteristicOperationType::kWrite: |
| return BluetoothEmulation::CharacteristicOperationTypeEnum::Write; |
| case bluetooth::mojom::CharacteristicOperationType:: |
| kSubscribeToNotifications: |
| return BluetoothEmulation::CharacteristicOperationTypeEnum:: |
| SubscribeToNotifications; |
| case bluetooth::mojom::CharacteristicOperationType:: |
| kUnsubscribeFromNotifications: |
| return BluetoothEmulation::CharacteristicOperationTypeEnum:: |
| UnsubscribeFromNotifications; |
| } |
| } |
| |
| std::optional<bluetooth::mojom::CharacteristicOperationType> |
| ToCharacteristicOperation(std::string_view type) { |
| if (type == BluetoothEmulation::CharacteristicOperationTypeEnum::Read) { |
| return bluetooth::mojom::CharacteristicOperationType::kRead; |
| } else if (type == |
| BluetoothEmulation::CharacteristicOperationTypeEnum::Write) { |
| return bluetooth::mojom::CharacteristicOperationType::kWrite; |
| } else if (type == BluetoothEmulation::CharacteristicOperationTypeEnum:: |
| SubscribeToNotifications) { |
| return bluetooth::mojom::CharacteristicOperationType:: |
| kSubscribeToNotifications; |
| } else if (type == BluetoothEmulation::CharacteristicOperationTypeEnum:: |
| UnsubscribeFromNotifications) { |
| return bluetooth::mojom::CharacteristicOperationType:: |
| kUnsubscribeFromNotifications; |
| } else { |
| return std::nullopt; |
| } |
| } |
| |
| constexpr std::string_view ToCharacteristicWriteType( |
| bluetooth::mojom::WriteType type) { |
| switch (type) { |
| case bluetooth::mojom::WriteType::kNone: |
| NOTREACHED(); |
| case bluetooth::mojom::WriteType::kWriteDefaultDeprecated: |
| return BluetoothEmulation::CharacteristicWriteTypeEnum:: |
| WriteDefaultDeprecated; |
| case bluetooth::mojom::WriteType::kWriteWithResponse: |
| return BluetoothEmulation::CharacteristicWriteTypeEnum::WriteWithResponse; |
| case bluetooth::mojom::WriteType::kWriteWithoutResponse: |
| return BluetoothEmulation::CharacteristicWriteTypeEnum:: |
| WriteWithoutResponse; |
| } |
| } |
| |
| constexpr std::string_view ToDescriptorOperation( |
| bluetooth::mojom::DescriptorOperationType type) { |
| switch (type) { |
| case bluetooth::mojom::DescriptorOperationType::kRead: |
| return BluetoothEmulation::CharacteristicOperationTypeEnum::Read; |
| case bluetooth::mojom::DescriptorOperationType::kWrite: |
| return BluetoothEmulation::DescriptorOperationTypeEnum::Write; |
| } |
| } |
| |
| std::optional<bluetooth::mojom::DescriptorOperationType> ToDescriptorOperation( |
| std::string_view type) { |
| if (type == BluetoothEmulation::DescriptorOperationTypeEnum::Read) { |
| return bluetooth::mojom::DescriptorOperationType::kRead; |
| } else if (type == BluetoothEmulation::DescriptorOperationTypeEnum::Write) { |
| return bluetooth::mojom::DescriptorOperationType::kWrite; |
| } else { |
| return std::nullopt; |
| } |
| } |
| |
| std::string getParentId(const std::string& id) { |
| // This decoding mechanism aligns with the identifier formatting mechanism in |
| // FakePeripheral::AddFakeService, |
| // FakeRemoteGattService::AddFakeCharacteristic, and |
| // FakeRemoteGattCharacteristic::AddFakeDescriptor. |
| size_t lastUnderscorePos = id.rfind('_'); |
| if (lastUnderscorePos != std::string::npos) { |
| return id.substr(0, lastUnderscorePos); |
| } |
| return ""; |
| } |
| |
| bool IsValidIdString(const std::string& str) { |
| if (str.empty()) { |
| return false; |
| } |
| // Id is expected to start from 1. |
| if (str[0] < '1' || str[0] > '9') { |
| return false; |
| } |
| return std::ranges::all_of(str.begin() + 1, str.end(), ::isdigit); |
| } |
| |
| bool IsValidServiceId(const std::string& id) { |
| size_t lastUnderscorePos = id.rfind('_'); |
| return IsValidIdString(id.substr(lastUnderscorePos + 1)); |
| } |
| |
| bool IsValidCharacteristicId(const std::string& id) { |
| size_t lastUnderscorePos = id.rfind('_'); |
| return IsValidIdString(id.substr(lastUnderscorePos + 1)) && |
| IsValidServiceId(id.substr(0, lastUnderscorePos)); |
| } |
| |
| bool IsValidDescriptorId(const std::string& id) { |
| size_t lastUnderscorePos = id.rfind('_'); |
| return IsValidIdString(id.substr(lastUnderscorePos + 1)) && |
| IsValidCharacteristicId(id.substr(0, lastUnderscorePos)); |
| } |
| |
| } // namespace |
| |
| // static |
| std::vector<BluetoothEmulationHandler*> BluetoothEmulationHandler::ForAgentHost( |
| DevToolsAgentHostImpl* host) { |
| return host->HandlersByName<BluetoothEmulationHandler>( |
| BluetoothEmulation::Metainfo::domainName); |
| } |
| |
| BluetoothEmulationHandler::BluetoothEmulationHandler() |
| : DevToolsDomainHandler(BluetoothEmulation::Metainfo::domainName) {} |
| |
| BluetoothEmulationHandler::~BluetoothEmulationHandler() = default; |
| |
| void BluetoothEmulationHandler::Wire(UberDispatcher* dispatcher) { |
| frontend_.emplace(dispatcher->channel()); |
| BluetoothEmulation::Dispatcher::wire(dispatcher, this); |
| } |
| |
| Response BluetoothEmulationHandler::Enable(const std::string& in_state, |
| bool in_le_supported) { |
| if (emulation_enabled_) { |
| return Response::ServerError("BluetoothEmulation already enabled"); |
| } |
| |
| CHECK(!is_enabled()); |
| CHECK(!client_receiver_.is_bound()); |
| emulation_enabled_ = true; |
| global_factory_values_ = |
| BluetoothAdapterFactory::Get()->InitGlobalOverrideValues(); |
| global_factory_values_->SetLESupported(in_le_supported); |
| if (in_le_supported) { |
| content::BluetoothAdapterFactoryWrapper::Get().SetBluetoothAdapterOverride( |
| base::MakeRefCounted<bluetooth::FakeCentral>( |
| ToCentralState(in_state), |
| fake_central_.BindNewPipeAndPassReceiver())); |
| fake_central_.reset_on_disconnect(); |
| // While there's a possibility the client might not be fully settled on the |
| // fake central side upon return, this is acceptable. Client events are |
| // expected to be delivered only after at least one peripheral has been |
| // simulated. By that time, the client should be properly settled on the |
| // fake central side. |
| fake_central_->SetClient(client_receiver_.BindNewEndpointAndPassRemote()); |
| client_receiver_.reset_on_disconnect(); |
| } |
| return Response::Success(); |
| } |
| |
| Response BluetoothEmulationHandler::Disable() { |
| if (is_enabled()) { |
| CHECK(emulation_enabled_); |
| client_receiver_.reset(); |
| fake_central_.reset(); |
| // reset this only if this is the instance holding the bound central. |
| content::BluetoothAdapterFactoryWrapper::Get().SetBluetoothAdapterOverride( |
| nullptr); |
| } |
| // The instance that has a valid `global_factory_values_` is the one that sets |
| // `emulation_enabled_`. Therefore, only that instance can reset |
| // `emulation_enabled_`. |
| if (global_factory_values_) { |
| global_factory_values_.reset(); |
| emulation_enabled_ = false; |
| } |
| return Response::Success(); |
| } |
| |
| void BluetoothEmulationHandler::SetSimulatedCentralState( |
| const std::string& in_state, |
| std::unique_ptr<SetSimulatedCentralStateCallback> callback) { |
| if (!is_enabled()) { |
| std::move(callback)->sendFailure( |
| Response::ServerError("BluetoothEmulation not enabled")); |
| return; |
| } |
| fake_central_->SetState( |
| ToCentralState(in_state), |
| base::BindOnce(&SetSimulatedCentralStateCallback::sendSuccess, |
| std::move(callback))); |
| } |
| |
| void BluetoothEmulationHandler::SimulatePreconnectedPeripheral( |
| const std::string& in_address, |
| const std::string& in_name, |
| std::unique_ptr< |
| protocol::Array<protocol::BluetoothEmulation::ManufacturerData>> |
| in_manufacturer_data, |
| std::unique_ptr<protocol::Array<String>> in_known_service_uuids, |
| std::unique_ptr<SimulatePreconnectedPeripheralCallback> callback) { |
| if (!is_enabled()) { |
| std::move(callback)->sendFailure( |
| Response::ServerError("BluetoothEmulation not enabled")); |
| return; |
| } |
| fake_central_->SimulatePreconnectedPeripheral( |
| in_address, in_name, ToManufacturerData(in_manufacturer_data.get()), |
| ToBluetoothUUIDs(in_known_service_uuids.get()), |
| base::BindOnce(&SimulatePreconnectedPeripheralCallback::sendSuccess, |
| std::move(callback))); |
| } |
| |
| void BluetoothEmulationHandler::SimulateAdvertisement( |
| std::unique_ptr<protocol::BluetoothEmulation::ScanEntry> in_entry, |
| std::unique_ptr<SimulateAdvertisementCallback> callback) { |
| if (!is_enabled()) { |
| std::move(callback)->sendFailure( |
| Response::ServerError("BluetoothEmulation not enabled")); |
| return; |
| } |
| bluetooth::mojom::ScanResultPtr payload = bluetooth::mojom::ScanResult::New( |
| in_entry->GetDeviceAddress(), in_entry->GetRssi(), |
| ToScanRecord(in_entry->GetScanRecord())); |
| fake_central_->SimulateAdvertisementReceived( |
| std::move(payload), |
| base::BindOnce(&SimulateAdvertisementCallback::sendSuccess, |
| std::move(callback))); |
| } |
| |
| void BluetoothEmulationHandler::SimulateGATTOperationResponse( |
| const std::string& in_address, |
| const std::string& in_type, |
| int in_code, |
| std::unique_ptr<SimulateGATTOperationResponseCallback> callback) { |
| if (!is_enabled()) { |
| std::move(callback)->sendFailure( |
| Response::ServerError("BluetoothEmulation not enabled")); |
| return; |
| } |
| auto gatt_operation_type = ToGATTOperation(in_type); |
| if (!gatt_operation_type) { |
| std::move(callback)->sendFailure(Response::InvalidParams( |
| base::StrCat({"Unknown GATT operation type ", in_type}))); |
| return; |
| } |
| |
| fake_central_->SimulateGATTOperationResponse( |
| *gatt_operation_type, in_address, in_code, |
| base::BindOnce( |
| [](std::unique_ptr<SimulateGATTOperationResponseCallback> callback, |
| const std::string& type, bool success) { |
| if (!success) { |
| std::move(callback)->sendFailure( |
| Response::ServerError(base::StrCat( |
| {"Failed to simulate GATT response for operation type ", |
| type}))); |
| return; |
| } |
| std::move(callback)->sendSuccess(); |
| }, |
| std::move(callback), in_type)); |
| } |
| |
| void BluetoothEmulationHandler::SimulateCharacteristicOperationResponse( |
| const std::string& characteristic_id, |
| const std::string& in_type, |
| int in_code, |
| std::optional<Binary> in_data, |
| std::unique_ptr<SimulateCharacteristicOperationResponseCallback> callback) { |
| if (!is_enabled()) { |
| std::move(callback)->sendFailure( |
| Response::ServerError("BluetoothEmulation not enabled")); |
| return; |
| } |
| auto operation_type = ToCharacteristicOperation(in_type); |
| if (!operation_type) { |
| std::move(callback)->sendFailure(Response::InvalidParams( |
| base::StrCat({"Unknown characteristic operation type ", in_type}))); |
| return; |
| } |
| if (operation_type == bluetooth::mojom::CharacteristicOperationType::kRead && |
| ((in_code == bluetooth::mojom::kGATTSuccess) != in_data.has_value())) { |
| std::move(callback)->sendFailure(Response::InvalidParams( |
| base::StrCat({"Characteristic operation type ", in_type, " with code ", |
| base::NumberToString(in_code), |
| in_data ? " does not expect" : " expects", " data"}))); |
| return; |
| } |
| |
| std::string service_id = getParentId(characteristic_id); |
| std::string address = getParentId(service_id); |
| fake_central_->SimulateCharacteristicOperationResponse( |
| *operation_type, characteristic_id, service_id, address, in_code, |
| in_data ? std::optional(base::ToVector(*in_data)) : std::nullopt, |
| base::BindOnce( |
| [](std::unique_ptr<SimulateCharacteristicOperationResponseCallback> |
| callback, |
| const std::string& error_message, bool success) { |
| if (!success) { |
| std::move(callback)->sendFailure( |
| Response::ServerError(error_message)); |
| return; |
| } |
| std::move(callback)->sendSuccess(); |
| }, |
| std::move(callback), |
| base::StrCat( |
| {"Failed to simulate characteristic response for operation type ", |
| in_type}))); |
| } |
| |
| void BluetoothEmulationHandler::SimulateDescriptorOperationResponse( |
| const std::string& descriptor_id, |
| const std::string& in_type, |
| int in_code, |
| std::optional<Binary> in_data, |
| std::unique_ptr<SimulateDescriptorOperationResponseCallback> callback) { |
| if (!is_enabled()) { |
| std::move(callback)->sendFailure( |
| Response::ServerError("BluetoothEmulation not enabled")); |
| return; |
| } |
| auto operation_type = ToDescriptorOperation(in_type); |
| if (!operation_type) { |
| std::move(callback)->sendFailure(Response::InvalidParams( |
| base::StrCat({"Unknown descriptor operation type ", in_type}))); |
| return; |
| } |
| if (operation_type == bluetooth::mojom::DescriptorOperationType::kRead && |
| ((in_code == bluetooth::mojom::kGATTSuccess) != in_data.has_value())) { |
| std::move(callback)->sendFailure(Response::InvalidParams( |
| base::StrCat({"Descriptor operation type ", in_type, " with code ", |
| base::NumberToString(in_code), |
| in_data ? " does not expect" : " expects", " data"}))); |
| return; |
| } |
| |
| std::string characteristic_id = getParentId(descriptor_id); |
| std::string service_id = getParentId(characteristic_id); |
| std::string address = getParentId(service_id); |
| fake_central_->SimulateDescriptorOperationResponse( |
| *operation_type, descriptor_id, characteristic_id, service_id, address, |
| in_code, in_data ? std::optional(base::ToVector(*in_data)) : std::nullopt, |
| base::BindOnce( |
| [](std::unique_ptr<SimulateDescriptorOperationResponseCallback> |
| callback, |
| const std::string& error_message, bool success) { |
| if (!success) { |
| std::move(callback)->sendFailure( |
| Response::ServerError(error_message)); |
| return; |
| } |
| std::move(callback)->sendSuccess(); |
| }, |
| std::move(callback), |
| base::StrCat( |
| {"Failed to simulate descriptor response for operation type ", |
| in_type}))); |
| } |
| |
| void BluetoothEmulationHandler::AddService( |
| const std::string& in_address, |
| const std::string& service_uuid, |
| std::unique_ptr<AddServiceCallback> callback) { |
| if (!is_enabled()) { |
| std::move(callback)->sendFailure( |
| Response::ServerError("BluetoothEmulation not enabled")); |
| return; |
| } |
| |
| device::BluetoothUUID uuid(service_uuid); |
| if (!uuid.IsValid()) { |
| std::move(callback)->sendFailure(Response::InvalidParams( |
| base::StrCat({service_uuid, " is not a valid UUID"}))); |
| return; |
| } |
| |
| fake_central_->AddFakeService( |
| in_address, uuid, |
| base::BindOnce( |
| [](std::unique_ptr<AddServiceCallback> callback, |
| const std::string& error_message, |
| const std::optional<std::string>& identifier) { |
| if (!identifier) { |
| std::move(callback)->sendFailure( |
| Response::ServerError(error_message)); |
| return; |
| } |
| DCHECK(IsValidServiceId(*identifier)); |
| std::move(callback)->sendSuccess(*identifier); |
| }, |
| std::move(callback), |
| base::StrCat({"Failed to add service ", service_uuid, |
| " to peripheral ", in_address}))); |
| } |
| |
| void BluetoothEmulationHandler::RemoveService( |
| const std::string& service_id, |
| std::unique_ptr<RemoveServiceCallback> callback) { |
| if (!is_enabled()) { |
| std::move(callback)->sendFailure( |
| Response::ServerError("BluetoothEmulation not enabled")); |
| return; |
| } |
| |
| std::string address = getParentId(service_id); |
| fake_central_->RemoveFakeService( |
| service_id, address, |
| base::BindOnce( |
| [](std::unique_ptr<RemoveServiceCallback> callback, |
| const std::string& error_message, bool success) { |
| if (!success) { |
| std::move(callback)->sendFailure( |
| Response::ServerError(error_message)); |
| return; |
| } |
| std::move(callback)->sendSuccess(); |
| }, |
| std::move(callback), |
| base::StrCat( |
| {"Failed to remove service represented by ", service_id}))); |
| } |
| |
| void BluetoothEmulationHandler::AddCharacteristic( |
| const std::string& service_id, |
| const std::string& characteristic_uuid, |
| std::unique_ptr<protocol::BluetoothEmulation::CharacteristicProperties> |
| in_properties, |
| std::unique_ptr<AddCharacteristicCallback> callback) { |
| if (!is_enabled()) { |
| std::move(callback)->sendFailure( |
| Response::ServerError("BluetoothEmulation not enabled")); |
| return; |
| } |
| |
| device::BluetoothUUID uuid(characteristic_uuid); |
| if (!uuid.IsValid()) { |
| std::move(callback)->sendFailure(Response::InvalidParams( |
| base::StrCat({characteristic_uuid, " is not a valid UUID"}))); |
| return; |
| } |
| |
| std::string address = getParentId(service_id); |
| fake_central_->AddFakeCharacteristic( |
| uuid, ToCharacteristicProperties(in_properties.get()), service_id, |
| address, |
| base::BindOnce( |
| [](std::unique_ptr<AddCharacteristicCallback> callback, |
| const std::string& error_message, |
| const std::optional<std::string>& identifier) { |
| if (!identifier) { |
| std::move(callback)->sendFailure( |
| Response::ServerError(error_message)); |
| return; |
| } |
| DCHECK(IsValidCharacteristicId(*identifier)); |
| std::move(callback)->sendSuccess(*identifier); |
| }, |
| std::move(callback), |
| base::StrCat({"Failed to add characteristic ", characteristic_uuid, |
| " to service ", service_id}))); |
| } |
| |
| void BluetoothEmulationHandler::RemoveCharacteristic( |
| const std::string& characteristic_id, |
| std::unique_ptr<RemoveCharacteristicCallback> callback) { |
| if (!is_enabled()) { |
| std::move(callback)->sendFailure( |
| Response::ServerError("BluetoothEmulation not enabled")); |
| return; |
| } |
| |
| std::string service_id = getParentId(characteristic_id); |
| std::string address = getParentId(service_id); |
| fake_central_->RemoveFakeCharacteristic( |
| characteristic_id, service_id, address, |
| base::BindOnce( |
| [](std::unique_ptr<RemoveCharacteristicCallback> callback, |
| const std::string& error_message, bool success) { |
| if (!success) { |
| std::move(callback)->sendFailure( |
| Response::ServerError(error_message)); |
| return; |
| } |
| std::move(callback)->sendSuccess(); |
| }, |
| std::move(callback), |
| base::StrCat({"Failed to remove characteristic represented by ", |
| characteristic_id}))); |
| } |
| |
| void BluetoothEmulationHandler::AddDescriptor( |
| const std::string& characteristic_id, |
| const std::string& descriptor_uuid, |
| std::unique_ptr<AddDescriptorCallback> callback) { |
| if (!is_enabled()) { |
| std::move(callback)->sendFailure( |
| Response::ServerError("BluetoothEmulation not enabled")); |
| return; |
| } |
| |
| device::BluetoothUUID uuid(descriptor_uuid); |
| if (!uuid.IsValid()) { |
| std::move(callback)->sendFailure(Response::InvalidParams( |
| base::StrCat({descriptor_uuid, " is not a valid UUID"}))); |
| return; |
| } |
| |
| std::string service_id = getParentId(characteristic_id); |
| std::string address = getParentId(service_id); |
| fake_central_->AddFakeDescriptor( |
| uuid, characteristic_id, service_id, address, |
| base::BindOnce( |
| [](std::unique_ptr<AddDescriptorCallback> callback, |
| const std::string& error_message, |
| const std::optional<std::string>& identifier) { |
| if (!identifier) { |
| std::move(callback)->sendFailure( |
| Response::ServerError(error_message)); |
| return; |
| } |
| DCHECK(IsValidDescriptorId(*identifier)); |
| std::move(callback)->sendSuccess(*identifier); |
| }, |
| std::move(callback), |
| base::StrCat({"Failed to add descriptor ", descriptor_uuid, |
| " to characteristic ", characteristic_id}))); |
| } |
| |
| void BluetoothEmulationHandler::RemoveDescriptor( |
| const std::string& descriptor_id, |
| std::unique_ptr<RemoveDescriptorCallback> callback) { |
| if (!is_enabled()) { |
| std::move(callback)->sendFailure( |
| Response::ServerError("BluetoothEmulation not enabled")); |
| return; |
| } |
| |
| std::string characteristic_id = getParentId(descriptor_id); |
| std::string service_id = getParentId(characteristic_id); |
| std::string address = getParentId(service_id); |
| fake_central_->RemoveFakeDescriptor( |
| descriptor_id, characteristic_id, service_id, address, |
| base::BindOnce( |
| [](std::unique_ptr<RemoveDescriptorCallback> callback, |
| const std::string& error_message, bool success) { |
| if (!success) { |
| std::move(callback)->sendFailure( |
| Response::ServerError(error_message)); |
| return; |
| } |
| std::move(callback)->sendSuccess(); |
| }, |
| std::move(callback), |
| base::StrCat( |
| {"Failed to remove descriptor represented by ", descriptor_id}))); |
| } |
| |
| void BluetoothEmulationHandler::SimulateGATTDisconnection( |
| const std::string& address, |
| std::unique_ptr<SimulateGATTDisconnectionCallback> callback) { |
| if (!is_enabled()) { |
| std::move(callback)->sendFailure( |
| Response::ServerError("BluetoothEmulation not enabled")); |
| return; |
| } |
| |
| fake_central_->SimulateGATTDisconnection( |
| address, |
| base::BindOnce( |
| [](std::unique_ptr<SimulateGATTDisconnectionCallback> callback, |
| bool success) { |
| if (!success) { |
| std::move(callback)->sendFailure(Response::ServerError( |
| "Failed to simulate GATT disconnection")); |
| return; |
| } |
| std::move(callback)->sendSuccess(); |
| }, |
| std::move(callback))); |
| } |
| |
| void BluetoothEmulationHandler::DispatchGATTOperationEvent( |
| bluetooth::mojom::GATTOperationType type, |
| const std::string& peripheral_address) { |
| frontend_->GattOperationReceived(peripheral_address, |
| std::string(ToGATTOperation(type))); |
| } |
| |
| void BluetoothEmulationHandler::DispatchCharacteristicOperationEvent( |
| bluetooth::mojom::CharacteristicOperationType type, |
| const std::optional<std::vector<uint8_t>>& data, |
| const std::optional<bluetooth::mojom::WriteType> write_type, |
| const std::string& characteristic_id) { |
| frontend_->CharacteristicOperationReceived( |
| characteristic_id, std::string(ToCharacteristicOperation(type)), |
| data ? std::optional(Binary::fromVector(*data)) : std::nullopt, |
| write_type |
| ? std::optional(std::string(ToCharacteristicWriteType(*write_type))) |
| : std::nullopt); |
| } |
| |
| void BluetoothEmulationHandler::DispatchDescriptorOperationEvent( |
| bluetooth::mojom::DescriptorOperationType type, |
| const std::optional<std::vector<uint8_t>>& data, |
| const std::string& descriptor_id) { |
| frontend_->DescriptorOperationReceived( |
| descriptor_id, std::string(ToDescriptorOperation(type)), |
| data ? std::optional(Binary::fromVector(*data)) : std::nullopt); |
| } |
| |
| } // namespace content::protocol |
