| // Copyright 2019 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "bluetooth/newblued/gatt_interface_handler.h" |
| |
| #include <bits/stdint-uintn.h> |
| #include <cstdint> |
| #include <memory> |
| #include <utility> |
| #include <vector> |
| |
| #include <chromeos/dbus/service_constants.h> |
| |
| #include "bluetooth/newblued/util.h" |
| |
| namespace bluetooth { |
| |
| namespace { |
| |
| // Canonicalizes UUID. |
| std::string CanonicalizeUuid(const Uuid& uuid) { |
| return uuid.canonical_value(); |
| } |
| |
| // Converts GATT service into its D-Bus object path. |
| dbus::ObjectPath ConvertServiceToObjectPath(const GattService* const& service) { |
| CHECK(service); |
| CHECK(service->HasOwner()); |
| |
| std::string device_address = service->device_address().value(); |
| return ConvertServiceHandleToObjectPath(device_address, |
| service->first_handle()); |
| } |
| |
| // Converts GATT characteristic into its D-Bus object path. |
| dbus::ObjectPath ConvertCharToObjectPath( |
| const GattCharacteristic* const& characteristic) { |
| CHECK(characteristic); |
| |
| const GattService* service = characteristic->service().value(); |
| CHECK(service->HasOwner()); |
| |
| return bluetooth::ConvertCharacteristicHandleToObjectPath( |
| service->device_address().value(), service->first_handle(), |
| characteristic->first_handle()); |
| } |
| |
| // Converts GATT characteristic properties to BlueZ GATT characteristic flags. |
| std::vector<std::string> ConvertPropertiesToStrings( |
| const std::uint8_t& properties) { |
| std::vector<std::string> flags; |
| |
| if (properties & GattCharacteristicPropertyMask::BROADCAST) |
| flags.push_back(bluetooth_gatt_characteristic::kFlagBroadcast); |
| if (properties & GattCharacteristicPropertyMask::READ) |
| flags.push_back(bluetooth_gatt_characteristic::kFlagRead); |
| if (properties & GattCharacteristicPropertyMask::WRITE_WITHOUT_RESPONSE) |
| flags.push_back(bluetooth_gatt_characteristic::kFlagWriteWithoutResponse); |
| if (properties & GattCharacteristicPropertyMask::WRITE) |
| flags.push_back(bluetooth_gatt_characteristic::kFlagWrite); |
| if (properties & GattCharacteristicPropertyMask::NOTIFY) |
| flags.push_back(bluetooth_gatt_characteristic::kFlagNotify); |
| if (properties & GattCharacteristicPropertyMask::INDICATE) |
| flags.push_back(bluetooth_gatt_characteristic::kFlagIndicate); |
| if (properties & GattCharacteristicPropertyMask::AUTHENTICATED_SIGNED_WRITE) |
| flags.push_back( |
| bluetooth_gatt_characteristic::kFlagAuthenticatedSignedWrites); |
| if (properties & GattCharacteristicPropertyMask::EXTENDED_PROPERTIES) |
| flags.push_back(bluetooth_gatt_characteristic::kFlagExtendedProperties); |
| |
| return flags; |
| } |
| |
| // Translates GATT notifying setting to a bool value. |
| bool ConvertNotifySettingToBool( |
| const GattCharacteristic::NotifySetting& setting) { |
| return setting != GattCharacteristic::NotifySetting::NONE; |
| } |
| |
| void ConvertGattClientOperationErrorToDBusError( |
| std::string* dbus_error, |
| std::string* error_message, |
| GattClientOperationError error) { |
| CHECK(dbus_error != nullptr); |
| CHECK(error_message != nullptr); |
| |
| *dbus_error = ""; |
| *error_message = ""; |
| switch (error) { |
| case GattClientOperationError::NONE: |
| return; |
| case GattClientOperationError::READ_NOT_ALLOWED: |
| *dbus_error = bluetooth_gatt_characteristic::kErrorNotPermitted; |
| *error_message = "Read not permitted"; |
| return; |
| case GattClientOperationError::WRITE_NOT_ALLOWED: |
| *dbus_error = bluetooth_gatt_characteristic::kErrorNotPermitted; |
| *error_message = "Write not permitted"; |
| return; |
| case GattClientOperationError::INSUFF_AUTHN: // Fall through. |
| case GattClientOperationError::INSUFF_ENCR_KEY_SIZE: // Fall through. |
| case GattClientOperationError::INSUFF_ENC: |
| *dbus_error = bluetooth_gatt_characteristic::kErrorNotPermitted; |
| *error_message = "Not paired"; |
| return; |
| case GattClientOperationError::NOT_SUPPORTED: |
| *dbus_error = bluetooth_gatt_characteristic::kErrorNotSupported; |
| return; |
| case GattClientOperationError::INSUFF_AUTHZ: |
| *dbus_error = bluetooth_gatt_characteristic::kErrorNotAuthorized; |
| return; |
| case GattClientOperationError::INVALID_OFFSET: |
| *dbus_error = bluetooth_gatt_characteristic::kErrorInvalidArguments; |
| *error_message = "Invalid offset"; |
| return; |
| case GattClientOperationError::INVALUD_ATTR_VALUE_LENGTH: |
| *dbus_error = bluetooth_gatt_characteristic::kErrorInvalidArguments; |
| *error_message = "Invalid length"; |
| return; |
| case GattClientOperationError::OTHER: // Fall through. |
| default: |
| *dbus_error = bluetooth_gatt_characteristic::kErrorFailed; |
| *error_message = "Operation failed with other error"; |
| return; |
| } |
| } |
| |
| } // namespace |
| |
| GattInterfaceHandler::GattInterfaceHandler( |
| scoped_refptr<dbus::Bus> bus, |
| Newblue* newblue, |
| ExportedObjectManagerWrapper* exported_object_manager_wrapper, |
| Gatt* gatt) |
| : bus_(bus), |
| newblue_(newblue), |
| exported_object_manager_wrapper_(exported_object_manager_wrapper), |
| gatt_(gatt), |
| weak_ptr_factory_(this) { |
| CHECK(bus_); |
| CHECK(newblue_); |
| CHECK(exported_object_manager_wrapper_); |
| CHECK(gatt_); |
| } |
| |
| void GattInterfaceHandler::Init() { |
| gatt_->AddGattObserver(this); |
| } |
| |
| void GattInterfaceHandler::OnGattServiceAdded(const GattService& service) { |
| ExportGattServiceInterface(service); |
| } |
| |
| void GattInterfaceHandler::OnGattServiceRemoved(const GattService& service) { |
| CHECK(service.HasOwner()); |
| |
| dbus::ObjectPath service_path(ConvertServiceHandleToObjectPath( |
| service.device_address().value(), service.first_handle())); |
| |
| VLOG(1) << "Unexporting a GATT service object at " << service_path.value(); |
| |
| exported_object_manager_wrapper_->RemoveExportedInterface( |
| service_path, bluetooth_gatt_service::kBluetoothGattServiceInterface); |
| } |
| |
| void GattInterfaceHandler::OnGattServiceChanged(const GattService& service) { |
| ExportGattServiceInterface(service); |
| } |
| |
| void GattInterfaceHandler::OnGattCharacteristicAdded( |
| const GattCharacteristic& characteristic) { |
| ExportGattCharacteristicInterface(characteristic); |
| } |
| |
| void GattInterfaceHandler::OnGattCharacteristicRemoved( |
| const GattCharacteristic& characteristic) { |
| const GattService* service = characteristic.service().value(); |
| |
| CHECK(service->HasOwner()); |
| |
| dbus::ObjectPath char_path(ConvertCharacteristicHandleToObjectPath( |
| service->device_address().value(), service->first_handle(), |
| characteristic.first_handle())); |
| |
| VLOG(1) << "Unexporting a GATT characteristic object at " |
| << char_path.value(); |
| |
| exported_object_manager_wrapper_->RemoveExportedInterface( |
| char_path, |
| bluetooth_gatt_characteristic::kBluetoothGattCharacteristicInterface); |
| |
| // Remove ongoing transaction(s) associated with the object. |
| for (auto it = gatt_client_requests_.begin(); |
| it != gatt_client_requests_.end();) { |
| if (it->second.object_path == char_path.value()) |
| it = gatt_client_requests_.erase(it); |
| else |
| ++it; |
| } |
| } |
| |
| void GattInterfaceHandler::OnGattCharacteristicChanged( |
| const GattCharacteristic& characteristic) { |
| ExportGattCharacteristicInterface(characteristic); |
| } |
| |
| void GattInterfaceHandler::OnGattDescriptorAdded( |
| const GattDescriptor& descriptor) { |
| ExportGattDescriptorInterface(descriptor); |
| } |
| |
| void GattInterfaceHandler::OnGattDescriptorRemoved( |
| const GattDescriptor& descriptor) { |
| const GattCharacteristic* characteristic = |
| descriptor.characteristic().value(); |
| const GattService* service = characteristic->service().value(); |
| |
| CHECK(service->HasOwner()); |
| |
| dbus::ObjectPath desc_path(ConvertDescriptorHandleToObjectPath( |
| service->device_address().value(), service->first_handle(), |
| characteristic->first_handle(), descriptor.handle())); |
| |
| VLOG(1) << "Unexporting a GATT descriptor object at " << desc_path.value(); |
| |
| exported_object_manager_wrapper_->RemoveExportedInterface( |
| desc_path, bluetooth_gatt_descriptor::kBluetoothGattDescriptorInterface); |
| } |
| |
| void GattInterfaceHandler::OnGattDescriptorChanged( |
| const GattDescriptor& descriptor) { |
| ExportGattDescriptorInterface(descriptor); |
| } |
| |
| void GattInterfaceHandler::AddGattCharacteristicMethodHandlers( |
| ExportedInterface* char_interface) { |
| CHECK(char_interface); |
| |
| char_interface->AddMethodHandlerWithMessage( |
| bluetooth_gatt_characteristic::kReadValue, |
| base::Bind(&GattInterfaceHandler::HandleCharacteristicReadValue, |
| base::Unretained(this))); |
| char_interface->AddMethodHandlerWithMessage( |
| bluetooth_gatt_characteristic::kWriteValue, |
| base::Bind(&GattInterfaceHandler::HandleCharacteristicWriteValue, |
| base::Unretained(this))); |
| char_interface->AddMethodHandlerWithMessage( |
| bluetooth_gatt_characteristic::kStartNotify, |
| base::Bind(&GattInterfaceHandler::HandleCharacteristicStartNotify, |
| base::Unretained(this))); |
| char_interface->AddMethodHandlerWithMessage( |
| bluetooth_gatt_characteristic::kStopNotify, |
| base::Bind(&GattInterfaceHandler::HandleCharacteristicStopNotify, |
| base::Unretained(this))); |
| char_interface->AddMethodHandlerWithMessage( |
| bluetooth_gatt_characteristic::kPrepareWriteValue, |
| base::Bind(&GattInterfaceHandler::HandleCharacteristicPrepareWriteValue, |
| base::Unretained(this))); |
| } |
| |
| void GattInterfaceHandler::AddGattDescriptorMethodHandlers( |
| ExportedInterface* desc_interface) { |
| CHECK(desc_interface); |
| |
| desc_interface->AddMethodHandlerWithMessage( |
| bluetooth_gatt_descriptor::kReadValue, |
| base::Bind(&GattInterfaceHandler::HandleDescriptorReadValue, |
| base::Unretained(this))); |
| desc_interface->AddMethodHandlerWithMessage( |
| bluetooth_gatt_descriptor::kWriteValue, |
| base::Bind(&GattInterfaceHandler::HandleDescriptorWriteValue, |
| base::Unretained(this))); |
| } |
| |
| void GattInterfaceHandler::ExportGattServiceProperties( |
| bool is_new, |
| ExportedInterface* service_interface, |
| const GattService& service) { |
| CHECK(service_interface); |
| |
| ExportDBusProperty(service_interface, bluetooth_gatt_service::kUUIDProperty, |
| service.uuid(), &CanonicalizeUuid, is_new); |
| ExportDBusProperty(service_interface, bluetooth_gatt_service::kDeviceProperty, |
| service.device_address(), |
| &ConvertDeviceAddressToObjectPath, is_new); |
| ExportDBusProperty(service_interface, |
| bluetooth_gatt_service::kPrimaryProperty, |
| service.primary(), is_new); |
| } |
| |
| void GattInterfaceHandler::ExportGattCharacteristicProperties( |
| bool is_new, |
| ExportedInterface* char_interface, |
| const GattCharacteristic& characteristic) { |
| CHECK(char_interface); |
| |
| ExportDBusProperty(char_interface, |
| bluetooth_gatt_characteristic::kUUIDProperty, |
| characteristic.uuid(), &CanonicalizeUuid, is_new); |
| ExportDBusProperty( |
| char_interface, bluetooth_gatt_characteristic::kServiceProperty, |
| characteristic.service(), &ConvertServiceToObjectPath, is_new); |
| |
| // GATT characteristic value property is optional, export only if the value |
| // is not empty for a new characteristic or there is an update. |
| if (!is_new || (is_new && !characteristic.value().value().empty())) { |
| ExportDBusProperty(char_interface, |
| bluetooth_gatt_characteristic::kValueProperty, |
| characteristic.value(), is_new); |
| } |
| |
| // TODO(mcchou): ConvertPropertiesToStrings only includes the properties |
| // which come along with the characteristic but not the extended properties. |
| // We need to parse the extended properties descriptor and present those in |
| // Flags as well. |
| ExportDBusProperty( |
| char_interface, bluetooth_gatt_characteristic::kFlagsProperty, |
| characteristic.properties(), &ConvertPropertiesToStrings, is_new); |
| |
| // GATT characteristic notifying property is optional, export only if |
| // characteristic properties contains notify and indicate bits. |
| uint8_t char_props = characteristic.properties().value(); |
| if (char_props & GattCharacteristicPropertyMask::NOTIFY || |
| char_props & GattCharacteristicPropertyMask::INDICATE) { |
| ExportDBusProperty( |
| char_interface, bluetooth_gatt_characteristic::kNotifyingProperty, |
| characteristic.notify_setting(), &ConvertNotifySettingToBool, is_new); |
| } |
| } |
| |
| void GattInterfaceHandler::ExportGattDescriptorProperties( |
| bool is_new, |
| ExportedInterface* desc_interface, |
| const GattDescriptor& descriptor) { |
| CHECK(desc_interface); |
| |
| ExportDBusProperty(desc_interface, bluetooth_gatt_descriptor::kUUIDProperty, |
| descriptor.uuid(), &CanonicalizeUuid, is_new); |
| ExportDBusProperty( |
| desc_interface, bluetooth_gatt_descriptor::kCharacteristicProperty, |
| descriptor.characteristic(), &ConvertCharToObjectPath, is_new); |
| |
| // GATT descriptor value property is optional, export only if the value is |
| // not empty for a new descriptor or there is an update. |
| if (!is_new || (is_new && !descriptor.value().value().empty())) { |
| ExportDBusProperty(desc_interface, |
| bluetooth_gatt_descriptor::kValueProperty, |
| descriptor.value(), is_new); |
| } |
| } |
| |
| void GattInterfaceHandler::ExportGattServiceInterface( |
| const GattService& service) { |
| CHECK(service.HasOwner()); |
| |
| bool is_new = false; |
| std::string device_address = service.device_address().value(); |
| dbus::ObjectPath service_path = |
| ConvertServiceHandleToObjectPath(device_address, service.first_handle()); |
| ExportedInterface* service_interface = |
| exported_object_manager_wrapper_->GetExportedInterface( |
| service_path, bluetooth_gatt_service::kBluetoothGattServiceInterface); |
| if (service_interface == nullptr) { |
| is_new = true; |
| |
| VLOG(1) << "Exporting a new GATT service object at " |
| << service_path.value(); |
| |
| exported_object_manager_wrapper_->AddExportedInterface( |
| service_path, bluetooth_gatt_service::kBluetoothGattServiceInterface, |
| base::Bind( |
| &ExportedObjectManagerWrapper::SetupStandardPropertyHandlers)); |
| service_interface = exported_object_manager_wrapper_->GetExportedInterface( |
| service_path, bluetooth_gatt_service::kBluetoothGattServiceInterface); |
| } else { |
| VLOG(2) << "Updating GATT service object at " << service_path.value(); |
| } |
| |
| ExportGattServiceProperties(is_new, service_interface, service); |
| |
| if (is_new) |
| service_interface->ExportAndBlock(); |
| } |
| |
| void GattInterfaceHandler::ExportGattCharacteristicInterface( |
| const GattCharacteristic& characteristic) { |
| const GattService* service = characteristic.service().value(); |
| CHECK(service->HasOwner()); |
| |
| bool is_new = false; |
| std::string device_address = service->device_address().value(); |
| dbus::ObjectPath char_path = ConvertCharacteristicHandleToObjectPath( |
| device_address, service->first_handle(), characteristic.first_handle()); |
| |
| ExportedInterface* char_interface = |
| exported_object_manager_wrapper_->GetExportedInterface( |
| char_path, |
| bluetooth_gatt_characteristic::kBluetoothGattCharacteristicInterface); |
| if (char_interface == nullptr) { |
| is_new = true; |
| |
| VLOG(1) << "Exporting a new GATT characteristic object at " |
| << char_path.value(); |
| |
| exported_object_manager_wrapper_->AddExportedInterface( |
| char_path, |
| bluetooth_gatt_characteristic::kBluetoothGattCharacteristicInterface, |
| base::Bind( |
| &ExportedObjectManagerWrapper::SetupStandardPropertyHandlers)); |
| char_interface = exported_object_manager_wrapper_->GetExportedInterface( |
| char_path, |
| bluetooth_gatt_characteristic::kBluetoothGattCharacteristicInterface); |
| |
| AddGattCharacteristicMethodHandlers(char_interface); |
| } else { |
| VLOG(2) << "Updating GATT characteristic object at " << char_path.value(); |
| } |
| |
| ExportGattCharacteristicProperties(is_new, char_interface, characteristic); |
| |
| if (is_new) |
| char_interface->ExportAndBlock(); |
| } |
| |
| void GattInterfaceHandler::ExportGattDescriptorInterface( |
| const GattDescriptor& descriptor) { |
| const GattCharacteristic* characteristic = |
| descriptor.characteristic().value(); |
| const GattService* service = characteristic->service().value(); |
| CHECK(service->HasOwner()); |
| |
| bool is_new = false; |
| std::string device_address = service->device_address().value(); |
| dbus::ObjectPath desc_path = ConvertDescriptorHandleToObjectPath( |
| device_address, service->first_handle(), characteristic->first_handle(), |
| descriptor.handle()); |
| |
| ExportedInterface* desc_interface = |
| exported_object_manager_wrapper_->GetExportedInterface( |
| desc_path, |
| bluetooth_gatt_descriptor::kBluetoothGattDescriptorInterface); |
| if (desc_interface == nullptr) { |
| is_new = true; |
| |
| VLOG(1) << "Exporting a new GATT descriptor object at " |
| << desc_path.value(); |
| |
| exported_object_manager_wrapper_->AddExportedInterface( |
| desc_path, bluetooth_gatt_descriptor::kBluetoothGattDescriptorInterface, |
| base::Bind( |
| &ExportedObjectManagerWrapper::SetupStandardPropertyHandlers)); |
| desc_interface = exported_object_manager_wrapper_->GetExportedInterface( |
| desc_path, |
| bluetooth_gatt_descriptor::kBluetoothGattDescriptorInterface); |
| |
| AddGattDescriptorMethodHandlers(desc_interface); |
| } else { |
| VLOG(2) << "Updating new GATT descriptor object at " << desc_path.value(); |
| } |
| |
| ExportGattDescriptorProperties(is_new, desc_interface, descriptor); |
| |
| if (is_new) |
| desc_interface->ExportAndBlock(); |
| } |
| |
| void GattInterfaceHandler::HandleCharacteristicReadValue( |
| std::unique_ptr< |
| brillo::dbus_utils::DBusMethodResponse<std::vector<uint8_t>>> response, |
| dbus::Message* message, |
| const brillo::VariantDictionary& options) { |
| CHECK(message); |
| |
| std::string device_address; |
| uint16_t service_handle = 0, char_handle = 0; |
| |
| uint16_t offset = |
| brillo::GetVariantValueOrDefault<uint16_t>(options, "offset"); |
| if (!ConvertCharacteristicObjectPathToHandles(&device_address, |
| &service_handle, &char_handle, |
| message->GetPath().value())) { |
| response->ReplyWithError(FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_gatt_characteristic::kErrorFailed, |
| "Invalid GATT characteristic object path"); |
| return; |
| } |
| |
| if (device_address.empty() || service_handle == kInvalidGattAttributeHandle || |
| char_handle == kInvalidGattAttributeHandle) { |
| response->ReplyWithError( |
| FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_gatt_characteristic::kErrorFailed, |
| "Invalid device address or invalid GATT characteristic handles"); |
| return; |
| } |
| |
| GattClientRequest request = { |
| .object_path = message->GetPath().value(), |
| .type = GattClientRequestType::READ_CHARACTERISTIC_VALUE, |
| .read_value_response = std::move(response), |
| }; |
| |
| auto transaction_id = gatt_->ReadCharacteristicValue( |
| device_address, service_handle, char_handle, offset, |
| base::Bind(&GattInterfaceHandler::OnReadCharacteristicValue, |
| weak_ptr_factory_.GetWeakPtr())); |
| if (transaction_id == kInvalidUniqueId) { |
| request.read_value_response->ReplyWithError( |
| FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_gatt_characteristic::kErrorFailed, ""); |
| return; |
| } |
| |
| VLOG(1) << "Reading a GATT characteristic value at " |
| << message->GetPath().value(); |
| |
| gatt_client_requests_.emplace(transaction_id, std::move(request)); |
| } |
| |
| void GattInterfaceHandler::HandleCharacteristicWriteValue( |
| std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<>> response, |
| dbus::Message* message) { |
| response->ReplyWithError(FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_gatt_characteristic::kErrorFailed, |
| "Not implemented"); |
| } |
| |
| void GattInterfaceHandler::HandleCharacteristicStartNotify( |
| std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<>> response, |
| dbus::Message* message) { |
| response->ReplyWithError(FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_gatt_characteristic::kErrorFailed, |
| "Not implemented"); |
| } |
| |
| void GattInterfaceHandler::HandleCharacteristicStopNotify( |
| std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<>> response, |
| dbus::Message* message) { |
| response->ReplyWithError(FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_gatt_characteristic::kErrorFailed, |
| "Not implemented"); |
| } |
| |
| void GattInterfaceHandler::HandleCharacteristicPrepareWriteValue( |
| std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<>> response, |
| dbus::Message* message) { |
| response->ReplyWithError(FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_gatt_characteristic::kErrorFailed, |
| "Not implemented"); |
| } |
| |
| void GattInterfaceHandler::HandleDescriptorReadValue( |
| std::unique_ptr< |
| brillo::dbus_utils::DBusMethodResponse<std::vector<uint8_t>>> response, |
| dbus::Message* message, |
| const brillo::VariantDictionary& options) { |
| CHECK(message); |
| |
| std::string device_address; |
| uint16_t service_handle = 0, char_handle = 0, desc_handle = 0; |
| |
| uint16_t offset = |
| brillo::GetVariantValueOrDefault<uint16_t>(options, "offset"); |
| if (!ConvertDescriptorObjectPathToHandles(&device_address, &service_handle, |
| &char_handle, &desc_handle, |
| message->GetPath().value())) { |
| response->ReplyWithError(FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_gatt_descriptor::kErrorFailed, |
| "Invalid GATT descriptor object path"); |
| return; |
| } |
| |
| if (device_address.empty() || service_handle == kInvalidGattAttributeHandle || |
| char_handle == kInvalidGattAttributeHandle || |
| desc_handle == kInvalidGattAttributeHandle) { |
| response->ReplyWithError( |
| FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_gatt_descriptor::kErrorFailed, |
| "Invalid device address or invalid GATT descriptor handles"); |
| return; |
| } |
| |
| GattClientRequest request = { |
| .object_path = message->GetPath().value(), |
| .type = GattClientRequestType::READ_DESCRIPTOR_VALUE, |
| .read_value_response = std::move(response), |
| }; |
| |
| auto transaction_id = gatt_->ReadDescriptorValue( |
| device_address, service_handle, char_handle, desc_handle, offset, |
| base::Bind(&GattInterfaceHandler::OnReadDescriptorValue, |
| weak_ptr_factory_.GetWeakPtr())); |
| if (transaction_id == kInvalidUniqueId) { |
| request.read_value_response->ReplyWithError( |
| FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_gatt_descriptor::kErrorFailed, ""); |
| return; |
| } |
| |
| VLOG(1) << "Reading a GATT descriptor value at " |
| << message->GetPath().value(); |
| |
| gatt_client_requests_.emplace(transaction_id, std::move(request)); |
| } |
| |
| void GattInterfaceHandler::HandleDescriptorWriteValue( |
| std::unique_ptr<brillo::dbus_utils::DBusMethodResponse<>> response, |
| dbus::Message* message) { |
| response->ReplyWithError(FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_gatt_descriptor::kErrorFailed, |
| "Not implemented"); |
| } |
| |
| void GattInterfaceHandler::OnReadCharacteristicValue( |
| UniqueId transaction_id, |
| const std::string& device_address, |
| uint16_t service_handle, |
| uint16_t char_handle, |
| GattClientOperationError error, |
| const std::vector<uint8_t>& value) { |
| auto request = gatt_client_requests_.find(transaction_id); |
| |
| CHECK(request != gatt_client_requests_.end()); |
| CHECK(request->second.type == |
| GattClientRequestType::READ_CHARACTERISTIC_VALUE); |
| CHECK(request->second.read_value_response != nullptr); |
| CHECK(request->second.object_path == |
| ConvertCharacteristicHandleToObjectPath(device_address, service_handle, |
| char_handle) |
| .value()); |
| |
| auto response = std::move(request->second.read_value_response); |
| |
| if (value.empty()) { |
| response->ReplyWithError(FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_gatt_characteristic::kErrorFailed, |
| "Empty value"); |
| gatt_client_requests_.erase(transaction_id); |
| return; |
| } |
| |
| std::string dbus_error; |
| std::string error_message; |
| ConvertGattClientOperationErrorToDBusError(&dbus_error, &error_message, |
| error); |
| if (error != GattClientOperationError::NONE) { |
| response->ReplyWithError(FROM_HERE, brillo::errors::dbus::kDomain, |
| dbus_error, error_message); |
| gatt_client_requests_.erase(transaction_id); |
| return; |
| } |
| |
| VLOG(1) << "Finished reading a GATT characteristic value at " |
| << request->second.object_path; |
| |
| gatt_client_requests_.erase(transaction_id); |
| response->Return(value); |
| } |
| |
| void GattInterfaceHandler::OnReadDescriptorValue( |
| UniqueId transaction_id, |
| const std::string& device_address, |
| uint16_t service_handle, |
| uint16_t char_handle, |
| uint16_t desc_handle, |
| GattClientOperationError error, |
| const std::vector<uint8_t>& value) { |
| auto request = gatt_client_requests_.find(transaction_id); |
| |
| CHECK(request != gatt_client_requests_.end()); |
| CHECK(request->second.type == GattClientRequestType::READ_DESCRIPTOR_VALUE); |
| CHECK(request->second.read_value_response != nullptr); |
| CHECK(request->second.object_path == |
| ConvertDescriptorHandleToObjectPath(device_address, service_handle, |
| char_handle, desc_handle) |
| .value()); |
| |
| auto response = std::move(request->second.read_value_response); |
| |
| if (value.empty()) { |
| response->ReplyWithError(FROM_HERE, brillo::errors::dbus::kDomain, |
| bluetooth_gatt_descriptor::kErrorFailed, |
| "Empty value"); |
| gatt_client_requests_.erase(transaction_id); |
| return; |
| } |
| |
| std::string dbus_error; |
| std::string error_message; |
| ConvertGattClientOperationErrorToDBusError(&dbus_error, &error_message, |
| error); |
| if (error != GattClientOperationError::NONE) { |
| response->ReplyWithError(FROM_HERE, brillo::errors::dbus::kDomain, |
| dbus_error, error_message); |
| gatt_client_requests_.erase(transaction_id); |
| return; |
| } |
| |
| VLOG(1) << "Finished reading a GATT descriptor value at " |
| << request->second.object_path; |
| |
| gatt_client_requests_.erase(transaction_id); |
| response->Return(value); |
| } |
| |
| } // namespace bluetooth |
