Bluetooth: D-Bus client interface for org.bluez.Input1

chromeos/dbus/fake_bluetooth_device_client.cc

 // Copyright (c) 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 "chromeos/dbus/fake_bluetooth_device_client.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/time.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_bluetooth_adapter_client.h"
 #include "chromeos/dbus/fake_bluetooth_agent_manager_client.h"
 #include "chromeos/dbus/fake_bluetooth_agent_service_provider.h"
+#include "chromeos/dbus/fake_bluetooth_input_client.h"
 #include "dbus/object_path.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace {
 
 // Default interval between simulated events.
 const int kSimulationIntervalMs = 750;
 
 }
 
@@ skipping 185 matching lines @@
              object_path == dbus::ObjectPath(kMicrosoftMousePath)) {
     // Must not be paired
     error_callback.Run(bluetooth_adapter::kErrorFailed,
                        "Connection fails while paired");
     return;
   }
 
   // The device can be connected.
   properties->connected.ReplaceValue(true);
 
+  AddInputDeviceIfNeeded(object_path, properties);
+
   callback.Run();
   properties->NotifyPropertyChanged(properties->connected.name());
 }
 
 void FakeBluetoothDeviceClient::Disconnect(
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   VLOG(1) << "Disconnect: " << object_path.value();
   Properties* properties = GetProperties(object_path);
@@ skipping 169 matching lines @@
       std::find(device_list_.begin(), device_list_.end(), device_path);
   if (listiter == device_list_.end())
     return;
 
   PropertiesMap::iterator iter = properties_map_.find(device_path);
   Properties* properties = iter->second;
 
   VLOG(1) << "removing device: " << properties->alias.value();
   device_list_.erase(listiter);
 
+  // Remove the Input interface if it exists. This should be called before the
+  // ExperimentalBluetoothDeviceClient::Observer::DeviceRemoved because it
+  // deletes the BluetoothDeviceExperimentalChromeOS object, including the
+  // device_path referenced here.
+  FakeBluetoothInputClient* fake_bluetooth_input_client =
+      static_cast<FakeBluetoothInputClient*>(
+          DBusThreadManager::Get()->GetExperimentalBluetoothInputClient());
+  fake_bluetooth_input_client->RemoveInputDevice(device_path);
+
   FOR_EACH_OBSERVER(ExperimentalBluetoothDeviceClient::Observer, observers_,
                     DeviceRemoved(device_path));
 
   delete properties;
   properties_map_.erase(iter);
 }
 
 void FakeBluetoothDeviceClient::OnPropertyChanged(
     const dbus::ObjectPath& object_path,
     const std::string& property_name) {
@@ skipping 195 matching lines @@
   if (pairing_cancelled_) {
     pairing_cancelled_ = false;
 
     error_callback.Run(bluetooth_adapter::kErrorAuthenticationCanceled,
                        "Cancaled");
   } else {
     Properties* properties = GetProperties(object_path);
 
     properties->paired.ReplaceValue(true);
 
+    AddInputDeviceIfNeeded(object_path, properties);
+
     callback.Run();
     properties->NotifyPropertyChanged(properties->paired.name());
   }
 }
 
 void FakeBluetoothDeviceClient::TimeoutSimulatedPairing(
     const dbus::ObjectPath& object_path,
     const ErrorCallback& error_callback) {
   VLOG(1) << "TimeoutSimulatedPairing: " << object_path.value();
 
@@ skipping 12 matching lines @@
 
 void FakeBluetoothDeviceClient::RejectSimulatedPairing(
     const dbus::ObjectPath& object_path,
     const ErrorCallback& error_callback) {
   VLOG(1) << "RejectSimulatedPairing: " << object_path.value();
 
   error_callback.Run(bluetooth_adapter::kErrorAuthenticationRejected,
                      "Rejected");
 }
 
+void FakeBluetoothDeviceClient::AddInputDeviceIfNeeded(
+    const dbus::ObjectPath& object_path,
+    Properties* properties) {
+  // If the paired device is a HID device based on it's bluetooth class,
+  // simulate the Input interface.
+  FakeBluetoothInputClient* fake_bluetooth_input_client =
+      static_cast<FakeBluetoothInputClient*>(
+          DBusThreadManager::Get()->GetExperimentalBluetoothInputClient());
+
+  if ((properties->bluetooth_class.value() & 0x001f03) == 0x000500) {
+    std::vector<std::string> uuids = properties->uuids.value();
+    if (std::find(uuids.begin(), uuids.end(),
+        "00001124-0000-1000-8000-00805f9b34fb") == uuids.end()) {
+      uuids.push_back("00001124-0000-1000-8000-00805f9b34fb");
+      properties->uuids.ReplaceValue(uuids);
+      fake_bluetooth_input_client->AddInputDevice(object_path);
+    }
+  }
+}
+
 void FakeBluetoothDeviceClient::PinCodeCallback(
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback,
     ExperimentalBluetoothAgentServiceProvider::Delegate::Status status,
     const std::string& pincode) {
   VLOG(1) << "PinCodeCallback: " << object_path.value();
 
   if (status == ExperimentalBluetoothAgentServiceProvider::Delegate::SUCCESS) {
     MessageLoop::current()->PostDelayedTask(
@@ skipping 125 matching lines @@
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
                    base::Unretained(this),
                    object_path, callback, error_callback),
         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 
   }
 }
 
 }  // namespace chromeos