| // Copyright 2023 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "device/bluetooth/floss/bluetooth_local_gatt_descriptor_floss.h" |
| |
| #include "base/logging.h" |
| #include "base/memory/ptr_util.h" |
| #include "base/rand_util.h" |
| #include "base/strings/stringprintf.h" |
| #include "base/types/cxx23_to_underlying.h" |
| #include "device/bluetooth/floss/bluetooth_gatt_characteristic_floss.h" |
| #include "device/bluetooth/floss/floss_dbus_manager.h" |
| |
| namespace floss { |
| |
| // static |
| base::WeakPtr<BluetoothLocalGattDescriptorFloss> |
| BluetoothLocalGattDescriptorFloss::Create( |
| const device::BluetoothUUID& uuid, |
| device::BluetoothGattCharacteristic::Permissions permissions, |
| BluetoothLocalGattCharacteristicFloss* characteristic) { |
| const auto& [_, floss_permissions] = |
| BluetoothGattCharacteristicFloss::ConvertPropsAndPermsToFloss( |
| /*properties=*/0, static_cast<uint16_t>(permissions)); |
| auto* descriptor = new BluetoothLocalGattDescriptorFloss( |
| uuid, floss_permissions, characteristic); |
| auto weak_ptr = descriptor->weak_ptr_factory_.GetWeakPtr(); |
| weak_ptr->index_ = |
| characteristic->AddDescriptor(base::WrapUnique(descriptor)); |
| return weak_ptr; |
| } |
| |
| BluetoothLocalGattDescriptorFloss::BluetoothLocalGattDescriptorFloss( |
| const device::BluetoothUUID& uuid, |
| device::BluetoothGattCharacteristic::Permissions permissions, |
| BluetoothLocalGattCharacteristicFloss* characteristic) |
| : uuid_(uuid), |
| permissions_(permissions), |
| characteristic_(raw_ref<BluetoothLocalGattCharacteristicFloss>::from_ptr( |
| characteristic)), |
| client_instance_id_(characteristic_->service_->NewInstanceId()) {} |
| |
| BluetoothLocalGattDescriptorFloss::~BluetoothLocalGattDescriptorFloss() { |
| characteristic_->service_->RemoveServerObserverForHandle(floss_instance_id_); |
| } |
| |
| std::string BluetoothLocalGattDescriptorFloss::GetIdentifier() const { |
| return base::StringPrintf( |
| "%s-%s/%04x", |
| characteristic_->service_->GetAdapter()->GetAddress().c_str(), |
| GetUUID().value().c_str(), client_instance_id_); |
| } |
| |
| device::BluetoothUUID BluetoothLocalGattDescriptorFloss::GetUUID() const { |
| return uuid_; |
| } |
| |
| device::BluetoothGattCharacteristic::Permissions |
| BluetoothLocalGattDescriptorFloss::GetPermissions() const { |
| const auto& [_, perms] = |
| BluetoothGattCharacteristicFloss::ConvertPropsAndPermsFromFloss( |
| /*properties=*/0, permissions_); |
| return perms; |
| } |
| |
| device::BluetoothLocalGattCharacteristic* |
| BluetoothLocalGattDescriptorFloss::GetCharacteristic() const { |
| return &*characteristic_; |
| } |
| |
| GattDescriptor BluetoothLocalGattDescriptorFloss::ToGattDescriptor() { |
| GattDescriptor descriptor; |
| descriptor.uuid = uuid_; |
| descriptor.instance_id = floss_instance_id_; |
| descriptor.permissions = permissions_; |
| return descriptor; |
| } |
| |
| void BluetoothLocalGattDescriptorFloss::ResolveInstanceId( |
| const GattCharacteristic& characteristic) { |
| DCHECK(characteristic.descriptors[index_].uuid == GetUUID()); |
| floss_instance_id_ = characteristic.descriptors[index_].instance_id; |
| characteristic_->service_->AddServerObserverForHandle(floss_instance_id_, |
| this); |
| } |
| |
| void BluetoothLocalGattDescriptorFloss::GattServerDescriptorReadRequest( |
| std::string address, |
| int32_t request_id, |
| int32_t offset, |
| bool is_long, |
| int32_t handle) { |
| DCHECK(handle == floss_instance_id_); |
| |
| if (pending_request_.has_value()) { |
| LOG(ERROR) << __func__ << ": A request for device '" |
| << pending_request_.value().address << "' is already pending"; |
| FlossDBusManager::Get()->GetGattManagerClient()->SendResponse( |
| base::DoNothing(), address, request_id, GattStatus::kBusy, offset, |
| std::vector<uint8_t>()); |
| return; |
| } |
| |
| device::BluetoothLocalGattService::Delegate* delegate = |
| characteristic_->service_->delegate_; |
| if (!delegate) { |
| LOG(ERROR) << __func__ << ": No delegate for local GATT service"; |
| FlossDBusManager::Get()->GetGattManagerClient()->SendResponse( |
| base::DoNothing(), address, request_id, GattStatus::kError, offset, |
| std::vector<uint8_t>()); |
| return; |
| } |
| |
| pending_request_.emplace(GattRequest{address, request_id, offset}); |
| auto* device = characteristic_->service_->GetAdapter()->GetDevice(address); |
| BluetoothLocalGattDescriptor* descriptor = |
| static_cast<BluetoothLocalGattDescriptor*>(this); |
| |
| // This callback is expected to run, so run it if the client has not done so |
| // within the next second. |
| response_timer_.Start( |
| FROM_HERE, kResponseTimeout, |
| base::BindOnce(&BluetoothLocalGattDescriptorFloss::OnReadRequestCallback, |
| weak_ptr_factory_.GetWeakPtr(), request_id, |
| BluetoothGattServiceFloss::GattErrorCode::kFailed, |
| base::OwnedRef(std::vector<uint8_t>()))); |
| |
| delegate->OnDescriptorReadRequest( |
| device, descriptor, offset, |
| base::BindOnce(&BluetoothLocalGattDescriptorFloss::OnReadRequestCallback, |
| weak_ptr_factory_.GetWeakPtr(), request_id)); |
| } |
| |
| void BluetoothLocalGattDescriptorFloss::OnReadRequestCallback( |
| int32_t request_id, |
| std::optional<BluetoothGattServiceFloss::GattErrorCode> error_code, |
| const std::vector<uint8_t>& value) { |
| if (!pending_request_.has_value()) { |
| // If this check trips, we have already handled the request response. |
| LOG(ERROR) << __func__ << ": No pending read request for request with id " |
| << request_id; |
| return; |
| } |
| auto read_request = pending_request_.value(); |
| if (read_request.request_id != request_id) { |
| // This check may trip due to a stale (timed-out) request being belatedly |
| // responded to. |
| LOG(ERROR) << __func__ << ": Read request id mismatch. Expected: " |
| << read_request.request_id << ", Actual: " << request_id; |
| return; |
| } |
| response_timer_.Stop(); |
| |
| GattStatus status = error_code.has_value() |
| ? BluetoothGattServiceFloss::GattServiceErrorToStatus( |
| error_code.value()) |
| : GattStatus::kSuccess; |
| FlossDBusManager::Get()->GetGattManagerClient()->SendResponse( |
| base::DoNothing(), read_request.address, request_id, status, |
| read_request.offset, value); |
| pending_request_.reset(); |
| } |
| |
| void BluetoothLocalGattDescriptorFloss::GattServerDescriptorWriteRequest( |
| std::string address, |
| int32_t request_id, |
| int32_t offset, |
| int32_t length, |
| bool is_prepared_write, |
| bool needs_response, |
| int32_t handle, |
| std::vector<uint8_t> value) { |
| DCHECK(handle == floss_instance_id_); |
| |
| if (is_prepared_write) { |
| // TODO(b/329709266) - Support prepare write requests for descriptors |
| LOG(ERROR) << __func__ << ": Prepared write request not supported."; |
| if (needs_response) { |
| FlossDBusManager::Get()->GetGattManagerClient()->SendResponse( |
| base::DoNothing(), address, request_id, GattStatus::kReqNotSupported, |
| offset, value); |
| } |
| return; |
| } |
| |
| if (pending_request_.has_value()) { |
| LOG(ERROR) << __func__ << ": A request for device '" |
| << pending_request_.value().address << "' is already pending"; |
| if (needs_response) { |
| FlossDBusManager::Get()->GetGattManagerClient()->SendResponse( |
| base::DoNothing(), address, request_id, GattStatus::kBusy, offset, |
| value); |
| } |
| return; |
| } |
| |
| device::BluetoothLocalGattService::Delegate* delegate = |
| characteristic_->service_->delegate_; |
| if (!delegate) { |
| LOG(ERROR) << __func__ << ": No delegate for local GATT service"; |
| if (needs_response) { |
| FlossDBusManager::Get()->GetGattManagerClient()->SendResponse( |
| base::DoNothing(), address, request_id, GattStatus::kError, offset, |
| value); |
| } |
| return; |
| } |
| |
| if (GetUUID() == |
| BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid()) { |
| auto status = HandleCccDescriptor(address, value); |
| if (needs_response) { |
| FlossDBusManager::Get()->GetGattManagerClient()->SendResponse( |
| base::DoNothing(), address, request_id, status, offset, value); |
| } |
| return; |
| } |
| |
| pending_request_.emplace(GattRequest{address, request_id, offset}); |
| auto* device = characteristic_->service_->GetAdapter()->GetDevice(address); |
| BluetoothLocalGattDescriptor* descriptor = |
| static_cast<BluetoothLocalGattDescriptor*>(this); |
| |
| // This callback is expected to run, so run it if the client has not done so |
| // within the next second. |
| response_timer_.Start( |
| FROM_HERE, kResponseTimeout, |
| base::BindOnce(&BluetoothLocalGattDescriptorFloss::OnWriteRequestCallback, |
| weak_ptr_factory_.GetWeakPtr(), request_id, |
| base::OwnedRef(value), needs_response, /*success=*/false)); |
| |
| delegate->OnDescriptorWriteRequest( |
| device, descriptor, value, offset, |
| base::BindOnce(&BluetoothLocalGattDescriptorFloss::OnWriteRequestCallback, |
| weak_ptr_factory_.GetWeakPtr(), request_id, |
| base::OwnedRef(value), needs_response, |
| /*success=*/true), |
| base::BindOnce(&BluetoothLocalGattDescriptorFloss::OnWriteRequestCallback, |
| weak_ptr_factory_.GetWeakPtr(), request_id, |
| base::OwnedRef(value), needs_response, |
| /*success=*/false)); |
| } |
| |
| void BluetoothLocalGattDescriptorFloss::OnWriteRequestCallback( |
| int32_t request_id, |
| std::vector<uint8_t>& value, |
| bool needs_response, |
| bool success) { |
| if (!pending_request_.has_value()) { |
| // If this check trips, we have already handled the request response. |
| LOG(ERROR) << __func__ << ": No pending write request for request with id " |
| << request_id; |
| return; |
| } |
| auto write_request = pending_request_.value(); |
| if (write_request.request_id != request_id) { |
| // This check may trip due to a stale (timed-out) request being belatedly |
| // responded to. |
| LOG(ERROR) << __func__ << ": Write request id mismatch. Expected: " |
| << write_request.request_id << ", Actual: " << request_id; |
| return; |
| } |
| response_timer_.Stop(); |
| |
| if (!needs_response) { |
| pending_request_.reset(); |
| return; |
| } |
| GattStatus status = success ? GattStatus::kSuccess : GattStatus::kError; |
| FlossDBusManager::Get()->GetGattManagerClient()->SendResponse( |
| base::DoNothing(), write_request.address, write_request.request_id, |
| status, write_request.offset, value); |
| pending_request_.reset(); |
| } |
| |
| GattStatus BluetoothLocalGattDescriptorFloss::HandleCccDescriptor( |
| std::string address, |
| std::vector<uint8_t>& value) { |
| device::BluetoothLocalGattService::Delegate* delegate = |
| characteristic_->service_->delegate_; |
| auto* device = characteristic_->service_->GetAdapter()->GetDevice(address); |
| device::BluetoothLocalGattCharacteristic* characteristic = |
| static_cast<device::BluetoothLocalGattCharacteristic*>( |
| &characteristic_.get()); |
| |
| if (value.size() != 2) { |
| LOG(ERROR) << __func__ << ": Value is not a valid CccdValueType"; |
| return GattStatus::kCccCfgErr; |
| } |
| uint16_t notification_type = (value[1] << 8) + value[0]; |
| |
| auto properties = characteristic_->GetProperties(); |
| switch (notification_type) { |
| case base::to_underlying( |
| device::BluetoothGattCharacteristic::NotificationType::kNone): |
| cccd_type_ = device::BluetoothGattCharacteristic::NotificationType::kNone; |
| delegate->OnNotificationsStop(device, characteristic); |
| break; |
| case base::to_underlying( |
| device::BluetoothGattCharacteristic::NotificationType::kNotification): |
| if (!(properties & |
| device::BluetoothGattCharacteristic::PROPERTY_NOTIFY)) { |
| LOG(WARNING) << __func__ << ": Parent characteristic (uuid: " |
| << characteristic_->GetUUID() |
| << ") does not have the necessary properties to notify " |
| "(properties: " |
| << properties << ")"; |
| return GattStatus::kCccCfgErr; |
| } |
| cccd_type_ = |
| device::BluetoothGattCharacteristic::NotificationType::kNotification; |
| delegate->OnNotificationsStart(device, cccd_type_, characteristic); |
| break; |
| case base::to_underlying( |
| device::BluetoothGattCharacteristic::NotificationType::kIndication): |
| if (!(properties & |
| device::BluetoothGattCharacteristic::PROPERTY_INDICATE)) { |
| LOG(WARNING) << __func__ << ": Parent characteristic (uuid: " |
| << characteristic_->GetUUID() |
| << ") does not have the necessary properties to indicate " |
| "(properties: " |
| << properties << ")"; |
| return GattStatus::kCccCfgErr; |
| } |
| cccd_type_ = |
| device::BluetoothGattCharacteristic::NotificationType::kIndication; |
| delegate->OnNotificationsStart(device, cccd_type_, characteristic); |
| break; |
| default: |
| LOG(WARNING) << __func__ << ": Value '" << notification_type |
| << "' is not a valid CccdValueType"; |
| return GattStatus::kCccCfgErr; |
| } |
| return GattStatus::kSuccess; |
| } |
| |
| } // namespace floss |
