| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chromeos/dbus/fake_bluetooth_device_client.h" | |
| 6 | |
| 7 #include <fcntl.h> | |
| 8 #include <sys/socket.h> | |
| 9 #include <sys/types.h> | |
| 10 #include <unistd.h> | |
| 11 | |
| 12 #include <algorithm> | |
| 13 #include <string> | |
| 14 #include <utility> | |
| 15 | |
| 16 #include "base/location.h" | |
| 17 #include "base/logging.h" | |
| 18 #include "base/memory/scoped_ptr.h" | |
| 19 #include "base/rand_util.h" | |
| 20 #include "base/single_thread_task_runner.h" | |
| 21 #include "base/stl_util.h" | |
| 22 #include "base/thread_task_runner_handle.h" | |
| 23 #include "base/threading/worker_pool.h" | |
| 24 #include "base/time/time.h" | |
| 25 #include "chromeos/dbus/dbus_thread_manager.h" | |
| 26 #include "chromeos/dbus/fake_bluetooth_adapter_client.h" | |
| 27 #include "chromeos/dbus/fake_bluetooth_agent_manager_client.h" | |
| 28 #include "chromeos/dbus/fake_bluetooth_agent_service_provider.h" | |
| 29 #include "chromeos/dbus/fake_bluetooth_gatt_service_client.h" | |
| 30 #include "chromeos/dbus/fake_bluetooth_input_client.h" | |
| 31 #include "chromeos/dbus/fake_bluetooth_profile_manager_client.h" | |
| 32 #include "chromeos/dbus/fake_bluetooth_profile_service_provider.h" | |
| 33 #include "dbus/file_descriptor.h" | |
| 34 #include "third_party/cros_system_api/dbus/service_constants.h" | |
| 35 | |
| 36 namespace { | |
| 37 | |
| 38 // Default interval between simulated events. | |
| 39 const int kSimulationIntervalMs = 750; | |
| 40 | |
| 41 // Minimum and maximum bounds for randomly generated RSSI values. | |
| 42 const int kMinRSSI = -90; | |
| 43 const int kMaxRSSI = -30; | |
| 44 | |
| 45 // The default value of connection info properties from GetConnInfo(). | |
| 46 const int kUnkownPower = 127; | |
| 47 | |
| 48 // This is meant to delay the removal of a pre defined device until the | |
| 49 // developer has time to see it. | |
| 50 const int kVanishingDevicePairTimeMultiplier = 4; | |
| 51 | |
| 52 // Meant to delay a pair request for an observable amount of time. | |
| 53 const int kIncomingSimulationPairTimeMultiplier = 45; | |
| 54 | |
| 55 // Meant to delay a request that asks for pair requests for an observable | |
| 56 // amount of time. | |
| 57 const int kIncomingSimulationStartPairTimeMultiplier = 30; | |
| 58 | |
| 59 // This allows the PIN code dialog to be shown for a long enough time to see | |
| 60 // the PIN code UI in detail. | |
| 61 const int kPinCodeDevicePairTimeMultiplier = 7; | |
| 62 | |
| 63 // This allows the pairing dialog to be shown for a long enough time to see | |
| 64 // its UI in detail. | |
| 65 const int kSimulateNormalPairTimeMultiplier = 3; | |
| 66 | |
| 67 void SimulatedProfileSocket(int fd) { | |
| 68 // Simulate a server-side socket of a profile; read data from the socket, | |
| 69 // write it back, and then close. | |
| 70 char buf[1024]; | |
| 71 ssize_t len; | |
| 72 ssize_t count; | |
| 73 | |
| 74 len = read(fd, buf, sizeof buf); | |
| 75 if (len < 0) { | |
| 76 close(fd); | |
| 77 return; | |
| 78 } | |
| 79 | |
| 80 count = len; | |
| 81 len = write(fd, buf, count); | |
| 82 if (len < 0) { | |
| 83 close(fd); | |
| 84 return; | |
| 85 } | |
| 86 | |
| 87 close(fd); | |
| 88 } | |
| 89 | |
| 90 void SimpleErrorCallback(const std::string& error_name, | |
| 91 const std::string& error_message) { | |
| 92 VLOG(1) << "Bluetooth Error: " << error_name << ": " << error_message; | |
| 93 } | |
| 94 | |
| 95 } // namespace | |
| 96 | |
| 97 namespace chromeos { | |
| 98 | |
| 99 const char FakeBluetoothDeviceClient::kTestPinCode[] = "123456"; | |
| 100 const int FakeBluetoothDeviceClient::kTestPassKey = 123456; | |
| 101 | |
| 102 const char FakeBluetoothDeviceClient::kPairingMethodNone[] = "None"; | |
| 103 const char FakeBluetoothDeviceClient::kPairingMethodPinCode[] = "PIN Code"; | |
| 104 const char FakeBluetoothDeviceClient::kPairingMethodPassKey[] = "PassKey"; | |
| 105 | |
| 106 const char FakeBluetoothDeviceClient::kPairingActionConfirmation[] = | |
| 107 "Confirmation"; | |
| 108 const char FakeBluetoothDeviceClient::kPairingActionDisplay[] = "Display"; | |
| 109 const char FakeBluetoothDeviceClient::kPairingActionFail[] = "Fail"; | |
| 110 const char FakeBluetoothDeviceClient::kPairingActionRequest[] = "Request"; | |
| 111 | |
| 112 const char FakeBluetoothDeviceClient::kPairedDevicePath[] = | |
| 113 "/fake/hci0/dev0"; | |
| 114 const char FakeBluetoothDeviceClient::kPairedDeviceAddress[] = | |
| 115 "00:11:22:33:44:55"; | |
| 116 const char FakeBluetoothDeviceClient::kPairedDeviceName[] = | |
| 117 "Fake Device"; | |
| 118 const uint32 FakeBluetoothDeviceClient::kPairedDeviceClass = 0x000104; | |
| 119 | |
| 120 const char FakeBluetoothDeviceClient::kLegacyAutopairPath[] = | |
| 121 "/fake/hci0/dev1"; | |
| 122 const char FakeBluetoothDeviceClient::kLegacyAutopairAddress[] = | |
| 123 "28:CF:DA:00:00:00"; | |
| 124 const char FakeBluetoothDeviceClient::kLegacyAutopairName[] = | |
| 125 "Bluetooth 2.0 Mouse"; | |
| 126 const uint32 FakeBluetoothDeviceClient::kLegacyAutopairClass = 0x002580; | |
| 127 | |
| 128 const char FakeBluetoothDeviceClient::kDisplayPinCodePath[] = | |
| 129 "/fake/hci0/dev2"; | |
| 130 const char FakeBluetoothDeviceClient::kDisplayPinCodeAddress[] = | |
| 131 "28:37:37:00:00:00"; | |
| 132 const char FakeBluetoothDeviceClient::kDisplayPinCodeName[] = | |
| 133 "Bluetooth 2.0 Keyboard"; | |
| 134 const uint32 FakeBluetoothDeviceClient::kDisplayPinCodeClass = 0x002540; | |
| 135 | |
| 136 const char FakeBluetoothDeviceClient::kVanishingDevicePath[] = | |
| 137 "/fake/hci0/dev3"; | |
| 138 const char FakeBluetoothDeviceClient::kVanishingDeviceAddress[] = | |
| 139 "01:02:03:04:05:06"; | |
| 140 const char FakeBluetoothDeviceClient::kVanishingDeviceName[] = | |
| 141 "Vanishing Device"; | |
| 142 const uint32 FakeBluetoothDeviceClient::kVanishingDeviceClass = 0x000104; | |
| 143 | |
| 144 const char FakeBluetoothDeviceClient::kConnectUnpairablePath[] = | |
| 145 "/fake/hci0/dev4"; | |
| 146 const char FakeBluetoothDeviceClient::kConnectUnpairableAddress[] = | |
| 147 "7C:ED:8D:00:00:00"; | |
| 148 const char FakeBluetoothDeviceClient::kConnectUnpairableName[] = | |
| 149 "Unpairable Device"; | |
| 150 const uint32 FakeBluetoothDeviceClient::kConnectUnpairableClass = 0x002580; | |
| 151 | |
| 152 const char FakeBluetoothDeviceClient::kDisplayPasskeyPath[] = | |
| 153 "/fake/hci0/dev5"; | |
| 154 const char FakeBluetoothDeviceClient::kDisplayPasskeyAddress[] = | |
| 155 "00:0F:F6:00:00:00"; | |
| 156 const char FakeBluetoothDeviceClient::kDisplayPasskeyName[] = | |
| 157 "Bluetooth 2.1+ Keyboard"; | |
| 158 const uint32 FakeBluetoothDeviceClient::kDisplayPasskeyClass = 0x002540; | |
| 159 | |
| 160 const char FakeBluetoothDeviceClient::kRequestPinCodePath[] = | |
| 161 "/fake/hci0/dev6"; | |
| 162 const char FakeBluetoothDeviceClient::kRequestPinCodeAddress[] = | |
| 163 "00:24:BE:00:00:00"; | |
| 164 const char FakeBluetoothDeviceClient::kRequestPinCodeName[] = | |
| 165 "PIN Device"; | |
| 166 const uint32 FakeBluetoothDeviceClient::kRequestPinCodeClass = 0x240408; | |
| 167 | |
| 168 const char FakeBluetoothDeviceClient::kConfirmPasskeyPath[] = | |
| 169 "/fake/hci0/dev7"; | |
| 170 const char FakeBluetoothDeviceClient::kConfirmPasskeyAddress[] = | |
| 171 "20:7D:74:00:00:00"; | |
| 172 const char FakeBluetoothDeviceClient::kConfirmPasskeyName[] = | |
| 173 "Phone"; | |
| 174 const uint32 FakeBluetoothDeviceClient::kConfirmPasskeyClass = 0x7a020c; | |
| 175 | |
| 176 const char FakeBluetoothDeviceClient::kRequestPasskeyPath[] = | |
| 177 "/fake/hci0/dev8"; | |
| 178 const char FakeBluetoothDeviceClient::kRequestPasskeyAddress[] = | |
| 179 "20:7D:74:00:00:01"; | |
| 180 const char FakeBluetoothDeviceClient::kRequestPasskeyName[] = | |
| 181 "Passkey Device"; | |
| 182 const uint32 FakeBluetoothDeviceClient::kRequestPasskeyClass = 0x7a020c; | |
| 183 | |
| 184 const char FakeBluetoothDeviceClient::kUnconnectableDevicePath[] = | |
| 185 "/fake/hci0/dev9"; | |
| 186 const char FakeBluetoothDeviceClient::kUnconnectableDeviceAddress[] = | |
| 187 "20:7D:74:00:00:02"; | |
| 188 const char FakeBluetoothDeviceClient::kUnconnectableDeviceName[] = | |
| 189 "Unconnectable Device"; | |
| 190 const uint32 FakeBluetoothDeviceClient::kUnconnectableDeviceClass = 0x7a020c; | |
| 191 | |
| 192 const char FakeBluetoothDeviceClient::kUnpairableDevicePath[] = | |
| 193 "/fake/hci0/devA"; | |
| 194 const char FakeBluetoothDeviceClient::kUnpairableDeviceAddress[] = | |
| 195 "20:7D:74:00:00:03"; | |
| 196 const char FakeBluetoothDeviceClient::kUnpairableDeviceName[] = | |
| 197 "Unpairable Device"; | |
| 198 const uint32 FakeBluetoothDeviceClient::kUnpairableDeviceClass = 0x002540; | |
| 199 | |
| 200 const char FakeBluetoothDeviceClient::kJustWorksPath[] = | |
| 201 "/fake/hci0/devB"; | |
| 202 const char FakeBluetoothDeviceClient::kJustWorksAddress[] = | |
| 203 "00:0C:8A:00:00:00"; | |
| 204 const char FakeBluetoothDeviceClient::kJustWorksName[] = | |
| 205 "Just-Works Device"; | |
| 206 const uint32 FakeBluetoothDeviceClient::kJustWorksClass = 0x240428; | |
| 207 | |
| 208 const char FakeBluetoothDeviceClient::kLowEnergyPath[] = | |
| 209 "/fake/hci0/devC"; | |
| 210 const char FakeBluetoothDeviceClient::kLowEnergyAddress[] = | |
| 211 "00:1A:11:00:15:30"; | |
| 212 const char FakeBluetoothDeviceClient::kLowEnergyName[] = | |
| 213 "Bluetooth 4.0 Heart Rate Monitor"; | |
| 214 const uint32 FakeBluetoothDeviceClient::kLowEnergyClass = | |
| 215 0x000918; // Major class "Health", Minor class "Heart/Pulse Rate Monitor." | |
| 216 | |
| 217 const char FakeBluetoothDeviceClient::kPairedUnconnectableDevicePath[] = | |
| 218 "/fake/hci0/devD"; | |
| 219 const char FakeBluetoothDeviceClient::kPairedUnconnectableDeviceAddress[] = | |
| 220 "20:7D:74:00:00:04"; | |
| 221 const char FakeBluetoothDeviceClient::kPairedUnconnectableDeviceName[] = | |
| 222 "Paired Unconnectable Device"; | |
| 223 const uint32 FakeBluetoothDeviceClient::kPairedUnconnectableDeviceClass = | |
| 224 0x000104; | |
| 225 | |
| 226 FakeBluetoothDeviceClient::Properties::Properties( | |
| 227 const PropertyChangedCallback& callback) | |
| 228 : BluetoothDeviceClient::Properties( | |
| 229 NULL, | |
| 230 bluetooth_device::kBluetoothDeviceInterface, | |
| 231 callback) { | |
| 232 } | |
| 233 | |
| 234 FakeBluetoothDeviceClient::Properties::~Properties() { | |
| 235 } | |
| 236 | |
| 237 void FakeBluetoothDeviceClient::Properties::Get( | |
| 238 dbus::PropertyBase* property, | |
| 239 dbus::PropertySet::GetCallback callback) { | |
| 240 VLOG(1) << "Get " << property->name(); | |
| 241 callback.Run(false); | |
| 242 } | |
| 243 | |
| 244 void FakeBluetoothDeviceClient::Properties::GetAll() { | |
| 245 VLOG(1) << "GetAll"; | |
| 246 } | |
| 247 | |
| 248 void FakeBluetoothDeviceClient::Properties::Set( | |
| 249 dbus::PropertyBase *property, | |
| 250 dbus::PropertySet::SetCallback callback) { | |
| 251 VLOG(1) << "Set " << property->name(); | |
| 252 if (property->name() == trusted.name()) { | |
| 253 callback.Run(true); | |
| 254 property->ReplaceValueWithSetValue(); | |
| 255 } else { | |
| 256 callback.Run(false); | |
| 257 } | |
| 258 } | |
| 259 | |
| 260 FakeBluetoothDeviceClient::SimulatedPairingOptions::SimulatedPairingOptions() {} | |
| 261 | |
| 262 FakeBluetoothDeviceClient::SimulatedPairingOptions::~SimulatedPairingOptions() { | |
| 263 } | |
| 264 | |
| 265 FakeBluetoothDeviceClient::IncomingDeviceProperties:: | |
| 266 IncomingDeviceProperties() {} | |
| 267 | |
| 268 FakeBluetoothDeviceClient::IncomingDeviceProperties:: | |
| 269 ~IncomingDeviceProperties() {} | |
| 270 | |
| 271 FakeBluetoothDeviceClient::FakeBluetoothDeviceClient() | |
| 272 : simulation_interval_ms_(kSimulationIntervalMs), | |
| 273 discovery_simulation_step_(0), | |
| 274 incoming_pairing_simulation_step_(0), | |
| 275 pairing_cancelled_(false), | |
| 276 connection_rssi_(kUnkownPower), | |
| 277 transmit_power_(kUnkownPower), | |
| 278 max_transmit_power_(kUnkownPower) { | |
| 279 scoped_ptr<Properties> properties(new Properties( | |
| 280 base::Bind(&FakeBluetoothDeviceClient::OnPropertyChanged, | |
| 281 base::Unretained(this), dbus::ObjectPath(kPairedDevicePath)))); | |
| 282 properties->address.ReplaceValue(kPairedDeviceAddress); | |
| 283 properties->bluetooth_class.ReplaceValue(kPairedDeviceClass); | |
| 284 properties->name.ReplaceValue("Fake Device (Name)"); | |
| 285 properties->alias.ReplaceValue(kPairedDeviceName); | |
| 286 properties->paired.ReplaceValue(true); | |
| 287 properties->trusted.ReplaceValue(true); | |
| 288 properties->adapter.ReplaceValue( | |
| 289 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath)); | |
| 290 | |
| 291 std::vector<std::string> uuids; | |
| 292 uuids.push_back("00001800-0000-1000-8000-00805f9b34fb"); | |
| 293 uuids.push_back("00001801-0000-1000-8000-00805f9b34fb"); | |
| 294 properties->uuids.ReplaceValue(uuids); | |
| 295 | |
| 296 properties->modalias.ReplaceValue("usb:v05ACp030Dd0306"); | |
| 297 | |
| 298 properties_map_.insert(dbus::ObjectPath(kPairedDevicePath), | |
| 299 properties.Pass()); | |
| 300 device_list_.push_back(dbus::ObjectPath(kPairedDevicePath)); | |
| 301 | |
| 302 properties.reset(new Properties(base::Bind( | |
| 303 &FakeBluetoothDeviceClient::OnPropertyChanged, base::Unretained(this), | |
| 304 dbus::ObjectPath(kPairedUnconnectableDevicePath)))); | |
| 305 properties->address.ReplaceValue(kPairedUnconnectableDeviceAddress); | |
| 306 properties->bluetooth_class.ReplaceValue(kPairedUnconnectableDeviceClass); | |
| 307 properties->name.ReplaceValue("Fake Device 2 (Unconnectable)"); | |
| 308 properties->alias.ReplaceValue(kPairedUnconnectableDeviceName); | |
| 309 properties->paired.ReplaceValue(true); | |
| 310 properties->trusted.ReplaceValue(true); | |
| 311 properties->adapter.ReplaceValue( | |
| 312 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath)); | |
| 313 | |
| 314 properties->uuids.ReplaceValue(uuids); | |
| 315 | |
| 316 properties->modalias.ReplaceValue("usb:v05ACp030Dd0306"); | |
| 317 | |
| 318 properties_map_.insert(dbus::ObjectPath(kPairedUnconnectableDevicePath), | |
| 319 properties.Pass()); | |
| 320 device_list_.push_back(dbus::ObjectPath(kPairedUnconnectableDevicePath)); | |
| 321 } | |
| 322 | |
| 323 FakeBluetoothDeviceClient::~FakeBluetoothDeviceClient() { | |
| 324 } | |
| 325 | |
| 326 void FakeBluetoothDeviceClient::Init(dbus::Bus* bus) { | |
| 327 } | |
| 328 | |
| 329 void FakeBluetoothDeviceClient::AddObserver(Observer* observer) { | |
| 330 observers_.AddObserver(observer); | |
| 331 } | |
| 332 | |
| 333 void FakeBluetoothDeviceClient::RemoveObserver(Observer* observer) { | |
| 334 observers_.RemoveObserver(observer); | |
| 335 } | |
| 336 | |
| 337 std::vector<dbus::ObjectPath> FakeBluetoothDeviceClient::GetDevicesForAdapter( | |
| 338 const dbus::ObjectPath& adapter_path) { | |
| 339 if (adapter_path == | |
| 340 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath)) | |
| 341 return device_list_; | |
| 342 else | |
| 343 return std::vector<dbus::ObjectPath>(); | |
| 344 } | |
| 345 | |
| 346 FakeBluetoothDeviceClient::Properties* | |
| 347 FakeBluetoothDeviceClient::GetProperties(const dbus::ObjectPath& object_path) { | |
| 348 PropertiesMap::const_iterator iter = properties_map_.find(object_path); | |
| 349 if (iter != properties_map_.end()) | |
| 350 return iter->second; | |
| 351 return NULL; | |
| 352 } | |
| 353 | |
| 354 FakeBluetoothDeviceClient::SimulatedPairingOptions* | |
| 355 FakeBluetoothDeviceClient::GetPairingOptions( | |
| 356 const dbus::ObjectPath& object_path) { | |
| 357 PairingOptionsMap::const_iterator iter = | |
| 358 pairing_options_map_.find(object_path); | |
| 359 if (iter != pairing_options_map_.end()) | |
| 360 return iter->second; | |
| 361 return iter != pairing_options_map_.end() ? iter->second : nullptr; | |
| 362 } | |
| 363 | |
| 364 void FakeBluetoothDeviceClient::Connect( | |
| 365 const dbus::ObjectPath& object_path, | |
| 366 const base::Closure& callback, | |
| 367 const ErrorCallback& error_callback) { | |
| 368 VLOG(1) << "Connect: " << object_path.value(); | |
| 369 Properties* properties = GetProperties(object_path); | |
| 370 | |
| 371 if (properties->connected.value() == true) { | |
| 372 // Already connected. | |
| 373 callback.Run(); | |
| 374 return; | |
| 375 } | |
| 376 | |
| 377 if (properties->paired.value() != true && | |
| 378 object_path != dbus::ObjectPath(kConnectUnpairablePath) && | |
| 379 object_path != dbus::ObjectPath(kLowEnergyPath)) { | |
| 380 // Must be paired. | |
| 381 error_callback.Run(bluetooth_device::kErrorFailed, "Not paired"); | |
| 382 return; | |
| 383 } else if (properties->paired.value() == true && | |
| 384 (object_path == dbus::ObjectPath(kUnconnectableDevicePath) || | |
| 385 object_path == | |
| 386 dbus::ObjectPath(kPairedUnconnectableDevicePath))) { | |
| 387 // Must not be paired | |
| 388 error_callback.Run(bluetooth_device::kErrorFailed, | |
| 389 "Connection fails while paired"); | |
| 390 return; | |
| 391 } | |
| 392 | |
| 393 // The device can be connected. | |
| 394 properties->connected.ReplaceValue(true); | |
| 395 callback.Run(); | |
| 396 | |
| 397 // Expose GATT services if connected to LE device. | |
| 398 if (object_path == dbus::ObjectPath(kLowEnergyPath)) { | |
| 399 FakeBluetoothGattServiceClient* gatt_service_client = | |
| 400 static_cast<FakeBluetoothGattServiceClient*>( | |
| 401 DBusThreadManager::Get()->GetBluetoothGattServiceClient()); | |
| 402 gatt_service_client->ExposeHeartRateService( | |
| 403 dbus::ObjectPath(kLowEnergyPath)); | |
| 404 } | |
| 405 | |
| 406 AddInputDeviceIfNeeded(object_path, properties); | |
| 407 } | |
| 408 | |
| 409 void FakeBluetoothDeviceClient::Disconnect( | |
| 410 const dbus::ObjectPath& object_path, | |
| 411 const base::Closure& callback, | |
| 412 const ErrorCallback& error_callback) { | |
| 413 VLOG(1) << "Disconnect: " << object_path.value(); | |
| 414 Properties* properties = GetProperties(object_path); | |
| 415 | |
| 416 if (!properties->connected.value()) { | |
| 417 error_callback.Run("org.bluez.Error.NotConnected", "Not Connected"); | |
| 418 return; | |
| 419 } | |
| 420 | |
| 421 // Hide the Heart Rate Service if disconnected from LE device. | |
| 422 if (object_path == dbus::ObjectPath(kLowEnergyPath)) { | |
| 423 FakeBluetoothGattServiceClient* gatt_service_client = | |
| 424 static_cast<FakeBluetoothGattServiceClient*>( | |
| 425 DBusThreadManager::Get()->GetBluetoothGattServiceClient()); | |
| 426 gatt_service_client->HideHeartRateService(); | |
| 427 } | |
| 428 | |
| 429 callback.Run(); | |
| 430 properties->connected.ReplaceValue(false); | |
| 431 } | |
| 432 | |
| 433 void FakeBluetoothDeviceClient::ConnectProfile( | |
| 434 const dbus::ObjectPath& object_path, | |
| 435 const std::string& uuid, | |
| 436 const base::Closure& callback, | |
| 437 const ErrorCallback& error_callback) { | |
| 438 VLOG(1) << "ConnectProfile: " << object_path.value() << " " << uuid; | |
| 439 | |
| 440 FakeBluetoothProfileManagerClient* fake_bluetooth_profile_manager_client = | |
| 441 static_cast<FakeBluetoothProfileManagerClient*>( | |
| 442 DBusThreadManager::Get()->GetBluetoothProfileManagerClient()); | |
| 443 FakeBluetoothProfileServiceProvider* profile_service_provider = | |
| 444 fake_bluetooth_profile_manager_client->GetProfileServiceProvider(uuid); | |
| 445 if (profile_service_provider == NULL) { | |
| 446 error_callback.Run(kNoResponseError, "Missing profile"); | |
| 447 return; | |
| 448 } | |
| 449 | |
| 450 if (object_path == dbus::ObjectPath(kPairedUnconnectableDevicePath)) { | |
| 451 error_callback.Run(bluetooth_device::kErrorFailed, "unconnectable"); | |
| 452 return; | |
| 453 } | |
| 454 | |
| 455 // Make a socket pair of a compatible type with the type used by Bluetooth; | |
| 456 // spin up a thread to simulate the server side and wrap the client side in | |
| 457 // a D-Bus file descriptor object. | |
| 458 int socket_type = SOCK_STREAM; | |
| 459 if (uuid == FakeBluetoothProfileManagerClient::kL2capUuid) | |
| 460 socket_type = SOCK_SEQPACKET; | |
| 461 | |
| 462 int fds[2]; | |
| 463 if (socketpair(AF_UNIX, socket_type, 0, fds) < 0) { | |
| 464 error_callback.Run(kNoResponseError, "socketpair call failed"); | |
| 465 return; | |
| 466 } | |
| 467 | |
| 468 int args; | |
| 469 args = fcntl(fds[1], F_GETFL, NULL); | |
| 470 if (args < 0) { | |
| 471 error_callback.Run(kNoResponseError, "failed to get socket flags"); | |
| 472 return; | |
| 473 } | |
| 474 | |
| 475 args |= O_NONBLOCK; | |
| 476 if (fcntl(fds[1], F_SETFL, args) < 0) { | |
| 477 error_callback.Run(kNoResponseError, "failed to set socket non-blocking"); | |
| 478 return; | |
| 479 } | |
| 480 | |
| 481 base::WorkerPool::GetTaskRunner(false)->PostTask( | |
| 482 FROM_HERE, | |
| 483 base::Bind(&SimulatedProfileSocket, | |
| 484 fds[0])); | |
| 485 | |
| 486 scoped_ptr<dbus::FileDescriptor> fd(new dbus::FileDescriptor(fds[1])); | |
| 487 | |
| 488 // Post the new connection to the service provider. | |
| 489 BluetoothProfileServiceProvider::Delegate::Options options; | |
| 490 | |
| 491 profile_service_provider->NewConnection( | |
| 492 object_path, | |
| 493 fd.Pass(), | |
| 494 options, | |
| 495 base::Bind(&FakeBluetoothDeviceClient::ConnectionCallback, | |
| 496 base::Unretained(this), | |
| 497 object_path, | |
| 498 callback, | |
| 499 error_callback)); | |
| 500 } | |
| 501 | |
| 502 void FakeBluetoothDeviceClient::DisconnectProfile( | |
| 503 const dbus::ObjectPath& object_path, | |
| 504 const std::string& uuid, | |
| 505 const base::Closure& callback, | |
| 506 const ErrorCallback& error_callback) { | |
| 507 VLOG(1) << "DisconnectProfile: " << object_path.value() << " " << uuid; | |
| 508 | |
| 509 FakeBluetoothProfileManagerClient* fake_bluetooth_profile_manager_client = | |
| 510 static_cast<FakeBluetoothProfileManagerClient*>( | |
| 511 DBusThreadManager::Get()->GetBluetoothProfileManagerClient()); | |
| 512 FakeBluetoothProfileServiceProvider* profile_service_provider = | |
| 513 fake_bluetooth_profile_manager_client->GetProfileServiceProvider(uuid); | |
| 514 if (profile_service_provider == NULL) { | |
| 515 error_callback.Run(kNoResponseError, "Missing profile"); | |
| 516 return; | |
| 517 } | |
| 518 | |
| 519 profile_service_provider->RequestDisconnection( | |
| 520 object_path, | |
| 521 base::Bind(&FakeBluetoothDeviceClient::DisconnectionCallback, | |
| 522 base::Unretained(this), | |
| 523 object_path, | |
| 524 callback, | |
| 525 error_callback)); | |
| 526 } | |
| 527 | |
| 528 void FakeBluetoothDeviceClient::Pair( | |
| 529 const dbus::ObjectPath& object_path, | |
| 530 const base::Closure& callback, | |
| 531 const ErrorCallback& error_callback) { | |
| 532 VLOG(1) << "Pair: " << object_path.value(); | |
| 533 Properties* properties = GetProperties(object_path); | |
| 534 | |
| 535 if (properties->paired.value() == true) { | |
| 536 // Already paired. | |
| 537 callback.Run(); | |
| 538 return; | |
| 539 } | |
| 540 | |
| 541 SimulatePairing(object_path, false, callback, error_callback); | |
| 542 } | |
| 543 | |
| 544 void FakeBluetoothDeviceClient::CancelPairing( | |
| 545 const dbus::ObjectPath& object_path, | |
| 546 const base::Closure& callback, | |
| 547 const ErrorCallback& error_callback) { | |
| 548 VLOG(1) << "CancelPairing: " << object_path.value(); | |
| 549 pairing_cancelled_ = true; | |
| 550 callback.Run(); | |
| 551 } | |
| 552 | |
| 553 void FakeBluetoothDeviceClient::GetConnInfo( | |
| 554 const dbus::ObjectPath& object_path, | |
| 555 const ConnInfoCallback& callback, | |
| 556 const ErrorCallback& error_callback) { | |
| 557 Properties* properties = GetProperties(object_path); | |
| 558 if (!properties->connected.value()) { | |
| 559 error_callback.Run("org.bluez.Error.NotConnected", "Not Connected"); | |
| 560 return; | |
| 561 } | |
| 562 | |
| 563 callback.Run(connection_rssi_, transmit_power_, max_transmit_power_); | |
| 564 } | |
| 565 | |
| 566 void FakeBluetoothDeviceClient::BeginDiscoverySimulation( | |
| 567 const dbus::ObjectPath& adapter_path) { | |
| 568 VLOG(1) << "starting discovery simulation"; | |
| 569 | |
| 570 discovery_simulation_step_ = 1; | |
| 571 | |
| 572 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 573 FROM_HERE, | |
| 574 base::Bind(&FakeBluetoothDeviceClient::DiscoverySimulationTimer, | |
| 575 base::Unretained(this)), | |
| 576 base::TimeDelta::FromMilliseconds(simulation_interval_ms_)); | |
| 577 } | |
| 578 | |
| 579 void FakeBluetoothDeviceClient::EndDiscoverySimulation( | |
| 580 const dbus::ObjectPath& adapter_path) { | |
| 581 VLOG(1) << "stopping discovery simulation"; | |
| 582 discovery_simulation_step_ = 0; | |
| 583 } | |
| 584 | |
| 585 void FakeBluetoothDeviceClient::BeginIncomingPairingSimulation( | |
| 586 const dbus::ObjectPath& adapter_path) { | |
| 587 VLOG(1) << "starting incoming pairing simulation"; | |
| 588 | |
| 589 incoming_pairing_simulation_step_ = 1; | |
| 590 | |
| 591 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 592 FROM_HERE, | |
| 593 base::Bind(&FakeBluetoothDeviceClient::IncomingPairingSimulationTimer, | |
| 594 base::Unretained(this)), | |
| 595 base::TimeDelta::FromMilliseconds( | |
| 596 kIncomingSimulationStartPairTimeMultiplier * | |
| 597 simulation_interval_ms_)); | |
| 598 } | |
| 599 | |
| 600 void FakeBluetoothDeviceClient::EndIncomingPairingSimulation( | |
| 601 const dbus::ObjectPath& adapter_path) { | |
| 602 VLOG(1) << "stopping incoming pairing simulation"; | |
| 603 incoming_pairing_simulation_step_ = 0; | |
| 604 } | |
| 605 | |
| 606 void FakeBluetoothDeviceClient::SetSimulationIntervalMs(int interval_ms) { | |
| 607 simulation_interval_ms_ = interval_ms; | |
| 608 } | |
| 609 | |
| 610 void FakeBluetoothDeviceClient::CreateDevice( | |
| 611 const dbus::ObjectPath& adapter_path, | |
| 612 const dbus::ObjectPath& device_path) { | |
| 613 if (std::find(device_list_.begin(), | |
| 614 device_list_.end(), device_path) != device_list_.end()) | |
| 615 return; | |
| 616 | |
| 617 scoped_ptr<Properties> properties( | |
| 618 new Properties(base::Bind(&FakeBluetoothDeviceClient::OnPropertyChanged, | |
| 619 base::Unretained(this), device_path))); | |
| 620 properties->adapter.ReplaceValue(adapter_path); | |
| 621 | |
| 622 if (device_path == dbus::ObjectPath(kLegacyAutopairPath)) { | |
| 623 properties->address.ReplaceValue(kLegacyAutopairAddress); | |
| 624 properties->bluetooth_class.ReplaceValue(kLegacyAutopairClass); | |
| 625 properties->name.ReplaceValue("LegacyAutopair"); | |
| 626 properties->alias.ReplaceValue(kLegacyAutopairName); | |
| 627 | |
| 628 std::vector<std::string> uuids; | |
| 629 uuids.push_back("00001124-0000-1000-8000-00805f9b34fb"); | |
| 630 properties->uuids.ReplaceValue(uuids); | |
| 631 | |
| 632 } else if (device_path == dbus::ObjectPath(kDisplayPinCodePath)) { | |
| 633 properties->address.ReplaceValue(kDisplayPinCodeAddress); | |
| 634 properties->bluetooth_class.ReplaceValue(kDisplayPinCodeClass); | |
| 635 properties->name.ReplaceValue("DisplayPinCode"); | |
| 636 properties->alias.ReplaceValue(kDisplayPinCodeName); | |
| 637 | |
| 638 std::vector<std::string> uuids; | |
| 639 uuids.push_back("00001124-0000-1000-8000-00805f9b34fb"); | |
| 640 properties->uuids.ReplaceValue(uuids); | |
| 641 | |
| 642 } else if (device_path == dbus::ObjectPath(kVanishingDevicePath)) { | |
| 643 properties->address.ReplaceValue(kVanishingDeviceAddress); | |
| 644 properties->bluetooth_class.ReplaceValue(kVanishingDeviceClass); | |
| 645 properties->name.ReplaceValue("VanishingDevice"); | |
| 646 properties->alias.ReplaceValue(kVanishingDeviceName); | |
| 647 | |
| 648 } else if (device_path == dbus::ObjectPath(kConnectUnpairablePath)) { | |
| 649 properties->address.ReplaceValue(kConnectUnpairableAddress); | |
| 650 properties->bluetooth_class.ReplaceValue(kConnectUnpairableClass); | |
| 651 properties->name.ReplaceValue("ConnectUnpairable"); | |
| 652 properties->alias.ReplaceValue(kConnectUnpairableName); | |
| 653 | |
| 654 std::vector<std::string> uuids; | |
| 655 uuids.push_back("00001124-0000-1000-8000-00805f9b34fb"); | |
| 656 properties->uuids.ReplaceValue(uuids); | |
| 657 | |
| 658 } else if (device_path == dbus::ObjectPath(kDisplayPasskeyPath)) { | |
| 659 properties->address.ReplaceValue(kDisplayPasskeyAddress); | |
| 660 properties->bluetooth_class.ReplaceValue(kDisplayPasskeyClass); | |
| 661 properties->name.ReplaceValue("DisplayPasskey"); | |
| 662 properties->alias.ReplaceValue(kDisplayPasskeyName); | |
| 663 | |
| 664 std::vector<std::string> uuids; | |
| 665 uuids.push_back("00001124-0000-1000-8000-00805f9b34fb"); | |
| 666 properties->uuids.ReplaceValue(uuids); | |
| 667 | |
| 668 } else if (device_path == dbus::ObjectPath(kRequestPinCodePath)) { | |
| 669 properties->address.ReplaceValue(kRequestPinCodeAddress); | |
| 670 properties->bluetooth_class.ReplaceValue(kRequestPinCodeClass); | |
| 671 properties->name.ReplaceValue("RequestPinCode"); | |
| 672 properties->alias.ReplaceValue(kRequestPinCodeName); | |
| 673 | |
| 674 } else if (device_path == dbus::ObjectPath(kConfirmPasskeyPath)) { | |
| 675 properties->address.ReplaceValue(kConfirmPasskeyAddress); | |
| 676 properties->bluetooth_class.ReplaceValue(kConfirmPasskeyClass); | |
| 677 properties->name.ReplaceValue("ConfirmPasskey"); | |
| 678 properties->alias.ReplaceValue(kConfirmPasskeyName); | |
| 679 | |
| 680 } else if (device_path == dbus::ObjectPath(kRequestPasskeyPath)) { | |
| 681 properties->address.ReplaceValue(kRequestPasskeyAddress); | |
| 682 properties->bluetooth_class.ReplaceValue(kRequestPasskeyClass); | |
| 683 properties->name.ReplaceValue("RequestPasskey"); | |
| 684 properties->alias.ReplaceValue(kRequestPasskeyName); | |
| 685 | |
| 686 } else if (device_path == dbus::ObjectPath(kUnconnectableDevicePath)) { | |
| 687 properties->address.ReplaceValue(kUnconnectableDeviceAddress); | |
| 688 properties->bluetooth_class.ReplaceValue(kUnconnectableDeviceClass); | |
| 689 properties->name.ReplaceValue("UnconnectableDevice"); | |
| 690 properties->alias.ReplaceValue(kUnconnectableDeviceName); | |
| 691 | |
| 692 } else if (device_path == dbus::ObjectPath(kUnpairableDevicePath)) { | |
| 693 properties->address.ReplaceValue(kUnpairableDeviceAddress); | |
| 694 properties->bluetooth_class.ReplaceValue(kUnpairableDeviceClass); | |
| 695 properties->name.ReplaceValue("Fake Unpairable Device"); | |
| 696 properties->alias.ReplaceValue(kUnpairableDeviceName); | |
| 697 | |
| 698 } else if (device_path == dbus::ObjectPath(kJustWorksPath)) { | |
| 699 properties->address.ReplaceValue(kJustWorksAddress); | |
| 700 properties->bluetooth_class.ReplaceValue(kJustWorksClass); | |
| 701 properties->name.ReplaceValue("JustWorks"); | |
| 702 properties->alias.ReplaceValue(kJustWorksName); | |
| 703 | |
| 704 } else if (device_path == dbus::ObjectPath(kLowEnergyPath)) { | |
| 705 properties->address.ReplaceValue(kLowEnergyAddress); | |
| 706 properties->bluetooth_class.ReplaceValue(kLowEnergyClass); | |
| 707 properties->name.ReplaceValue("Heart Rate Monitor"); | |
| 708 properties->alias.ReplaceValue(kLowEnergyName); | |
| 709 | |
| 710 std::vector<std::string> uuids; | |
| 711 uuids.push_back(FakeBluetoothGattServiceClient::kHeartRateServiceUUID); | |
| 712 properties->uuids.ReplaceValue(uuids); | |
| 713 | |
| 714 } else { | |
| 715 NOTREACHED(); | |
| 716 | |
| 717 } | |
| 718 | |
| 719 properties_map_.insert(device_path, properties.Pass()); | |
| 720 device_list_.push_back(device_path); | |
| 721 FOR_EACH_OBSERVER(BluetoothDeviceClient::Observer, observers_, | |
| 722 DeviceAdded(device_path)); | |
| 723 } | |
| 724 | |
| 725 void FakeBluetoothDeviceClient::CreateDeviceWithProperties( | |
| 726 const dbus::ObjectPath& adapter_path, | |
| 727 const IncomingDeviceProperties& props) { | |
| 728 dbus::ObjectPath device_path(props.device_path); | |
| 729 if (std::find(device_list_.begin(), device_list_.end(), device_path) != | |
| 730 device_list_.end()) | |
| 731 return; | |
| 732 | |
| 733 scoped_ptr<Properties> properties( | |
| 734 new Properties(base::Bind(&FakeBluetoothDeviceClient::OnPropertyChanged, | |
| 735 base::Unretained(this), device_path))); | |
| 736 properties->adapter.ReplaceValue(adapter_path); | |
| 737 properties->name.ReplaceValue(props.device_name); | |
| 738 properties->alias.ReplaceValue(props.device_alias); | |
| 739 properties->address.ReplaceValue(props.device_address); | |
| 740 properties->bluetooth_class.ReplaceValue(props.device_class); | |
| 741 properties->trusted.ReplaceValue(props.is_trusted); | |
| 742 | |
| 743 if (props.is_trusted) | |
| 744 properties->paired.ReplaceValue(true); | |
| 745 | |
| 746 scoped_ptr<SimulatedPairingOptions> options(new SimulatedPairingOptions); | |
| 747 options->pairing_method = props.pairing_method; | |
| 748 options->pairing_auth_token = props.pairing_auth_token; | |
| 749 options->pairing_action = props.pairing_action; | |
| 750 options->incoming = props.incoming; | |
| 751 | |
| 752 properties_map_.insert(device_path, properties.Pass()); | |
| 753 device_list_.push_back(device_path); | |
| 754 pairing_options_map_.insert(device_path, options.Pass()); | |
| 755 FOR_EACH_OBSERVER(BluetoothDeviceClient::Observer, observers_, | |
| 756 DeviceAdded(device_path)); | |
| 757 } | |
| 758 | |
| 759 scoped_ptr<base::ListValue> | |
| 760 FakeBluetoothDeviceClient::GetBluetoothDevicesAsDictionaries() const { | |
| 761 scoped_ptr<base::ListValue> predefined_devices(new base::ListValue); | |
| 762 scoped_ptr<base::DictionaryValue> pairedDevice(new base::DictionaryValue); | |
| 763 pairedDevice->SetString("path", kPairedDevicePath); | |
| 764 pairedDevice->SetString("address", kPairedDeviceAddress); | |
| 765 pairedDevice->SetString("name", kPairedDeviceName); | |
| 766 pairedDevice->SetString("alias", kPairedDeviceName); | |
| 767 pairedDevice->SetString("pairingMethod", ""); | |
| 768 pairedDevice->SetString("pairingAuthToken", ""); | |
| 769 pairedDevice->SetString("pairingAction", ""); | |
| 770 pairedDevice->SetInteger("classValue", kPairedDeviceClass); | |
| 771 pairedDevice->SetBoolean("discoverable", true); | |
| 772 pairedDevice->SetBoolean("isTrusted", true); | |
| 773 pairedDevice->SetBoolean("paired", true); | |
| 774 pairedDevice->SetBoolean("incoming", false); | |
| 775 predefined_devices->Append(pairedDevice.Pass()); | |
| 776 | |
| 777 scoped_ptr<base::DictionaryValue> legacyDevice(new base::DictionaryValue); | |
| 778 legacyDevice->SetString("path", kLegacyAutopairPath); | |
| 779 legacyDevice->SetString("address", kLegacyAutopairAddress); | |
| 780 legacyDevice->SetString("name", kLegacyAutopairName); | |
| 781 legacyDevice->SetString("alias", kLegacyAutopairName); | |
| 782 legacyDevice->SetString("pairingMethod", ""); | |
| 783 legacyDevice->SetString("pairingAuthToken", ""); | |
| 784 legacyDevice->SetString("pairingAction", ""); | |
| 785 legacyDevice->SetInteger("classValue", kLegacyAutopairClass); | |
| 786 legacyDevice->SetBoolean("isTrusted", true); | |
| 787 legacyDevice->SetBoolean("discoverable", false); | |
| 788 legacyDevice->SetBoolean("paired", false); | |
| 789 legacyDevice->SetBoolean("incoming", false); | |
| 790 predefined_devices->Append(legacyDevice.Pass()); | |
| 791 | |
| 792 scoped_ptr<base::DictionaryValue> pin(new base::DictionaryValue); | |
| 793 pin->SetString("path", kDisplayPinCodePath); | |
| 794 pin->SetString("address", kDisplayPinCodeAddress); | |
| 795 pin->SetString("name", kDisplayPinCodeName); | |
| 796 pin->SetString("alias", kDisplayPinCodeName); | |
| 797 pin->SetString("pairingMethod", kPairingMethodPinCode); | |
| 798 pin->SetString("pairingAuthToken", kTestPinCode); | |
| 799 pin->SetString("pairingAction", kPairingActionDisplay); | |
| 800 pin->SetInteger("classValue", kDisplayPinCodeClass); | |
| 801 pin->SetBoolean("isTrusted", false); | |
| 802 pin->SetBoolean("discoverable", false); | |
| 803 pin->SetBoolean("paired", false); | |
| 804 pin->SetBoolean("incoming", false); | |
| 805 predefined_devices->Append(pin.Pass()); | |
| 806 | |
| 807 scoped_ptr<base::DictionaryValue> vanishing(new base::DictionaryValue); | |
| 808 vanishing->SetString("path", kVanishingDevicePath); | |
| 809 vanishing->SetString("address", kVanishingDeviceAddress); | |
| 810 vanishing->SetString("name", kVanishingDeviceName); | |
| 811 vanishing->SetString("alias", kVanishingDeviceName); | |
| 812 vanishing->SetString("pairingMethod", ""); | |
| 813 vanishing->SetString("pairingAuthToken", ""); | |
| 814 vanishing->SetString("pairingAction", ""); | |
| 815 vanishing->SetInteger("classValue", kVanishingDeviceClass); | |
| 816 vanishing->SetBoolean("isTrusted", false); | |
| 817 vanishing->SetBoolean("discoverable", false); | |
| 818 vanishing->SetBoolean("paired", false); | |
| 819 vanishing->SetBoolean("incoming", false); | |
| 820 predefined_devices->Append(vanishing.Pass()); | |
| 821 | |
| 822 scoped_ptr<base::DictionaryValue> connect_unpairable( | |
| 823 new base::DictionaryValue); | |
| 824 connect_unpairable->SetString("path", kConnectUnpairablePath); | |
| 825 connect_unpairable->SetString("address", kConnectUnpairableAddress); | |
| 826 connect_unpairable->SetString("name", kConnectUnpairableName); | |
| 827 connect_unpairable->SetString("pairingMethod", ""); | |
| 828 connect_unpairable->SetString("pairingAuthToken", ""); | |
| 829 connect_unpairable->SetString("pairingAction", ""); | |
| 830 connect_unpairable->SetString("alias", kConnectUnpairableName); | |
| 831 connect_unpairable->SetInteger("classValue", kConnectUnpairableClass); | |
| 832 connect_unpairable->SetBoolean("isTrusted", false); | |
| 833 connect_unpairable->SetBoolean("discoverable", false); | |
| 834 connect_unpairable->SetBoolean("paired", false); | |
| 835 connect_unpairable->SetBoolean("incoming", false); | |
| 836 predefined_devices->Append(connect_unpairable.Pass()); | |
| 837 | |
| 838 scoped_ptr<base::DictionaryValue> passkey(new base::DictionaryValue); | |
| 839 passkey->SetString("path", kDisplayPasskeyPath); | |
| 840 passkey->SetString("address", kDisplayPasskeyAddress); | |
| 841 passkey->SetString("name", kDisplayPasskeyName); | |
| 842 passkey->SetString("alias", kDisplayPasskeyName); | |
| 843 passkey->SetString("pairingMethod", kPairingMethodPassKey); | |
| 844 passkey->SetInteger("pairingAuthToken", kTestPassKey); | |
| 845 passkey->SetString("pairingAction", kPairingActionDisplay); | |
| 846 passkey->SetInteger("classValue", kDisplayPasskeyClass); | |
| 847 passkey->SetBoolean("isTrusted", false); | |
| 848 passkey->SetBoolean("discoverable", false); | |
| 849 passkey->SetBoolean("paired", false); | |
| 850 passkey->SetBoolean("incoming", false); | |
| 851 predefined_devices->Append(passkey.Pass()); | |
| 852 | |
| 853 scoped_ptr<base::DictionaryValue> request_pin(new base::DictionaryValue); | |
| 854 request_pin->SetString("path", kRequestPinCodePath); | |
| 855 request_pin->SetString("address", kRequestPinCodeAddress); | |
| 856 request_pin->SetString("name", kRequestPinCodeName); | |
| 857 request_pin->SetString("alias", kRequestPinCodeName); | |
| 858 request_pin->SetString("pairingMethod", ""); | |
| 859 request_pin->SetString("pairingAuthToken", ""); | |
| 860 request_pin->SetString("pairingAction", kPairingActionRequest); | |
| 861 request_pin->SetInteger("classValue", kRequestPinCodeClass); | |
| 862 request_pin->SetBoolean("isTrusted", false); | |
| 863 request_pin->SetBoolean("discoverable", false); | |
| 864 request_pin->SetBoolean("paired", false); | |
| 865 request_pin->SetBoolean("incoming", false); | |
| 866 predefined_devices->Append(request_pin.Pass()); | |
| 867 | |
| 868 scoped_ptr<base::DictionaryValue> confirm(new base::DictionaryValue); | |
| 869 confirm->SetString("path", kConfirmPasskeyPath); | |
| 870 confirm->SetString("address", kConfirmPasskeyAddress); | |
| 871 confirm->SetString("name", kConfirmPasskeyName); | |
| 872 confirm->SetString("alias", kConfirmPasskeyName); | |
| 873 confirm->SetString("pairingMethod", ""); | |
| 874 confirm->SetInteger("pairingAuthToken", kTestPassKey); | |
| 875 confirm->SetString("pairingAction", kPairingActionConfirmation); | |
| 876 confirm->SetInteger("classValue", kConfirmPasskeyClass); | |
| 877 confirm->SetBoolean("isTrusted", false); | |
| 878 confirm->SetBoolean("discoverable", false); | |
| 879 confirm->SetBoolean("paired", false); | |
| 880 confirm->SetBoolean("incoming", false); | |
| 881 predefined_devices->Append(confirm.Pass()); | |
| 882 | |
| 883 scoped_ptr<base::DictionaryValue> request_passkey(new base::DictionaryValue); | |
| 884 request_passkey->SetString("path", kRequestPasskeyPath); | |
| 885 request_passkey->SetString("address", kRequestPasskeyAddress); | |
| 886 request_passkey->SetString("name", kRequestPasskeyName); | |
| 887 request_passkey->SetString("alias", kRequestPasskeyName); | |
| 888 request_passkey->SetString("pairingMethod", kPairingMethodPassKey); | |
| 889 request_passkey->SetString("pairingAction", kPairingActionRequest); | |
| 890 request_passkey->SetInteger("pairingAuthToken", kTestPassKey); | |
| 891 request_passkey->SetInteger("classValue", kRequestPasskeyClass); | |
| 892 request_passkey->SetBoolean("isTrusted", false); | |
| 893 request_passkey->SetBoolean("discoverable", false); | |
| 894 request_passkey->SetBoolean("paired", false); | |
| 895 request_passkey->SetBoolean("incoming", false); | |
| 896 predefined_devices->Append(request_passkey.Pass()); | |
| 897 | |
| 898 scoped_ptr<base::DictionaryValue> unconnectable(new base::DictionaryValue); | |
| 899 unconnectable->SetString("path", kUnconnectableDevicePath); | |
| 900 unconnectable->SetString("address", kUnconnectableDeviceAddress); | |
| 901 unconnectable->SetString("name", kUnconnectableDeviceName); | |
| 902 unconnectable->SetString("alias", kUnconnectableDeviceName); | |
| 903 unconnectable->SetString("pairingMethod", ""); | |
| 904 unconnectable->SetString("pairingAuthToken", ""); | |
| 905 unconnectable->SetString("pairingAction", ""); | |
| 906 unconnectable->SetInteger("classValue", kUnconnectableDeviceClass); | |
| 907 unconnectable->SetBoolean("isTrusted", true); | |
| 908 unconnectable->SetBoolean("discoverable", false); | |
| 909 unconnectable->SetBoolean("paired", false); | |
| 910 unconnectable->SetBoolean("incoming", false); | |
| 911 predefined_devices->Append(unconnectable.Pass()); | |
| 912 | |
| 913 scoped_ptr<base::DictionaryValue> unpairable(new base::DictionaryValue); | |
| 914 unpairable->SetString("path", kUnpairableDevicePath); | |
| 915 unpairable->SetString("address", kUnpairableDeviceAddress); | |
| 916 unpairable->SetString("name", kUnpairableDeviceName); | |
| 917 unpairable->SetString("alias", kUnpairableDeviceName); | |
| 918 unpairable->SetString("pairingMethod", ""); | |
| 919 unpairable->SetString("pairingAuthToken", ""); | |
| 920 unpairable->SetString("pairingAction", kPairingActionFail); | |
| 921 unpairable->SetInteger("classValue", kUnpairableDeviceClass); | |
| 922 unpairable->SetBoolean("isTrusted", false); | |
| 923 unpairable->SetBoolean("discoverable", false); | |
| 924 unpairable->SetBoolean("paired", false); | |
| 925 unpairable->SetBoolean("incoming", false); | |
| 926 predefined_devices->Append(unpairable.Pass()); | |
| 927 | |
| 928 scoped_ptr<base::DictionaryValue> just_works(new base::DictionaryValue); | |
| 929 just_works->SetString("path", kJustWorksPath); | |
| 930 just_works->SetString("address", kJustWorksAddress); | |
| 931 just_works->SetString("name", kJustWorksName); | |
| 932 just_works->SetString("alias", kJustWorksName); | |
| 933 just_works->SetString("pairingMethod", ""); | |
| 934 just_works->SetString("pairingAuthToken", ""); | |
| 935 just_works->SetString("pairingAction", ""); | |
| 936 just_works->SetInteger("classValue", kJustWorksClass); | |
| 937 just_works->SetBoolean("isTrusted", false); | |
| 938 just_works->SetBoolean("discoverable", false); | |
| 939 just_works->SetBoolean("paired", false); | |
| 940 just_works->SetBoolean("incoming", false); | |
| 941 predefined_devices->Append(just_works.Pass()); | |
| 942 | |
| 943 scoped_ptr<base::DictionaryValue> low_energy(new base::DictionaryValue); | |
| 944 low_energy->SetString("path", kLowEnergyPath); | |
| 945 low_energy->SetString("address", kLowEnergyAddress); | |
| 946 low_energy->SetString("name", kLowEnergyName); | |
| 947 low_energy->SetString("alias", kLowEnergyName); | |
| 948 low_energy->SetString("pairingMethod", ""); | |
| 949 low_energy->SetString("pairingAuthToken", ""); | |
| 950 low_energy->SetString("pairingAction", ""); | |
| 951 low_energy->SetInteger("classValue", kLowEnergyClass); | |
| 952 low_energy->SetBoolean("isTrusted", false); | |
| 953 low_energy->SetBoolean("discoverable", false); | |
| 954 low_energy->SetBoolean("paireed", false); | |
| 955 low_energy->SetBoolean("incoming", false); | |
| 956 predefined_devices->Append(low_energy.Pass()); | |
| 957 | |
| 958 scoped_ptr<base::DictionaryValue> paired_unconnectable( | |
| 959 new base::DictionaryValue); | |
| 960 paired_unconnectable->SetString("path", kPairedUnconnectableDevicePath); | |
| 961 paired_unconnectable->SetString("address", kPairedUnconnectableDeviceAddress); | |
| 962 paired_unconnectable->SetString("name", kPairedUnconnectableDeviceName); | |
| 963 paired_unconnectable->SetString("pairingMethod", ""); | |
| 964 paired_unconnectable->SetString("pairingAuthToken", ""); | |
| 965 paired_unconnectable->SetString("pairingAction", ""); | |
| 966 paired_unconnectable->SetString("alias", kPairedUnconnectableDeviceName); | |
| 967 paired_unconnectable->SetInteger("classValue", | |
| 968 kPairedUnconnectableDeviceClass); | |
| 969 paired_unconnectable->SetBoolean("isTrusted", false); | |
| 970 paired_unconnectable->SetBoolean("discoverable", true); | |
| 971 paired_unconnectable->SetBoolean("paired", true); | |
| 972 paired_unconnectable->SetBoolean("incoming", false); | |
| 973 predefined_devices->Append(paired_unconnectable.Pass()); | |
| 974 | |
| 975 return predefined_devices.Pass(); | |
| 976 } | |
| 977 | |
| 978 void FakeBluetoothDeviceClient::RemoveDevice( | |
| 979 const dbus::ObjectPath& adapter_path, | |
| 980 const dbus::ObjectPath& device_path) { | |
| 981 std::vector<dbus::ObjectPath>::iterator listiter = | |
| 982 std::find(device_list_.begin(), device_list_.end(), device_path); | |
| 983 if (listiter == device_list_.end()) | |
| 984 return; | |
| 985 | |
| 986 PropertiesMap::const_iterator iter = properties_map_.find(device_path); | |
| 987 Properties* properties = iter->second; | |
| 988 | |
| 989 VLOG(1) << "removing device: " << properties->alias.value(); | |
| 990 device_list_.erase(listiter); | |
| 991 | |
| 992 // Remove the Input interface if it exists. This should be called before the | |
| 993 // BluetoothDeviceClient::Observer::DeviceRemoved because it deletes the | |
| 994 // BluetoothDeviceChromeOS object, including the device_path referenced here. | |
| 995 FakeBluetoothInputClient* fake_bluetooth_input_client = | |
| 996 static_cast<FakeBluetoothInputClient*>( | |
| 997 DBusThreadManager::Get()->GetBluetoothInputClient()); | |
| 998 fake_bluetooth_input_client->RemoveInputDevice(device_path); | |
| 999 | |
| 1000 if (device_path == dbus::ObjectPath(kLowEnergyPath)) { | |
| 1001 FakeBluetoothGattServiceClient* gatt_service_client = | |
| 1002 static_cast<FakeBluetoothGattServiceClient*>( | |
| 1003 DBusThreadManager::Get()->GetBluetoothGattServiceClient()); | |
| 1004 gatt_service_client->HideHeartRateService(); | |
| 1005 } | |
| 1006 | |
| 1007 FOR_EACH_OBSERVER(BluetoothDeviceClient::Observer, observers_, | |
| 1008 DeviceRemoved(device_path)); | |
| 1009 | |
| 1010 properties_map_.erase(iter); | |
| 1011 PairingOptionsMap::const_iterator options_iter = | |
| 1012 pairing_options_map_.find(device_path); | |
| 1013 | |
| 1014 if (options_iter != pairing_options_map_.end()) { | |
| 1015 pairing_options_map_.erase(options_iter); | |
| 1016 } | |
| 1017 } | |
| 1018 | |
| 1019 void FakeBluetoothDeviceClient::OnPropertyChanged( | |
| 1020 const dbus::ObjectPath& object_path, | |
| 1021 const std::string& property_name) { | |
| 1022 VLOG(2) << "Fake Bluetooth device property changed: " << object_path.value() | |
| 1023 << ": " << property_name; | |
| 1024 FOR_EACH_OBSERVER(BluetoothDeviceClient::Observer, observers_, | |
| 1025 DevicePropertyChanged(object_path, property_name)); | |
| 1026 } | |
| 1027 | |
| 1028 void FakeBluetoothDeviceClient::DiscoverySimulationTimer() { | |
| 1029 if (!discovery_simulation_step_) | |
| 1030 return; | |
| 1031 | |
| 1032 // Timer fires every .75s, the numbers below are arbitrary to give a feel | |
| 1033 // for a discovery process. | |
| 1034 VLOG(1) << "discovery simulation, step " << discovery_simulation_step_; | |
| 1035 if (discovery_simulation_step_ == 2) { | |
| 1036 CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), | |
| 1037 dbus::ObjectPath(kLegacyAutopairPath)); | |
| 1038 CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), | |
| 1039 dbus::ObjectPath(kLowEnergyPath)); | |
| 1040 | |
| 1041 } else if (discovery_simulation_step_ == 4) { | |
| 1042 UpdateDeviceRSSI(dbus::ObjectPath(kLowEnergyPath), | |
| 1043 base::RandInt(kMinRSSI, kMaxRSSI)); | |
| 1044 CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), | |
| 1045 dbus::ObjectPath(kDisplayPinCodePath)); | |
| 1046 CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), | |
| 1047 dbus::ObjectPath(kVanishingDevicePath)); | |
| 1048 | |
| 1049 } else if (discovery_simulation_step_ == 7) { | |
| 1050 CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), | |
| 1051 dbus::ObjectPath(kConnectUnpairablePath)); | |
| 1052 UpdateDeviceRSSI(dbus::ObjectPath(kLowEnergyPath), | |
| 1053 base::RandInt(kMinRSSI, kMaxRSSI)); | |
| 1054 | |
| 1055 } else if (discovery_simulation_step_ == 8) { | |
| 1056 CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), | |
| 1057 dbus::ObjectPath(kDisplayPasskeyPath)); | |
| 1058 CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), | |
| 1059 dbus::ObjectPath(kRequestPinCodePath)); | |
| 1060 UpdateDeviceRSSI(dbus::ObjectPath(kLowEnergyPath), | |
| 1061 base::RandInt(kMinRSSI, kMaxRSSI)); | |
| 1062 | |
| 1063 } else if (discovery_simulation_step_ == 10) { | |
| 1064 CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), | |
| 1065 dbus::ObjectPath(kConfirmPasskeyPath)); | |
| 1066 CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), | |
| 1067 dbus::ObjectPath(kRequestPasskeyPath)); | |
| 1068 CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), | |
| 1069 dbus::ObjectPath(kUnconnectableDevicePath)); | |
| 1070 CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), | |
| 1071 dbus::ObjectPath(kUnpairableDevicePath)); | |
| 1072 CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), | |
| 1073 dbus::ObjectPath(kJustWorksPath)); | |
| 1074 UpdateDeviceRSSI(dbus::ObjectPath(kLowEnergyPath), | |
| 1075 base::RandInt(kMinRSSI, kMaxRSSI)); | |
| 1076 | |
| 1077 } else if (discovery_simulation_step_ == 13) { | |
| 1078 UpdateDeviceRSSI(dbus::ObjectPath(kLowEnergyPath), | |
| 1079 base::RandInt(kMinRSSI, kMaxRSSI)); | |
| 1080 RemoveDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), | |
| 1081 dbus::ObjectPath(kVanishingDevicePath)); | |
| 1082 } else if (discovery_simulation_step_ == 14) { | |
| 1083 UpdateDeviceRSSI(dbus::ObjectPath(kLowEnergyPath), | |
| 1084 base::RandInt(kMinRSSI, kMaxRSSI)); | |
| 1085 return; | |
| 1086 | |
| 1087 } | |
| 1088 | |
| 1089 ++discovery_simulation_step_; | |
| 1090 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1091 FROM_HERE, | |
| 1092 base::Bind(&FakeBluetoothDeviceClient::DiscoverySimulationTimer, | |
| 1093 base::Unretained(this)), | |
| 1094 base::TimeDelta::FromMilliseconds(simulation_interval_ms_)); | |
| 1095 } | |
| 1096 | |
| 1097 void FakeBluetoothDeviceClient::IncomingPairingSimulationTimer() { | |
| 1098 if (!incoming_pairing_simulation_step_) | |
| 1099 return; | |
| 1100 | |
| 1101 VLOG(1) << "incoming pairing simulation, step " | |
| 1102 << incoming_pairing_simulation_step_; | |
| 1103 switch (incoming_pairing_simulation_step_) { | |
| 1104 case 1: | |
| 1105 CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), | |
| 1106 dbus::ObjectPath(kConfirmPasskeyPath)); | |
| 1107 SimulatePairing(dbus::ObjectPath(kConfirmPasskeyPath), true, | |
| 1108 base::Bind(&base::DoNothing), | |
| 1109 base::Bind(&SimpleErrorCallback)); | |
| 1110 break; | |
| 1111 case 2: | |
| 1112 CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), | |
| 1113 dbus::ObjectPath(kJustWorksPath)); | |
| 1114 SimulatePairing(dbus::ObjectPath(kJustWorksPath), true, | |
| 1115 base::Bind(&base::DoNothing), | |
| 1116 base::Bind(&SimpleErrorCallback)); | |
| 1117 break; | |
| 1118 case 3: | |
| 1119 CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), | |
| 1120 dbus::ObjectPath(kDisplayPinCodePath)); | |
| 1121 SimulatePairing(dbus::ObjectPath(kDisplayPinCodePath), true, | |
| 1122 base::Bind(&base::DoNothing), | |
| 1123 base::Bind(&SimpleErrorCallback)); | |
| 1124 break; | |
| 1125 case 4: | |
| 1126 CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), | |
| 1127 dbus::ObjectPath(kDisplayPasskeyPath)); | |
| 1128 SimulatePairing(dbus::ObjectPath(kDisplayPasskeyPath), true, | |
| 1129 base::Bind(&base::DoNothing), | |
| 1130 base::Bind(&SimpleErrorCallback)); | |
| 1131 break; | |
| 1132 case 5: | |
| 1133 CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), | |
| 1134 dbus::ObjectPath(kRequestPinCodePath)); | |
| 1135 SimulatePairing(dbus::ObjectPath(kRequestPinCodePath), true, | |
| 1136 base::Bind(&base::DoNothing), | |
| 1137 base::Bind(&SimpleErrorCallback)); | |
| 1138 break; | |
| 1139 case 6: | |
| 1140 CreateDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), | |
| 1141 dbus::ObjectPath(kRequestPasskeyPath)); | |
| 1142 SimulatePairing(dbus::ObjectPath(kRequestPasskeyPath), true, | |
| 1143 base::Bind(&base::DoNothing), | |
| 1144 base::Bind(&SimpleErrorCallback)); | |
| 1145 break; | |
| 1146 default: | |
| 1147 return; | |
| 1148 } | |
| 1149 | |
| 1150 ++incoming_pairing_simulation_step_; | |
| 1151 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1152 FROM_HERE, | |
| 1153 base::Bind(&FakeBluetoothDeviceClient::IncomingPairingSimulationTimer, | |
| 1154 base::Unretained(this)), | |
| 1155 base::TimeDelta::FromMilliseconds(kIncomingSimulationPairTimeMultiplier * | |
| 1156 simulation_interval_ms_)); | |
| 1157 } | |
| 1158 | |
| 1159 void FakeBluetoothDeviceClient::SimulatePairing( | |
| 1160 const dbus::ObjectPath& object_path, | |
| 1161 bool incoming_request, | |
| 1162 const base::Closure& callback, | |
| 1163 const ErrorCallback& error_callback) { | |
| 1164 pairing_cancelled_ = false; | |
| 1165 | |
| 1166 FakeBluetoothAgentManagerClient* fake_bluetooth_agent_manager_client = | |
| 1167 static_cast<FakeBluetoothAgentManagerClient*>( | |
| 1168 DBusThreadManager::Get()->GetBluetoothAgentManagerClient()); | |
| 1169 FakeBluetoothAgentServiceProvider* agent_service_provider = | |
| 1170 fake_bluetooth_agent_manager_client->GetAgentServiceProvider(); | |
| 1171 CHECK(agent_service_provider != NULL); | |
| 1172 | |
| 1173 // Grab the device's pairing properties. | |
| 1174 PairingOptionsMap::const_iterator iter = | |
| 1175 pairing_options_map_.find(object_path); | |
| 1176 | |
| 1177 // If the device with path |object_path| has simulated pairing properties | |
| 1178 // defined, then pair it based on its |pairing_method|. | |
| 1179 if (iter != pairing_options_map_.end()) { | |
| 1180 if (iter->second->pairing_action == kPairingActionFail) { | |
| 1181 // Fails the pairing with an org.bluez.Error.Failed error. | |
| 1182 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1183 FROM_HERE, | |
| 1184 base::Bind(&FakeBluetoothDeviceClient::FailSimulatedPairing, | |
| 1185 base::Unretained(this), object_path, error_callback), | |
| 1186 base::TimeDelta::FromMilliseconds(simulation_interval_ms_)); | |
| 1187 } else if (iter->second->pairing_method == kPairingMethodNone || | |
| 1188 iter->second->pairing_method.empty()) { | |
| 1189 if (!iter->second->incoming) { | |
| 1190 // Simply pair and connect the device. | |
| 1191 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1192 FROM_HERE, | |
| 1193 base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing, | |
| 1194 base::Unretained(this), object_path, callback, | |
| 1195 error_callback), | |
| 1196 base::TimeDelta::FromMilliseconds( | |
| 1197 kSimulateNormalPairTimeMultiplier * simulation_interval_ms_)); | |
| 1198 } else { | |
| 1199 agent_service_provider->RequestAuthorization( | |
| 1200 object_path, | |
| 1201 base::Bind(&FakeBluetoothDeviceClient::ConfirmationCallback, | |
| 1202 base::Unretained(this), object_path, callback, | |
| 1203 error_callback)); | |
| 1204 } | |
| 1205 } else if (iter->second->pairing_method == kPairingMethodPinCode) { | |
| 1206 if (iter->second->pairing_action == kPairingActionDisplay) { | |
| 1207 // Display a Pincode, and wait before acting as if the other end | |
| 1208 // accepted it. | |
| 1209 agent_service_provider->DisplayPinCode( | |
| 1210 object_path, iter->second->pairing_auth_token); | |
| 1211 | |
| 1212 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1213 FROM_HERE, | |
| 1214 base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing, | |
| 1215 base::Unretained(this), object_path, callback, | |
| 1216 error_callback), | |
| 1217 base::TimeDelta::FromMilliseconds(kPinCodeDevicePairTimeMultiplier * | |
| 1218 simulation_interval_ms_)); | |
| 1219 } else if (iter->second->pairing_action == kPairingActionRequest) { | |
| 1220 // Request a pin code. | |
| 1221 agent_service_provider->RequestPinCode( | |
| 1222 object_path, base::Bind(&FakeBluetoothDeviceClient::PinCodeCallback, | |
| 1223 base::Unretained(this), object_path, | |
| 1224 callback, error_callback)); | |
| 1225 } else if (iter->second->pairing_action == kPairingActionConfirmation) { | |
| 1226 error_callback.Run(kNoResponseError, "No confirm for pincode pairing."); | |
| 1227 } | |
| 1228 } else if (iter->second->pairing_method == kPairingMethodPassKey) { | |
| 1229 // Display a passkey, and each interval act as if another key was entered | |
| 1230 // for it. | |
| 1231 if (iter->second->pairing_action == kPairingActionDisplay) { | |
| 1232 agent_service_provider->DisplayPasskey( | |
| 1233 object_path, std::stoi(iter->second->pairing_auth_token), 0); | |
| 1234 | |
| 1235 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1236 FROM_HERE, base::Bind(&FakeBluetoothDeviceClient::SimulateKeypress, | |
| 1237 base::Unretained(this), 1, object_path, | |
| 1238 callback, error_callback), | |
| 1239 base::TimeDelta::FromMilliseconds(simulation_interval_ms_)); | |
| 1240 } else if (iter->second->pairing_action == kPairingActionRequest) { | |
| 1241 agent_service_provider->RequestPasskey( | |
| 1242 object_path, base::Bind(&FakeBluetoothDeviceClient::PasskeyCallback, | |
| 1243 base::Unretained(this), object_path, | |
| 1244 callback, error_callback)); | |
| 1245 } else if (iter->second->pairing_action == kPairingActionConfirmation) { | |
| 1246 agent_service_provider->RequestConfirmation( | |
| 1247 object_path, std::stoi(iter->second->pairing_auth_token), | |
| 1248 base::Bind(&FakeBluetoothDeviceClient::ConfirmationCallback, | |
| 1249 base::Unretained(this), object_path, callback, | |
| 1250 error_callback)); | |
| 1251 } | |
| 1252 } | |
| 1253 } else { | |
| 1254 if (object_path == dbus::ObjectPath(kLegacyAutopairPath) || | |
| 1255 object_path == dbus::ObjectPath(kConnectUnpairablePath) || | |
| 1256 object_path == dbus::ObjectPath(kUnconnectableDevicePath) || | |
| 1257 object_path == dbus::ObjectPath(kLowEnergyPath)) { | |
| 1258 // No need to call anything on the pairing delegate, just wait 3 times | |
| 1259 // the interval before acting as if the other end accepted it. | |
| 1260 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1261 FROM_HERE, | |
| 1262 base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing, | |
| 1263 base::Unretained(this), object_path, callback, | |
| 1264 error_callback), | |
| 1265 base::TimeDelta::FromMilliseconds(kSimulateNormalPairTimeMultiplier * | |
| 1266 simulation_interval_ms_)); | |
| 1267 | |
| 1268 } else if (object_path == dbus::ObjectPath(kDisplayPinCodePath)) { | |
| 1269 // Display a Pincode, and wait before acting as if the other end accepted | |
| 1270 // it. | |
| 1271 agent_service_provider->DisplayPinCode(object_path, kTestPinCode); | |
| 1272 | |
| 1273 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1274 FROM_HERE, | |
| 1275 base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing, | |
| 1276 base::Unretained(this), object_path, callback, | |
| 1277 error_callback), | |
| 1278 base::TimeDelta::FromMilliseconds(kPinCodeDevicePairTimeMultiplier * | |
| 1279 simulation_interval_ms_)); | |
| 1280 | |
| 1281 } else if (object_path == dbus::ObjectPath(kVanishingDevicePath)) { | |
| 1282 // The vanishing device simulates being too far away, and thus times out. | |
| 1283 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1284 FROM_HERE, | |
| 1285 base::Bind(&FakeBluetoothDeviceClient::TimeoutSimulatedPairing, | |
| 1286 base::Unretained(this), object_path, error_callback), | |
| 1287 base::TimeDelta::FromMilliseconds(kVanishingDevicePairTimeMultiplier * | |
| 1288 simulation_interval_ms_)); | |
| 1289 | |
| 1290 } else if (object_path == dbus::ObjectPath(kDisplayPasskeyPath)) { | |
| 1291 // Display a passkey, and each interval act as if another key was entered | |
| 1292 // for it. | |
| 1293 agent_service_provider->DisplayPasskey(object_path, kTestPassKey, 0); | |
| 1294 | |
| 1295 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1296 FROM_HERE, base::Bind(&FakeBluetoothDeviceClient::SimulateKeypress, | |
| 1297 base::Unretained(this), 1, object_path, | |
| 1298 callback, error_callback), | |
| 1299 base::TimeDelta::FromMilliseconds(simulation_interval_ms_)); | |
| 1300 | |
| 1301 } else if (object_path == dbus::ObjectPath(kRequestPinCodePath)) { | |
| 1302 // Request a Pincode. | |
| 1303 agent_service_provider->RequestPinCode( | |
| 1304 object_path, base::Bind(&FakeBluetoothDeviceClient::PinCodeCallback, | |
| 1305 base::Unretained(this), object_path, callback, | |
| 1306 error_callback)); | |
| 1307 | |
| 1308 } else if (object_path == dbus::ObjectPath(kConfirmPasskeyPath)) { | |
| 1309 // Request confirmation of a Passkey. | |
| 1310 agent_service_provider->RequestConfirmation( | |
| 1311 object_path, kTestPassKey, | |
| 1312 base::Bind(&FakeBluetoothDeviceClient::ConfirmationCallback, | |
| 1313 base::Unretained(this), object_path, callback, | |
| 1314 error_callback)); | |
| 1315 | |
| 1316 } else if (object_path == dbus::ObjectPath(kRequestPasskeyPath)) { | |
| 1317 // Request a Passkey from the user. | |
| 1318 agent_service_provider->RequestPasskey( | |
| 1319 object_path, base::Bind(&FakeBluetoothDeviceClient::PasskeyCallback, | |
| 1320 base::Unretained(this), object_path, callback, | |
| 1321 error_callback)); | |
| 1322 | |
| 1323 } else if (object_path == dbus::ObjectPath(kUnpairableDevicePath)) { | |
| 1324 // Fails the pairing with an org.bluez.Error.Failed error. | |
| 1325 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1326 FROM_HERE, | |
| 1327 base::Bind(&FakeBluetoothDeviceClient::FailSimulatedPairing, | |
| 1328 base::Unretained(this), object_path, error_callback), | |
| 1329 base::TimeDelta::FromMilliseconds(simulation_interval_ms_)); | |
| 1330 | |
| 1331 } else if (object_path == dbus::ObjectPath(kJustWorksPath)) { | |
| 1332 if (incoming_request) { | |
| 1333 agent_service_provider->RequestAuthorization( | |
| 1334 object_path, | |
| 1335 base::Bind(&FakeBluetoothDeviceClient::ConfirmationCallback, | |
| 1336 base::Unretained(this), object_path, callback, | |
| 1337 error_callback)); | |
| 1338 | |
| 1339 } else { | |
| 1340 // No need to call anything on the pairing delegate, just wait before | |
| 1341 // acting as if the other end accepted it. | |
| 1342 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1343 FROM_HERE, | |
| 1344 base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing, | |
| 1345 base::Unretained(this), object_path, callback, | |
| 1346 error_callback), | |
| 1347 base::TimeDelta::FromMilliseconds( | |
| 1348 kSimulateNormalPairTimeMultiplier * simulation_interval_ms_)); | |
| 1349 } | |
| 1350 | |
| 1351 } else { | |
| 1352 error_callback.Run(kNoResponseError, "No pairing fake"); | |
| 1353 } | |
| 1354 } | |
| 1355 } | |
| 1356 | |
| 1357 void FakeBluetoothDeviceClient::CompleteSimulatedPairing( | |
| 1358 const dbus::ObjectPath& object_path, | |
| 1359 const base::Closure& callback, | |
| 1360 const ErrorCallback& error_callback) { | |
| 1361 VLOG(1) << "CompleteSimulatedPairing: " << object_path.value(); | |
| 1362 if (pairing_cancelled_) { | |
| 1363 pairing_cancelled_ = false; | |
| 1364 | |
| 1365 error_callback.Run(bluetooth_device::kErrorAuthenticationCanceled, | |
| 1366 "Cancelled"); | |
| 1367 } else { | |
| 1368 Properties* properties = GetProperties(object_path); | |
| 1369 | |
| 1370 properties->paired.ReplaceValue(true); | |
| 1371 callback.Run(); | |
| 1372 | |
| 1373 AddInputDeviceIfNeeded(object_path, properties); | |
| 1374 } | |
| 1375 } | |
| 1376 | |
| 1377 void FakeBluetoothDeviceClient::TimeoutSimulatedPairing( | |
| 1378 const dbus::ObjectPath& object_path, | |
| 1379 const ErrorCallback& error_callback) { | |
| 1380 VLOG(1) << "TimeoutSimulatedPairing: " << object_path.value(); | |
| 1381 | |
| 1382 error_callback.Run(bluetooth_device::kErrorAuthenticationTimeout, | |
| 1383 "Timed out"); | |
| 1384 } | |
| 1385 | |
| 1386 void FakeBluetoothDeviceClient::CancelSimulatedPairing( | |
| 1387 const dbus::ObjectPath& object_path, | |
| 1388 const ErrorCallback& error_callback) { | |
| 1389 VLOG(1) << "CancelSimulatedPairing: " << object_path.value(); | |
| 1390 | |
| 1391 error_callback.Run(bluetooth_device::kErrorAuthenticationCanceled, | |
| 1392 "Canceled"); | |
| 1393 } | |
| 1394 | |
| 1395 void FakeBluetoothDeviceClient::RejectSimulatedPairing( | |
| 1396 const dbus::ObjectPath& object_path, | |
| 1397 const ErrorCallback& error_callback) { | |
| 1398 VLOG(1) << "RejectSimulatedPairing: " << object_path.value(); | |
| 1399 | |
| 1400 error_callback.Run(bluetooth_device::kErrorAuthenticationRejected, | |
| 1401 "Rejected"); | |
| 1402 } | |
| 1403 | |
| 1404 void FakeBluetoothDeviceClient::FailSimulatedPairing( | |
| 1405 const dbus::ObjectPath& object_path, | |
| 1406 const ErrorCallback& error_callback) { | |
| 1407 VLOG(1) << "FailSimulatedPairing: " << object_path.value(); | |
| 1408 | |
| 1409 error_callback.Run(bluetooth_device::kErrorFailed, "Failed"); | |
| 1410 } | |
| 1411 | |
| 1412 void FakeBluetoothDeviceClient::AddInputDeviceIfNeeded( | |
| 1413 const dbus::ObjectPath& object_path, | |
| 1414 Properties* properties) { | |
| 1415 // If the paired device is a HID device based on it's bluetooth class, | |
| 1416 // simulate the Input interface. | |
| 1417 FakeBluetoothInputClient* fake_bluetooth_input_client = | |
| 1418 static_cast<FakeBluetoothInputClient*>( | |
| 1419 DBusThreadManager::Get()->GetBluetoothInputClient()); | |
| 1420 | |
| 1421 if ((properties->bluetooth_class.value() & 0x001f03) == 0x000500) | |
| 1422 fake_bluetooth_input_client->AddInputDevice(object_path); | |
| 1423 } | |
| 1424 | |
| 1425 void FakeBluetoothDeviceClient::UpdateDeviceRSSI( | |
| 1426 const dbus::ObjectPath& object_path, | |
| 1427 int16 rssi) { | |
| 1428 PropertiesMap::const_iterator iter = properties_map_.find(object_path); | |
| 1429 if (iter == properties_map_.end()) { | |
| 1430 VLOG(2) << "Fake device does not exist: " << object_path.value(); | |
| 1431 return; | |
| 1432 } | |
| 1433 Properties* properties = iter->second; | |
| 1434 DCHECK(properties); | |
| 1435 properties->rssi.ReplaceValue(rssi); | |
| 1436 } | |
| 1437 | |
| 1438 void FakeBluetoothDeviceClient::UpdateConnectionInfo( | |
| 1439 uint16 connection_rssi, | |
| 1440 uint16 transmit_power, | |
| 1441 uint16 max_transmit_power) { | |
| 1442 connection_rssi_ = connection_rssi; | |
| 1443 transmit_power_ = transmit_power; | |
| 1444 max_transmit_power_ = max_transmit_power; | |
| 1445 } | |
| 1446 | |
| 1447 void FakeBluetoothDeviceClient::PinCodeCallback( | |
| 1448 const dbus::ObjectPath& object_path, | |
| 1449 const base::Closure& callback, | |
| 1450 const ErrorCallback& error_callback, | |
| 1451 BluetoothAgentServiceProvider::Delegate::Status status, | |
| 1452 const std::string& pincode) { | |
| 1453 VLOG(1) << "PinCodeCallback: " << object_path.value(); | |
| 1454 | |
| 1455 if (status == BluetoothAgentServiceProvider::Delegate::SUCCESS) { | |
| 1456 PairingOptionsMap::const_iterator iter = | |
| 1457 pairing_options_map_.find(object_path); | |
| 1458 | |
| 1459 bool success = true; | |
| 1460 | |
| 1461 // If the device has pairing options defined | |
| 1462 if (iter != pairing_options_map_.end()) { | |
| 1463 success = iter->second->pairing_auth_token == pincode; | |
| 1464 } | |
| 1465 | |
| 1466 if (success) { | |
| 1467 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1468 FROM_HERE, | |
| 1469 base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing, | |
| 1470 base::Unretained(this), object_path, callback, | |
| 1471 error_callback), | |
| 1472 base::TimeDelta::FromMilliseconds(kSimulateNormalPairTimeMultiplier * | |
| 1473 simulation_interval_ms_)); | |
| 1474 } else { | |
| 1475 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1476 FROM_HERE, | |
| 1477 base::Bind(&FakeBluetoothDeviceClient::RejectSimulatedPairing, | |
| 1478 base::Unretained(this), object_path, error_callback), | |
| 1479 base::TimeDelta::FromMilliseconds(simulation_interval_ms_)); | |
| 1480 } | |
| 1481 | |
| 1482 } else if (status == BluetoothAgentServiceProvider::Delegate::CANCELLED) { | |
| 1483 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1484 FROM_HERE, | |
| 1485 base::Bind(&FakeBluetoothDeviceClient::CancelSimulatedPairing, | |
| 1486 base::Unretained(this), object_path, error_callback), | |
| 1487 base::TimeDelta::FromMilliseconds(simulation_interval_ms_)); | |
| 1488 | |
| 1489 } else if (status == BluetoothAgentServiceProvider::Delegate::REJECTED) { | |
| 1490 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1491 FROM_HERE, | |
| 1492 base::Bind(&FakeBluetoothDeviceClient::RejectSimulatedPairing, | |
| 1493 base::Unretained(this), object_path, error_callback), | |
| 1494 base::TimeDelta::FromMilliseconds(simulation_interval_ms_)); | |
| 1495 } | |
| 1496 } | |
| 1497 | |
| 1498 void FakeBluetoothDeviceClient::PasskeyCallback( | |
| 1499 const dbus::ObjectPath& object_path, | |
| 1500 const base::Closure& callback, | |
| 1501 const ErrorCallback& error_callback, | |
| 1502 BluetoothAgentServiceProvider::Delegate::Status status, | |
| 1503 uint32 passkey) { | |
| 1504 VLOG(1) << "PasskeyCallback: " << object_path.value(); | |
| 1505 | |
| 1506 if (status == BluetoothAgentServiceProvider::Delegate::SUCCESS) { | |
| 1507 PairingOptionsMap::const_iterator iter = | |
| 1508 pairing_options_map_.find(object_path); | |
| 1509 bool success = true; | |
| 1510 | |
| 1511 if (iter != pairing_options_map_.end()) { | |
| 1512 success = static_cast<uint32>( | |
| 1513 std::stoi(iter->second->pairing_auth_token)) == passkey; | |
| 1514 } | |
| 1515 | |
| 1516 if (success) { | |
| 1517 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1518 FROM_HERE, | |
| 1519 base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing, | |
| 1520 base::Unretained(this), object_path, callback, | |
| 1521 error_callback), | |
| 1522 base::TimeDelta::FromMilliseconds(kSimulateNormalPairTimeMultiplier * | |
| 1523 simulation_interval_ms_)); | |
| 1524 } else { | |
| 1525 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1526 FROM_HERE, | |
| 1527 base::Bind(&FakeBluetoothDeviceClient::RejectSimulatedPairing, | |
| 1528 base::Unretained(this), object_path, error_callback), | |
| 1529 base::TimeDelta::FromMilliseconds(simulation_interval_ms_)); | |
| 1530 } | |
| 1531 | |
| 1532 } else if (status == BluetoothAgentServiceProvider::Delegate::CANCELLED) { | |
| 1533 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1534 FROM_HERE, | |
| 1535 base::Bind(&FakeBluetoothDeviceClient::CancelSimulatedPairing, | |
| 1536 base::Unretained(this), object_path, error_callback), | |
| 1537 base::TimeDelta::FromMilliseconds(simulation_interval_ms_)); | |
| 1538 | |
| 1539 } else if (status == BluetoothAgentServiceProvider::Delegate::REJECTED) { | |
| 1540 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1541 FROM_HERE, | |
| 1542 base::Bind(&FakeBluetoothDeviceClient::RejectSimulatedPairing, | |
| 1543 base::Unretained(this), object_path, error_callback), | |
| 1544 base::TimeDelta::FromMilliseconds(simulation_interval_ms_)); | |
| 1545 } | |
| 1546 } | |
| 1547 | |
| 1548 void FakeBluetoothDeviceClient::ConfirmationCallback( | |
| 1549 const dbus::ObjectPath& object_path, | |
| 1550 const base::Closure& callback, | |
| 1551 const ErrorCallback& error_callback, | |
| 1552 BluetoothAgentServiceProvider::Delegate::Status status) { | |
| 1553 VLOG(1) << "ConfirmationCallback: " << object_path.value(); | |
| 1554 | |
| 1555 if (status == BluetoothAgentServiceProvider::Delegate::SUCCESS) { | |
| 1556 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1557 FROM_HERE, | |
| 1558 base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing, | |
| 1559 base::Unretained(this), object_path, callback, | |
| 1560 error_callback), | |
| 1561 base::TimeDelta::FromMilliseconds(kSimulateNormalPairTimeMultiplier * | |
| 1562 simulation_interval_ms_)); | |
| 1563 | |
| 1564 } else if (status == BluetoothAgentServiceProvider::Delegate::CANCELLED) { | |
| 1565 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1566 FROM_HERE, | |
| 1567 base::Bind(&FakeBluetoothDeviceClient::CancelSimulatedPairing, | |
| 1568 base::Unretained(this), object_path, error_callback), | |
| 1569 base::TimeDelta::FromMilliseconds(simulation_interval_ms_)); | |
| 1570 | |
| 1571 } else if (status == BluetoothAgentServiceProvider::Delegate::REJECTED) { | |
| 1572 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1573 FROM_HERE, | |
| 1574 base::Bind(&FakeBluetoothDeviceClient::RejectSimulatedPairing, | |
| 1575 base::Unretained(this), object_path, error_callback), | |
| 1576 base::TimeDelta::FromMilliseconds(simulation_interval_ms_)); | |
| 1577 } | |
| 1578 } | |
| 1579 | |
| 1580 void FakeBluetoothDeviceClient::SimulateKeypress( | |
| 1581 uint16 entered, | |
| 1582 const dbus::ObjectPath& object_path, | |
| 1583 const base::Closure& callback, | |
| 1584 const ErrorCallback& error_callback) { | |
| 1585 VLOG(1) << "SimulateKeypress " << entered << ": " << object_path.value(); | |
| 1586 | |
| 1587 FakeBluetoothAgentManagerClient* fake_bluetooth_agent_manager_client = | |
| 1588 static_cast<FakeBluetoothAgentManagerClient*>( | |
| 1589 DBusThreadManager::Get()->GetBluetoothAgentManagerClient()); | |
| 1590 FakeBluetoothAgentServiceProvider* agent_service_provider = | |
| 1591 fake_bluetooth_agent_manager_client->GetAgentServiceProvider(); | |
| 1592 | |
| 1593 // The agent service provider object could have been destroyed after the | |
| 1594 // pairing is canceled. | |
| 1595 if (!agent_service_provider) | |
| 1596 return; | |
| 1597 | |
| 1598 agent_service_provider->DisplayPasskey(object_path, kTestPassKey, entered); | |
| 1599 | |
| 1600 if (entered < 7) { | |
| 1601 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1602 FROM_HERE, base::Bind(&FakeBluetoothDeviceClient::SimulateKeypress, | |
| 1603 base::Unretained(this), entered + 1, object_path, | |
| 1604 callback, error_callback), | |
| 1605 base::TimeDelta::FromMilliseconds(simulation_interval_ms_)); | |
| 1606 | |
| 1607 } else { | |
| 1608 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 1609 FROM_HERE, | |
| 1610 base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing, | |
| 1611 base::Unretained(this), object_path, callback, | |
| 1612 error_callback), | |
| 1613 base::TimeDelta::FromMilliseconds(simulation_interval_ms_)); | |
| 1614 } | |
| 1615 } | |
| 1616 | |
| 1617 void FakeBluetoothDeviceClient::ConnectionCallback( | |
| 1618 const dbus::ObjectPath& object_path, | |
| 1619 const base::Closure& callback, | |
| 1620 const ErrorCallback& error_callback, | |
| 1621 BluetoothProfileServiceProvider::Delegate::Status status) { | |
| 1622 VLOG(1) << "ConnectionCallback: " << object_path.value(); | |
| 1623 | |
| 1624 if (status == BluetoothProfileServiceProvider::Delegate::SUCCESS) { | |
| 1625 callback.Run(); | |
| 1626 } else if (status == BluetoothProfileServiceProvider::Delegate::CANCELLED) { | |
| 1627 // TODO(keybuk): tear down this side of the connection | |
| 1628 error_callback.Run(bluetooth_device::kErrorFailed, "Canceled"); | |
| 1629 } else if (status == BluetoothProfileServiceProvider::Delegate::REJECTED) { | |
| 1630 // TODO(keybuk): tear down this side of the connection | |
| 1631 error_callback.Run(bluetooth_device::kErrorFailed, "Rejected"); | |
| 1632 } | |
| 1633 } | |
| 1634 | |
| 1635 void FakeBluetoothDeviceClient::DisconnectionCallback( | |
| 1636 const dbus::ObjectPath& object_path, | |
| 1637 const base::Closure& callback, | |
| 1638 const ErrorCallback& error_callback, | |
| 1639 BluetoothProfileServiceProvider::Delegate::Status status) { | |
| 1640 VLOG(1) << "DisconnectionCallback: " << object_path.value(); | |
| 1641 | |
| 1642 if (status == BluetoothProfileServiceProvider::Delegate::SUCCESS) { | |
| 1643 // TODO(keybuk): tear down this side of the connection | |
| 1644 callback.Run(); | |
| 1645 } else if (status == BluetoothProfileServiceProvider::Delegate::CANCELLED) { | |
| 1646 error_callback.Run(bluetooth_device::kErrorFailed, "Canceled"); | |
| 1647 } else if (status == BluetoothProfileServiceProvider::Delegate::REJECTED) { | |
| 1648 error_callback.Run(bluetooth_device::kErrorFailed, "Rejected"); | |
| 1649 } | |
| 1650 } | |
| 1651 | |
| 1652 } // namespace chromeos | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1347193004:
Refactor DBusThreadManager to split away BT clients. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master