Implement support for the OOB Pairing APIs.

chromeos/dbus/bluetooth_adapter_client.cc

 // Copyright (c) 2012 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 "chromeos/dbus/bluetooth_adapter_client.h"
 
 #include <map>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "chromeos/dbus/bluetooth_device_client.h"
 #include "chromeos/dbus/bluetooth_manager_client.h"
+#include "chromeos/dbus/bluetooth_out_of_band_pairing_data.h"
 #include "chromeos/dbus/bluetooth_property.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 BluetoothAdapterClient::Properties::Properties(dbus::ObjectProxy* object_proxy,
@@ skipping 267 matching lines @@
 
     dbus::ObjectProxy* object_proxy = GetObjectProxy(object_path);
 
     object_proxy->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&BluetoothAdapterClientImpl::OnCreateDevice,
                    weak_ptr_factory_.GetWeakPtr(), object_path, callback));
   }
 
+  // BluetoothAdapterClient override.
+  virtual void ReadLocalOutOfBandPairingData(
+      const dbus::ObjectPath& object_path,
+      const OutOfBandPairingDataCallback& callback) {
+    dbus::MethodCall method_call(
+        bluetooth_outofband::kBluetoothOutOfBandInterface,
+        bluetooth_outofband::kReadLocalData);
+
+    dbus::ObjectProxy* object_proxy = GetObjectProxy(object_path);
+
+    object_proxy->CallMethod(
+        &method_call,
+        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&BluetoothAdapterClientImpl::OnReadLocalData,
+                   weak_ptr_factory_.GetWeakPtr(), object_path, callback));
+  }
+
+  // BluetoothAdapterClient override.
+  virtual void AddRemoteOutOfBandPairingData(
+      const dbus::ObjectPath& object_path,
+      const std::string& address,
+      const OutOfBandPairingData& data,
+      const AdapterCallback& callback) {
+    dbus::MethodCall method_call(
+        bluetooth_outofband::kBluetoothOutOfBandInterface,
+        bluetooth_outofband::kAddRemoteData);
+
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendString(address);
+    writer.AppendArrayOfBytes(data.hash, kOutOfBandPairingDataSize);
+    writer.AppendArrayOfBytes(data.randomizer, kOutOfBandPairingDataSize);
+
+    dbus::ObjectProxy* object_proxy = GetObjectProxy(object_path);
+
+    object_proxy->CallMethod(
+        &method_call,
+        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&BluetoothAdapterClientImpl::ResponseToAdapterCallback,
+                   weak_ptr_factory_.GetWeakPtr(), object_path, callback));
+  }
+
+  virtual void RemoveRemoteOutOfBandPairingData(
+      const dbus::ObjectPath& object_path,
+      const std::string& address,
+      const AdapterCallback& callback) {
+    dbus::MethodCall method_call(
+        bluetooth_outofband::kBluetoothOutOfBandInterface,
+        bluetooth_outofband::kRemoveRemoteData);
+
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendString(address);
+
+    dbus::ObjectProxy* object_proxy = GetObjectProxy(object_path);
+
+    object_proxy->CallMethod(
+        &method_call,
+        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&BluetoothAdapterClientImpl::ResponseToAdapterCallback,
+                   weak_ptr_factory_.GetWeakPtr(), object_path, callback));
+  }
+
  private:
   // We maintain a collection of dbus object proxies and properties structures
   // for each adapter.
   typedef std::pair<dbus::ObjectProxy*, Properties*> Object;
   typedef std::map<const dbus::ObjectPath, Object> ObjectMap;
   ObjectMap object_map_;
 
   // BluetoothManagerClient::Observer override.
   virtual void AdapterAdded(const dbus::ObjectPath& object_path) OVERRIDE {
   }
@@ skipping 289 matching lines @@
         success = true;
       }
     } else {
       LOG(WARNING) << "Failed to create device.";
     }
 
     // Notify client.
     callback.Run(device_path, success);
   }
 
+  // Called when a response from ReadLocalOutOfBandPairingData() is received.
+  void OnReadLocalData(const dbus::ObjectPath& object_path,
+                       const OutOfBandPairingDataCallback& callback,
+                       dbus::Response* response) {
+    bool success = false;
+    OutOfBandPairingData data;
+    if (response != NULL) {
+      dbus::MessageReader reader(response);
+      uint8_t* bytes;
+      size_t length = kOutOfBandPairingDataSize;
+      if (reader.PopArrayOfBytes(&bytes, &length)) {
+        if (length == kOutOfBandPairingDataSize) {
+          memcpy(&data.hash, bytes, length);
+          if (reader.PopArrayOfBytes(&bytes, &length)) {
+            if (length == kOutOfBandPairingDataSize) {
+              memcpy(&data.randomizer, bytes, length);
+              success = true;
+            }
+          }
+        }
+      }
+    }
+    callback.Run(data, success);
+  }
+
+  // Translates a dbus::Response to an AdapterCallback by calling |callback|
+  // with |object_path| and assuming success if |response| is not NULL.
+  void ResponseToAdapterCallback(const dbus::ObjectPath& object_path,
+                                 const AdapterCallback& callback,
+                                 dbus::Response* response) {
+    callback.Run(object_path, response != NULL);
+  }
+
   // Called when a response for CreatePairedDevice() is received.
   void OnCreatePairedDevice(const dbus::ObjectPath& object_path,
                             const DeviceCallback& callback,
                             dbus::Response* response) {
     // Parse response.
     bool success = false;
     dbus::ObjectPath device_path;
     if (response != NULL) {
       dbus::MessageReader reader(response);
       if (!reader.PopObjectPath(&device_path)) {
@@ skipping 161 matching lines @@
   }
 
   // BluetoothAdapterClient override.
   virtual void UnregisterAgent(const dbus::ObjectPath& object_path,
                                const dbus::ObjectPath& agent_path,
                                const AdapterCallback& callback) OVERRIDE {
     VLOG(1) << "UnregisterAgent: " << object_path.value()
             << " " << agent_path.value();
     callback.Run(object_path, false);
   }
+
+  virtual void ReadLocalOutOfBandPairingData(
+      const dbus::ObjectPath& object_path,
+      const OutOfBandPairingDataCallback& callback) {
+    VLOG(1) << "ReadLocalOutOfBandPairingData: " << object_path.value();
+    OutOfBandPairingData data;
+    callback.Run(data, false);
+  }
+
+  virtual void AddRemoteOutOfBandPairingData(
+      const dbus::ObjectPath& object_path,
+      const std::string& address,
+      const OutOfBandPairingData& data,
+      const AdapterCallback& callback) {
+    VLOG(1) << "AddRemoteData: " << object_path.value();
+    callback.Run(object_path, false);
+  }
+
+  virtual void RemoveRemoteOutOfBandPairingData(
+      const dbus::ObjectPath& object_path,
+      const std::string& address,
+      const AdapterCallback& callback) {
+    VLOG(1) << "RemoveRemoteData: " << object_path.value();
+    callback.Run(object_path, false);
+  }
 };
 
 BluetoothAdapterClient::BluetoothAdapterClient() {
 }
 
 BluetoothAdapterClient::~BluetoothAdapterClient() {
 }
 
 BluetoothAdapterClient* BluetoothAdapterClient::Create(
     DBusClientImplementationType type,
     dbus::Bus* bus,
     BluetoothManagerClient* manager_client) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new BluetoothAdapterClientImpl(bus, manager_client);
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new BluetoothAdapterClientStubImpl();
 }
 
 }  // namespace chromeos