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 377 matching lines @@
 
   PropertiesMap::iterator iter = properties_map_.find(device_path);
   Properties* properties = iter->second;
 
   VLOG(1) << "removing device: " << properties->alias.value();
   device_list_.erase(listiter);
 
   FOR_EACH_OBSERVER(ExperimentalBluetoothDeviceClient::Observer, observers_,
                     DeviceRemoved(device_path));
 
+  // Remove the Input interface if it exists.
+  FakeBluetoothInputClient* fake_bluetooth_input_client =
+      static_cast<FakeBluetoothInputClient*>(
+          DBusThreadManager::Get()->GetExperimentalBluetoothInputClient());
+  fake_bluetooth_input_client->RemoveInputDevice(device_path);
+
   delete properties;
   properties_map_.erase(iter);
 }
 
 void FakeBluetoothDeviceClient::OnPropertyChanged(
     const dbus::ObjectPath& object_path,
     const std::string& property_name) {
   FOR_EACH_OBSERVER(ExperimentalBluetoothDeviceClient::Observer, observers_,
                     DevicePropertyChanged(object_path, property_name));
 }
@@ skipping 192 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);
 
+    // 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);
+      }
+    }

[keybuk, 2013/04/18 22:37:44]

This also needs to be run in the Connect() function for the Microsoft Mouse

[deymo, 2013/04/18 23:21:02]

CompleteSimulatedPairing is called also for the Microsoft Mouse.

[keybuk, 2013/04/18 23:45:09]

It is, but for the "test a connect failing after pairing" case

It's tested separately with just Connect(), in which case this won't be called

[deymo, 2013/04/19 01:23:22]

Done.

+
     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 157 matching lines @@
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
                    base::Unretained(this),
                    object_path, callback, error_callback),
         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 
   }
 }
 
 }  // namespace chromeos