BlueZ + DBus implementations of create/remove service record functions.

device/bluetooth/dbus/bluetooth_adapter_client.cc

 // Copyright 2013 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_adapter_client.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
-#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "base/observer_list.h"
+#include "base/values.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_manager.h"
-#include "dbus/object_proxy.h"
+#include "dbus/values_util.h"
+#include "device/bluetooth/bluez/bluetooth_service_attribute_value_bluez.h"
+#include "device/bluetooth/bluez/bluetooth_service_record_bluez.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace bluez {
 
+namespace {
+
+void WriteAttribute(dbus::MessageWriter* writer,
+                    const BluetoothServiceAttributeValueBlueZ& attribute) {
+  dbus::MessageWriter struct_writer(nullptr);
+  writer->OpenStruct(&struct_writer);
+  struct_writer.AppendByte(attribute.get_type());
+  struct_writer.AppendUint32(attribute.get_size());
+
+  if (attribute.get_type() != BluetoothServiceAttributeValueBlueZ::SEQUENCE) {
+    CHECK(attribute.get_value().value);
+    dbus::AppendValueDataAsVariant(&struct_writer,
+                                   *attribute.get_value().value);
+  } else {
+    dbus::MessageWriter array_writer(nullptr);
+    struct_writer.OpenArray("v", &array_writer);
+    for (const auto& v : *attribute.get_value().sequence)
+      WriteAttribute(&array_writer, v);
+    struct_writer.CloseContainer(&array_writer);
+  }
+  writer->CloseContainer(&struct_writer);
+}
+}
+
 BluetoothAdapterClient::DiscoveryFilter::DiscoveryFilter() {}
 
 BluetoothAdapterClient::DiscoveryFilter::~DiscoveryFilter() {}
 
 void BluetoothAdapterClient::DiscoveryFilter::CopyFrom(
     const DiscoveryFilter& filter) {
   if (filter.rssi.get())
     rssi.reset(new int16_t(*filter.rssi));
   else
     rssi.reset();
@@ skipping 232 matching lines @@
     writer.CloseContainer(&dict_writer);
 
     object_proxy->CallMethodWithErrorCallback(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&BluetoothAdapterClientImpl::OnSuccess,
                    weak_ptr_factory_.GetWeakPtr(), callback),
         base::Bind(&BluetoothAdapterClientImpl::OnError,
                    weak_ptr_factory_.GetWeakPtr(), error_callback));
   }
 
+  // BluetoothAdapterClient override.
+  void CreateServiceRecord(const dbus::ObjectPath& object_path,
+                           const bluez::BluetoothServiceRecordBlueZ& record,
+                           const ServiceRecordCallback& callback,
+                           const ErrorCallback& error_callback) override {
+    dbus::MethodCall method_call(bluetooth_adapter::kBluetoothAdapterInterface,
+                                 bluetooth_adapter::kCreateServiceRecord);
+
+    dbus::MessageWriter writer(&method_call);
+    dbus::MessageWriter dict_entry_writer(nullptr);
+    for (auto attribute_id : record.GetAttributeIds()) {
+      writer.OpenDictEntry(&dict_entry_writer);
+      dict_entry_writer.AppendUint16(attribute_id);
+      BluetoothServiceAttributeValueBlueZ::ValueType value;
+      value.value = nullptr;
+      const BluetoothServiceAttributeValueBlueZ& attribute =
+          record.GetAttributeValue(attribute_id);
+      WriteAttribute(&dict_entry_writer, attribute);
+    }
+
+    dbus::ObjectProxy* object_proxy =
+        object_manager_->GetObjectProxy(object_path);
+    if (!object_proxy) {
+      error_callback.Run(kUnknownAdapterError, "");
+      return;
+    }
+
+    object_proxy->CallMethodWithErrorCallback(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&BluetoothAdapterClientImpl::OnCreateServiceRecord,
+                   weak_ptr_factory_.GetWeakPtr(), callback),
+        base::Bind(&BluetoothAdapterClientImpl::OnError,
+                   weak_ptr_factory_.GetWeakPtr(), error_callback));
+  }
+
+  // BluetoothAdapterClient override.
+  void RemoveServiceRecord(const dbus::ObjectPath& object_path,
+                           uint32_t handle,
+                           const base::Closure& callback,
+                           const ErrorCallback& error_callback) override {
+    dbus::MethodCall method_call(bluetooth_adapter::kBluetoothAdapterInterface,
+                                 bluetooth_adapter::kRemoveServiceRecord);
+
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendUint32(handle);
+    dbus::ObjectProxy* object_proxy =
+        object_manager_->GetObjectProxy(object_path);
+    if (!object_proxy) {
+      error_callback.Run(kUnknownAdapterError, "");
+      return;
+    }
+
+    object_proxy->CallMethodWithErrorCallback(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&BluetoothAdapterClientImpl::OnSuccess,
+                   weak_ptr_factory_.GetWeakPtr(), callback),
+        base::Bind(&BluetoothAdapterClientImpl::OnError,
+                   weak_ptr_factory_.GetWeakPtr(), error_callback));
+  }
+
  protected:
   void Init(dbus::Bus* bus) override {
     object_manager_ = bus->GetObjectManager(
         bluetooth_object_manager::kBluetoothObjectManagerServiceName,
         dbus::ObjectPath(
             bluetooth_object_manager::kBluetoothObjectManagerServicePath));
     object_manager_->RegisterInterface(
         bluetooth_adapter::kBluetoothAdapterInterface, this);
   }
 
@@ skipping 17 matching lines @@
   // Called by dbus::PropertySet when a property value is changed,
   // either by result of a signal or response to a GetAll() or Get()
   // call. Informs observers.
   void OnPropertyChanged(const dbus::ObjectPath& object_path,
                          const std::string& property_name) {
     FOR_EACH_OBSERVER(BluetoothAdapterClient::Observer, observers_,
                       AdapterPropertyChanged(object_path, property_name));
   }
 
   // Called when a response for successful method call is received.
+  void OnCreateServiceRecord(const ServiceRecordCallback& callback,
+                             dbus::Response* response) {
+    DCHECK(response);
+    dbus::MessageReader reader(response);
+    uint32_t handle = 0;
+    if (!reader.PopUint32(&handle))
+      LOG(ERROR) << "Invalid response from CreateServiceRecord.";
+    callback.Run(handle);
+  }
+
+  // Called when a response for successful method call is received.
   void OnSuccess(const base::Closure& callback, dbus::Response* response) {
     DCHECK(response);
     callback.Run();
   }
 
   // Called when a response for a failed method call is received.
   void OnError(const ErrorCallback& error_callback,
                dbus::ErrorResponse* response) {
     // Error response has optional error message argument.
     std::string error_name;
@@ skipping 25 matching lines @@
 
 BluetoothAdapterClient::BluetoothAdapterClient() {}
 
 BluetoothAdapterClient::~BluetoothAdapterClient() {}
 
 BluetoothAdapterClient* BluetoothAdapterClient::Create() {
   return new BluetoothAdapterClientImpl;
 }
 
 }  // namespace bluez