Add implementation for parsing device info in read/write attribute calls.

device/bluetooth/dbus/bluetooth_gatt_descriptor_service_provider_impl.cc

 // Copyright 2016 The Chromium 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 "device/bluetooth/dbus/bluetooth_gatt_descriptor_service_provider_impl.h"
 
 #include <cstddef>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
+#include "device/bluetooth/dbus/bluetooth_gatt_attribute_helpers.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace bluez {
 
 namespace {
 
 const char kErrorInvalidArgs[] = "org.freedesktop.DBus.Error.InvalidArgs";
 const char kErrorPropertyReadOnly[] =
     "org.freedesktop.DBus.Error.PropertyReadOnly";
 const char kErrorFailed[] = "org.freedesktop.DBus.Error.Failed";
@@ skipping 45 matching lines @@
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnExported,
                  weak_ptr_factory_.GetWeakPtr()));
 
   exported_object_->ExportMethod(
       dbus::kDBusPropertiesInterface, dbus::kDBusPropertiesGetAll,
       base::Bind(&BluetoothGattDescriptorServiceProviderImpl::GetAll,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnExported,
                  weak_ptr_factory_.GetWeakPtr()));
+
+  // org.bluez.GattDescriptor1 interface:
+  exported_object_->ExportMethod(
+      bluetooth_gatt_descriptor::kBluetoothGattDescriptorInterface,
+      bluetooth_gatt_descriptor::kReadValue,
+      base::Bind(&BluetoothGattDescriptorServiceProviderImpl::ReadValue,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnExported,
+                 weak_ptr_factory_.GetWeakPtr()));
+  exported_object_->ExportMethod(
+      bluetooth_gatt_descriptor::kBluetoothGattDescriptorInterface,
+      bluetooth_gatt_descriptor::kWriteValue,
+      base::Bind(&BluetoothGattDescriptorServiceProviderImpl::WriteValue,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnExported,
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 BluetoothGattDescriptorServiceProviderImpl::
     ~BluetoothGattDescriptorServiceProviderImpl() {
   VLOG(1) << "Cleaning up Bluetooth GATT characteristic descriptor: "
           << object_path_.value();
   if (bus_)
     bus_->UnregisterExportedObject(object_path_);
 }
 
@@ skipping 133 matching lines @@
     return;
   }
 
   std::unique_ptr<dbus::Response> response =
       dbus::Response::FromMethodCall(method_call);
   dbus::MessageWriter writer(response.get());
   WriteProperties(&writer);
   response_sender.Run(std::move(response));
 }
 
+void BluetoothGattDescriptorServiceProviderImpl::ReadValue(
+    dbus::MethodCall* method_call,
+    dbus::ExportedObject::ResponseSender response_sender) {
+  VLOG(3) << "BluetoothGattDescriptorServiceProvider::ReadValue: "
+          << object_path_.value();
+  DCHECK(OnOriginThread());
+
+  dbus::MessageReader reader(method_call);
+  dbus::ObjectPath device_path = ReadDevicePath(&reader);
+  if (device_path.value().empty()) {
+    LOG(WARNING) << "ReadValue called with incorrect parameters: "
+                 << method_call->ToString();
+    // Continue on with an empty device path. This will return a null device to
+    // the delegate, which should know how to handle it.
+  }
+
+  DCHECK(delegate_);
+  delegate_->GetValue(
+      device_path,
+      base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnReadValue,
+                 weak_ptr_factory_.GetWeakPtr(), method_call, response_sender),
+      base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnFailure,
+                 weak_ptr_factory_.GetWeakPtr(), method_call, response_sender));
+}
+
+void BluetoothGattDescriptorServiceProviderImpl::WriteValue(
+    dbus::MethodCall* method_call,
+    dbus::ExportedObject::ResponseSender response_sender) {
+  VLOG(3) << "BluetoothGattDescriptorServiceProvider::WriteValue: "
+          << object_path_.value();
+  DCHECK(OnOriginThread());
+
+  dbus::MessageReader reader(method_call);
+  const uint8_t* bytes = NULL;
+  size_t length = 0;
+
+  std::vector<uint8_t> value;
+  if (!reader.PopArrayOfBytes(&bytes, &length)) {
+    LOG(WARNING) << "Error reading value parameter. WriteValue called with "
+                    "incorrect parameters: "
+                 << method_call->ToString();
+  }
+  if (bytes)
+    value.assign(bytes, bytes + length);
+
+  dbus::ObjectPath device_path = ReadDevicePath(&reader);
+  if (device_path.value().empty()) {
+    LOG(WARNING) << "WriteValue called with incorrect parameters: "
+                 << method_call->ToString();
+    // Continue on with an empty device path. This will return a null device to
+    // the delegate, which should know how to handle it.
+  }
+
+  DCHECK(delegate_);
+  delegate_->SetValue(
+      device_path, value,
+      base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnWriteValue,
+                 weak_ptr_factory_.GetWeakPtr(), method_call, response_sender),
+      base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnFailure,
+                 weak_ptr_factory_.GetWeakPtr(), method_call, response_sender));
+}
+
 void BluetoothGattDescriptorServiceProviderImpl::OnExported(
     const std::string& interface_name,
     const std::string& method_name,
     bool success) {
   LOG_IF(WARNING, !success) << "Failed to export " << interface_name << "."
                             << method_name;
 }
 
+void BluetoothGattDescriptorServiceProviderImpl::OnReadValue(
+    dbus::MethodCall* method_call,
+    dbus::ExportedObject::ResponseSender response_sender,
+    const std::vector<uint8_t>& value) {
+  VLOG(3) << "Descriptor value obtained from delegate. Responding to "
+             "ReadValue.";
+
+  std::unique_ptr<dbus::Response> response =
+      dbus::Response::FromMethodCall(method_call);
+  dbus::MessageWriter writer(response.get());
+  writer.AppendArrayOfBytes(value.data(), value.size());
+  response_sender.Run(std::move(response));
+}
+
+void BluetoothGattDescriptorServiceProviderImpl::OnWriteValue(
+    dbus::MethodCall* method_call,
+    dbus::ExportedObject::ResponseSender response_sender) {
+  VLOG(3) << "Responding to WriteValue.";
+
+  std::unique_ptr<dbus::Response> response =
+      dbus::Response::FromMethodCall(method_call);
+  response_sender.Run(std::move(response));
+}
+
 void BluetoothGattDescriptorServiceProviderImpl::WriteProperties(
     dbus::MessageWriter* writer) {
   dbus::MessageWriter array_writer(NULL);
   dbus::MessageWriter dict_entry_writer(NULL);
   dbus::MessageWriter variant_writer(NULL);
 
   writer->OpenArray("{sv}", &array_writer);
 
   // UUID:
   array_writer.OpenDictEntry(&dict_entry_writer);
@@ skipping 28 matching lines @@
           method_call, kErrorFailed, "Failed to get/set descriptor value.");
   response_sender.Run(std::move(error_response));
 }
 
 const dbus::ObjectPath&
 BluetoothGattDescriptorServiceProviderImpl::object_path() const {
   return object_path_;
 }
 
 }  // namespace bluez