Gallery.app: Remove the video related code from Gallery.
[chromium-blink-merge.git] / device / bluetooth / bluetooth_device_chromeos.cc
blobc8085699ef6b0231a2685fcf9c3a0d3197649672
1 // Copyright 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.
5 #include "device/bluetooth/bluetooth_device_chromeos.h"
7 #include <stdio.h>
9 #include "base/bind.h"
10 #include "base/memory/scoped_ptr.h"
11 #include "base/metrics/histogram.h"
12 #include "base/strings/string_number_conversions.h"
13 #include "base/strings/string_util.h"
14 #include "chromeos/dbus/bluetooth_adapter_client.h"
15 #include "chromeos/dbus/bluetooth_device_client.h"
16 #include "chromeos/dbus/bluetooth_gatt_service_client.h"
17 #include "chromeos/dbus/bluetooth_input_client.h"
18 #include "chromeos/dbus/dbus_thread_manager.h"
19 #include "dbus/bus.h"
20 #include "device/bluetooth/bluetooth_adapter_chromeos.h"
21 #include "device/bluetooth/bluetooth_gatt_connection_chromeos.h"
22 #include "device/bluetooth/bluetooth_pairing_chromeos.h"
23 #include "device/bluetooth/bluetooth_remote_gatt_service_chromeos.h"
24 #include "device/bluetooth/bluetooth_socket.h"
25 #include "device/bluetooth/bluetooth_socket_chromeos.h"
26 #include "device/bluetooth/bluetooth_socket_thread.h"
27 #include "device/bluetooth/bluetooth_uuid.h"
28 #include "third_party/cros_system_api/dbus/service_constants.h"
30 using device::BluetoothDevice;
31 using device::BluetoothSocket;
32 using device::BluetoothUUID;
34 namespace {
36 // Histogram enumerations for pairing results.
37 enum UMAPairingResult {
38 UMA_PAIRING_RESULT_SUCCESS,
39 UMA_PAIRING_RESULT_INPROGRESS,
40 UMA_PAIRING_RESULT_FAILED,
41 UMA_PAIRING_RESULT_AUTH_FAILED,
42 UMA_PAIRING_RESULT_AUTH_CANCELED,
43 UMA_PAIRING_RESULT_AUTH_REJECTED,
44 UMA_PAIRING_RESULT_AUTH_TIMEOUT,
45 UMA_PAIRING_RESULT_UNSUPPORTED_DEVICE,
46 UMA_PAIRING_RESULT_UNKNOWN_ERROR,
47 // NOTE: Add new pairing results immediately above this line. Make sure to
48 // update the enum list in tools/histogram/histograms.xml accordinly.
49 UMA_PAIRING_RESULT_COUNT
52 void ParseModalias(const dbus::ObjectPath& object_path,
53 BluetoothDevice::VendorIDSource* vendor_id_source,
54 uint16* vendor_id,
55 uint16* product_id,
56 uint16* device_id) {
57 chromeos::BluetoothDeviceClient::Properties* properties =
58 chromeos::DBusThreadManager::Get()->GetBluetoothDeviceClient()->
59 GetProperties(object_path);
60 DCHECK(properties);
62 std::string modalias = properties->modalias.value();
63 BluetoothDevice::VendorIDSource source_value;
64 int vendor_value, product_value, device_value;
66 if (sscanf(modalias.c_str(), "bluetooth:v%04xp%04xd%04x",
67 &vendor_value, &product_value, &device_value) == 3) {
68 source_value = BluetoothDevice::VENDOR_ID_BLUETOOTH;
69 } else if (sscanf(modalias.c_str(), "usb:v%04xp%04xd%04x",
70 &vendor_value, &product_value, &device_value) == 3) {
71 source_value = BluetoothDevice::VENDOR_ID_USB;
72 } else {
73 return;
76 if (vendor_id_source != NULL)
77 *vendor_id_source = source_value;
78 if (vendor_id != NULL)
79 *vendor_id = vendor_value;
80 if (product_id != NULL)
81 *product_id = product_value;
82 if (device_id != NULL)
83 *device_id = device_value;
86 void RecordPairingResult(BluetoothDevice::ConnectErrorCode error_code) {
87 UMAPairingResult pairing_result;
88 switch (error_code) {
89 case BluetoothDevice::ERROR_INPROGRESS:
90 pairing_result = UMA_PAIRING_RESULT_INPROGRESS;
91 break;
92 case BluetoothDevice::ERROR_FAILED:
93 pairing_result = UMA_PAIRING_RESULT_FAILED;
94 break;
95 case BluetoothDevice::ERROR_AUTH_FAILED:
96 pairing_result = UMA_PAIRING_RESULT_AUTH_FAILED;
97 break;
98 case BluetoothDevice::ERROR_AUTH_CANCELED:
99 pairing_result = UMA_PAIRING_RESULT_AUTH_CANCELED;
100 break;
101 case BluetoothDevice::ERROR_AUTH_REJECTED:
102 pairing_result = UMA_PAIRING_RESULT_AUTH_REJECTED;
103 break;
104 case BluetoothDevice::ERROR_AUTH_TIMEOUT:
105 pairing_result = UMA_PAIRING_RESULT_AUTH_TIMEOUT;
106 break;
107 case BluetoothDevice::ERROR_UNSUPPORTED_DEVICE:
108 pairing_result = UMA_PAIRING_RESULT_UNSUPPORTED_DEVICE;
109 break;
110 default:
111 pairing_result = UMA_PAIRING_RESULT_UNKNOWN_ERROR;
114 UMA_HISTOGRAM_ENUMERATION("Bluetooth.PairingResult",
115 pairing_result,
116 UMA_PAIRING_RESULT_COUNT);
119 } // namespace
121 namespace chromeos {
123 BluetoothDeviceChromeOS::BluetoothDeviceChromeOS(
124 BluetoothAdapterChromeOS* adapter,
125 const dbus::ObjectPath& object_path,
126 scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
127 scoped_refptr<device::BluetoothSocketThread> socket_thread)
128 : adapter_(adapter),
129 object_path_(object_path),
130 num_connecting_calls_(0),
131 connection_monitor_started_(false),
132 ui_task_runner_(ui_task_runner),
133 socket_thread_(socket_thread),
134 weak_ptr_factory_(this) {
135 DBusThreadManager::Get()->GetBluetoothGattServiceClient()->AddObserver(this);
137 // Add all known GATT services.
138 const std::vector<dbus::ObjectPath> gatt_services =
139 DBusThreadManager::Get()->GetBluetoothGattServiceClient()->GetServices();
140 for (std::vector<dbus::ObjectPath>::const_iterator it = gatt_services.begin();
141 it != gatt_services.end(); ++it) {
142 GattServiceAdded(*it);
146 BluetoothDeviceChromeOS::~BluetoothDeviceChromeOS() {
147 DBusThreadManager::Get()->GetBluetoothGattServiceClient()->
148 RemoveObserver(this);
150 // Copy the GATT services list here and clear the original so that when we
151 // send GattServiceRemoved(), GetGattServices() returns no services.
152 GattServiceMap gatt_services = gatt_services_;
153 gatt_services_.clear();
154 for (GattServiceMap::iterator iter = gatt_services.begin();
155 iter != gatt_services.end(); ++iter) {
156 FOR_EACH_OBSERVER(BluetoothDevice::Observer, observers_,
157 GattServiceRemoved(this, iter->second));
158 delete iter->second;
162 void BluetoothDeviceChromeOS::AddObserver(
163 device::BluetoothDevice::Observer* observer) {
164 DCHECK(observer);
165 observers_.AddObserver(observer);
168 void BluetoothDeviceChromeOS::RemoveObserver(
169 device::BluetoothDevice::Observer* observer) {
170 DCHECK(observer);
171 observers_.RemoveObserver(observer);
174 uint32 BluetoothDeviceChromeOS::GetBluetoothClass() const {
175 BluetoothDeviceClient::Properties* properties =
176 DBusThreadManager::Get()->GetBluetoothDeviceClient()->
177 GetProperties(object_path_);
178 DCHECK(properties);
180 return properties->bluetooth_class.value();
183 std::string BluetoothDeviceChromeOS::GetDeviceName() const {
184 BluetoothDeviceClient::Properties* properties =
185 DBusThreadManager::Get()->GetBluetoothDeviceClient()->
186 GetProperties(object_path_);
187 DCHECK(properties);
189 return properties->alias.value();
192 std::string BluetoothDeviceChromeOS::GetAddress() const {
193 BluetoothDeviceClient::Properties* properties =
194 DBusThreadManager::Get()->GetBluetoothDeviceClient()->
195 GetProperties(object_path_);
196 DCHECK(properties);
198 return CanonicalizeAddress(properties->address.value());
201 BluetoothDevice::VendorIDSource
202 BluetoothDeviceChromeOS::GetVendorIDSource() const {
203 VendorIDSource vendor_id_source = VENDOR_ID_UNKNOWN;
204 ParseModalias(object_path_, &vendor_id_source, NULL, NULL, NULL);
205 return vendor_id_source;
208 uint16 BluetoothDeviceChromeOS::GetVendorID() const {
209 uint16 vendor_id = 0;
210 ParseModalias(object_path_, NULL, &vendor_id, NULL, NULL);
211 return vendor_id;
214 uint16 BluetoothDeviceChromeOS::GetProductID() const {
215 uint16 product_id = 0;
216 ParseModalias(object_path_, NULL, NULL, &product_id, NULL);
217 return product_id;
220 uint16 BluetoothDeviceChromeOS::GetDeviceID() const {
221 uint16 device_id = 0;
222 ParseModalias(object_path_, NULL, NULL, NULL, &device_id);
223 return device_id;
226 int BluetoothDeviceChromeOS::GetRSSI() const {
227 BluetoothDeviceClient::Properties* properties =
228 DBusThreadManager::Get()->GetBluetoothDeviceClient()->GetProperties(
229 object_path_);
230 DCHECK(properties);
232 if (!IsConnected()) {
233 NOTIMPLEMENTED();
234 return kUnknownPower;
237 return connection_monitor_started_ ? properties->connection_rssi.value()
238 : kUnknownPower;
241 int BluetoothDeviceChromeOS::GetCurrentHostTransmitPower() const {
242 BluetoothDeviceClient::Properties* properties =
243 DBusThreadManager::Get()->GetBluetoothDeviceClient()->GetProperties(
244 object_path_);
245 DCHECK(properties);
247 return IsConnected() && connection_monitor_started_
248 ? properties->connection_tx_power.value()
249 : kUnknownPower;
252 int BluetoothDeviceChromeOS::GetMaximumHostTransmitPower() const {
253 BluetoothDeviceClient::Properties* properties =
254 DBusThreadManager::Get()->GetBluetoothDeviceClient()->GetProperties(
255 object_path_);
256 DCHECK(properties);
258 return IsConnected() ? properties->connection_tx_power_max.value()
259 : kUnknownPower;
262 bool BluetoothDeviceChromeOS::IsPaired() const {
263 BluetoothDeviceClient::Properties* properties =
264 DBusThreadManager::Get()->GetBluetoothDeviceClient()->
265 GetProperties(object_path_);
266 DCHECK(properties);
268 // Trusted devices are devices that don't support pairing but that the
269 // user has explicitly connected; it makes no sense for UI purposes to
270 // treat them differently from each other.
271 return properties->paired.value() || properties->trusted.value();
274 bool BluetoothDeviceChromeOS::IsConnected() const {
275 BluetoothDeviceClient::Properties* properties =
276 DBusThreadManager::Get()->GetBluetoothDeviceClient()->
277 GetProperties(object_path_);
278 DCHECK(properties);
280 return properties->connected.value();
283 bool BluetoothDeviceChromeOS::IsConnectable() const {
284 BluetoothInputClient::Properties* input_properties =
285 DBusThreadManager::Get()->GetBluetoothInputClient()->
286 GetProperties(object_path_);
287 // GetProperties returns NULL when the device does not implement the given
288 // interface. Non HID devices are normally connectable.
289 if (!input_properties)
290 return true;
292 return input_properties->reconnect_mode.value() != "device";
295 bool BluetoothDeviceChromeOS::IsConnecting() const {
296 return num_connecting_calls_ > 0;
299 BluetoothDeviceChromeOS::UUIDList BluetoothDeviceChromeOS::GetUUIDs() const {
300 BluetoothDeviceClient::Properties* properties =
301 DBusThreadManager::Get()->GetBluetoothDeviceClient()->
302 GetProperties(object_path_);
303 DCHECK(properties);
305 std::vector<device::BluetoothUUID> uuids;
306 const std::vector<std::string> &dbus_uuids = properties->uuids.value();
307 for (std::vector<std::string>::const_iterator iter = dbus_uuids.begin();
308 iter != dbus_uuids.end(); ++iter) {
309 device::BluetoothUUID uuid(*iter);
310 DCHECK(uuid.IsValid());
311 uuids.push_back(uuid);
313 return uuids;
316 bool BluetoothDeviceChromeOS::ExpectingPinCode() const {
317 return pairing_.get() && pairing_->ExpectingPinCode();
320 bool BluetoothDeviceChromeOS::ExpectingPasskey() const {
321 return pairing_.get() && pairing_->ExpectingPasskey();
324 bool BluetoothDeviceChromeOS::ExpectingConfirmation() const {
325 return pairing_.get() && pairing_->ExpectingConfirmation();
328 void BluetoothDeviceChromeOS::Connect(
329 BluetoothDevice::PairingDelegate* pairing_delegate,
330 const base::Closure& callback,
331 const ConnectErrorCallback& error_callback) {
332 if (num_connecting_calls_++ == 0)
333 adapter_->NotifyDeviceChanged(this);
335 VLOG(1) << object_path_.value() << ": Connecting, " << num_connecting_calls_
336 << " in progress";
338 if (IsPaired() || !pairing_delegate || !IsPairable()) {
339 // No need to pair, or unable to, skip straight to connection.
340 ConnectInternal(false, callback, error_callback);
341 } else {
342 // Initiate high-security connection with pairing.
343 BeginPairing(pairing_delegate);
345 DBusThreadManager::Get()->GetBluetoothDeviceClient()->
346 Pair(object_path_,
347 base::Bind(&BluetoothDeviceChromeOS::OnPair,
348 weak_ptr_factory_.GetWeakPtr(),
349 callback, error_callback),
350 base::Bind(&BluetoothDeviceChromeOS::OnPairError,
351 weak_ptr_factory_.GetWeakPtr(),
352 error_callback));
356 void BluetoothDeviceChromeOS::SetPinCode(const std::string& pincode) {
357 if (!pairing_.get())
358 return;
360 pairing_->SetPinCode(pincode);
363 void BluetoothDeviceChromeOS::SetPasskey(uint32 passkey) {
364 if (!pairing_.get())
365 return;
367 pairing_->SetPasskey(passkey);
370 void BluetoothDeviceChromeOS::ConfirmPairing() {
371 if (!pairing_.get())
372 return;
374 pairing_->ConfirmPairing();
377 void BluetoothDeviceChromeOS::RejectPairing() {
378 if (!pairing_.get())
379 return;
381 pairing_->RejectPairing();
384 void BluetoothDeviceChromeOS::CancelPairing() {
385 bool canceled = false;
387 // If there is a callback in progress that we can reply to then use that
388 // to cancel the current pairing request.
389 if (pairing_.get() && pairing_->CancelPairing())
390 canceled = true;
392 // If not we have to send an explicit CancelPairing() to the device instead.
393 if (!canceled) {
394 VLOG(1) << object_path_.value() << ": No pairing context or callback. "
395 << "Sending explicit cancel";
396 DBusThreadManager::Get()->GetBluetoothDeviceClient()->
397 CancelPairing(
398 object_path_,
399 base::Bind(&base::DoNothing),
400 base::Bind(&BluetoothDeviceChromeOS::OnCancelPairingError,
401 weak_ptr_factory_.GetWeakPtr()));
404 // Since there is no callback to this method it's possible that the pairing
405 // delegate is going to be freed before things complete (indeed it's
406 // documented that this is the method you should call while freeing the
407 // pairing delegate), so clear our the context holding on to it.
408 EndPairing();
411 void BluetoothDeviceChromeOS::Disconnect(const base::Closure& callback,
412 const ErrorCallback& error_callback) {
413 VLOG(1) << object_path_.value() << ": Disconnecting";
414 DBusThreadManager::Get()->GetBluetoothDeviceClient()->
415 Disconnect(
416 object_path_,
417 base::Bind(&BluetoothDeviceChromeOS::OnDisconnect,
418 weak_ptr_factory_.GetWeakPtr(),
419 callback),
420 base::Bind(&BluetoothDeviceChromeOS::OnDisconnectError,
421 weak_ptr_factory_.GetWeakPtr(),
422 error_callback));
425 void BluetoothDeviceChromeOS::Forget(const ErrorCallback& error_callback) {
426 VLOG(1) << object_path_.value() << ": Removing device";
427 DBusThreadManager::Get()->GetBluetoothAdapterClient()->
428 RemoveDevice(
429 adapter_->object_path(),
430 object_path_,
431 base::Bind(&base::DoNothing),
432 base::Bind(&BluetoothDeviceChromeOS::OnForgetError,
433 weak_ptr_factory_.GetWeakPtr(),
434 error_callback));
437 void BluetoothDeviceChromeOS::ConnectToService(
438 const BluetoothUUID& uuid,
439 const ConnectToServiceCallback& callback,
440 const ConnectToServiceErrorCallback& error_callback) {
441 VLOG(1) << object_path_.value() << ": Connecting to service: "
442 << uuid.canonical_value();
443 scoped_refptr<BluetoothSocketChromeOS> socket =
444 BluetoothSocketChromeOS::CreateBluetoothSocket(
445 ui_task_runner_,
446 socket_thread_,
447 NULL,
448 net::NetLog::Source());
449 socket->Connect(this, uuid,
450 base::Bind(callback, socket),
451 error_callback);
454 void BluetoothDeviceChromeOS::CreateGattConnection(
455 const GattConnectionCallback& callback,
456 const ConnectErrorCallback& error_callback) {
457 // TODO(armansito): Until there is a way to create a reference counted GATT
458 // connection in bluetoothd, simply do a regular connect.
459 Connect(NULL,
460 base::Bind(&BluetoothDeviceChromeOS::OnCreateGattConnection,
461 weak_ptr_factory_.GetWeakPtr(),
462 callback),
463 error_callback);
466 void BluetoothDeviceChromeOS::StartConnectionMonitor(
467 const base::Closure& callback,
468 const ErrorCallback& error_callback) {
469 DBusThreadManager::Get()->GetBluetoothDeviceClient()->StartConnectionMonitor(
470 object_path_,
471 base::Bind(&BluetoothDeviceChromeOS::OnStartConnectionMonitor,
472 weak_ptr_factory_.GetWeakPtr(),
473 callback),
474 base::Bind(&BluetoothDeviceChromeOS::OnStartConnectionMonitorError,
475 weak_ptr_factory_.GetWeakPtr(),
476 error_callback));
479 BluetoothPairingChromeOS* BluetoothDeviceChromeOS::BeginPairing(
480 BluetoothDevice::PairingDelegate* pairing_delegate) {
481 pairing_.reset(new BluetoothPairingChromeOS(this, pairing_delegate));
482 return pairing_.get();
485 void BluetoothDeviceChromeOS::EndPairing() {
486 pairing_.reset();
489 BluetoothPairingChromeOS* BluetoothDeviceChromeOS::GetPairing() const {
490 return pairing_.get();
493 void BluetoothDeviceChromeOS::GattServiceAdded(
494 const dbus::ObjectPath& object_path) {
495 if (GetGattService(object_path.value())) {
496 VLOG(1) << "Remote GATT service already exists: " << object_path.value();
497 return;
500 BluetoothGattServiceClient::Properties* properties =
501 DBusThreadManager::Get()->GetBluetoothGattServiceClient()->
502 GetProperties(object_path);
503 DCHECK(properties);
504 if (properties->device.value() != object_path_) {
505 VLOG(2) << "Remote GATT service does not belong to this device.";
506 return;
509 VLOG(1) << "Adding new remote GATT service for device: " << GetAddress();
511 BluetoothRemoteGattServiceChromeOS* service =
512 new BluetoothRemoteGattServiceChromeOS(this, object_path);
513 gatt_services_[service->GetIdentifier()] = service;
514 DCHECK(service->object_path() == object_path);
515 DCHECK(service->GetUUID().IsValid());
517 FOR_EACH_OBSERVER(device::BluetoothDevice::Observer, observers_,
518 GattServiceAdded(this, service));
521 void BluetoothDeviceChromeOS::GattServiceRemoved(
522 const dbus::ObjectPath& object_path) {
523 GattServiceMap::iterator iter = gatt_services_.find(object_path.value());
524 if (iter == gatt_services_.end()) {
525 VLOG(2) << "Unknown GATT service removed: " << object_path.value();
526 return;
529 VLOG(1) << "Removing remote GATT service from device: " << GetAddress();
531 BluetoothRemoteGattServiceChromeOS* service =
532 static_cast<BluetoothRemoteGattServiceChromeOS*>(iter->second);
533 DCHECK(service->object_path() == object_path);
534 gatt_services_.erase(iter);
535 FOR_EACH_OBSERVER(device::BluetoothDevice::Observer, observers_,
536 GattServiceRemoved(this, service));
537 delete service;
540 void BluetoothDeviceChromeOS::ConnectInternal(
541 bool after_pairing,
542 const base::Closure& callback,
543 const ConnectErrorCallback& error_callback) {
544 VLOG(1) << object_path_.value() << ": Connecting";
545 DBusThreadManager::Get()->GetBluetoothDeviceClient()->
546 Connect(
547 object_path_,
548 base::Bind(&BluetoothDeviceChromeOS::OnConnect,
549 weak_ptr_factory_.GetWeakPtr(),
550 after_pairing,
551 callback),
552 base::Bind(&BluetoothDeviceChromeOS::OnConnectError,
553 weak_ptr_factory_.GetWeakPtr(),
554 after_pairing,
555 error_callback));
558 void BluetoothDeviceChromeOS::OnConnect(bool after_pairing,
559 const base::Closure& callback) {
560 if (--num_connecting_calls_ == 0)
561 adapter_->NotifyDeviceChanged(this);
563 DCHECK(num_connecting_calls_ >= 0);
564 VLOG(1) << object_path_.value() << ": Connected, " << num_connecting_calls_
565 << " still in progress";
567 SetTrusted();
569 if (after_pairing)
570 UMA_HISTOGRAM_ENUMERATION("Bluetooth.PairingResult",
571 UMA_PAIRING_RESULT_SUCCESS,
572 UMA_PAIRING_RESULT_COUNT);
574 callback.Run();
577 void BluetoothDeviceChromeOS::OnCreateGattConnection(
578 const GattConnectionCallback& callback) {
579 scoped_ptr<device::BluetoothGattConnection> conn(
580 new BluetoothGattConnectionChromeOS(
581 adapter_, GetAddress(), object_path_));
582 callback.Run(conn.Pass());
585 void BluetoothDeviceChromeOS::OnConnectError(
586 bool after_pairing,
587 const ConnectErrorCallback& error_callback,
588 const std::string& error_name,
589 const std::string& error_message) {
590 if (--num_connecting_calls_ == 0)
591 adapter_->NotifyDeviceChanged(this);
593 DCHECK(num_connecting_calls_ >= 0);
594 LOG(WARNING) << object_path_.value() << ": Failed to connect device: "
595 << error_name << ": " << error_message;
596 VLOG(1) << object_path_.value() << ": " << num_connecting_calls_
597 << " still in progress";
599 // Determine the error code from error_name.
600 ConnectErrorCode error_code = ERROR_UNKNOWN;
601 if (error_name == bluetooth_device::kErrorFailed) {
602 error_code = ERROR_FAILED;
603 } else if (error_name == bluetooth_device::kErrorInProgress) {
604 error_code = ERROR_INPROGRESS;
605 } else if (error_name == bluetooth_device::kErrorNotSupported) {
606 error_code = ERROR_UNSUPPORTED_DEVICE;
609 if (after_pairing)
610 RecordPairingResult(error_code);
611 error_callback.Run(error_code);
614 void BluetoothDeviceChromeOS::OnPair(
615 const base::Closure& callback,
616 const ConnectErrorCallback& error_callback) {
617 VLOG(1) << object_path_.value() << ": Paired";
619 EndPairing();
621 ConnectInternal(true, callback, error_callback);
624 void BluetoothDeviceChromeOS::OnPairError(
625 const ConnectErrorCallback& error_callback,
626 const std::string& error_name,
627 const std::string& error_message) {
628 if (--num_connecting_calls_ == 0)
629 adapter_->NotifyDeviceChanged(this);
631 DCHECK(num_connecting_calls_ >= 0);
632 LOG(WARNING) << object_path_.value() << ": Failed to pair device: "
633 << error_name << ": " << error_message;
634 VLOG(1) << object_path_.value() << ": " << num_connecting_calls_
635 << " still in progress";
637 EndPairing();
639 // Determine the error code from error_name.
640 ConnectErrorCode error_code = ERROR_UNKNOWN;
641 if (error_name == bluetooth_device::kErrorConnectionAttemptFailed) {
642 error_code = ERROR_FAILED;
643 } else if (error_name == bluetooth_device::kErrorFailed) {
644 error_code = ERROR_FAILED;
645 } else if (error_name == bluetooth_device::kErrorAuthenticationFailed) {
646 error_code = ERROR_AUTH_FAILED;
647 } else if (error_name == bluetooth_device::kErrorAuthenticationCanceled) {
648 error_code = ERROR_AUTH_CANCELED;
649 } else if (error_name == bluetooth_device::kErrorAuthenticationRejected) {
650 error_code = ERROR_AUTH_REJECTED;
651 } else if (error_name == bluetooth_device::kErrorAuthenticationTimeout) {
652 error_code = ERROR_AUTH_TIMEOUT;
655 RecordPairingResult(error_code);
656 error_callback.Run(error_code);
659 void BluetoothDeviceChromeOS::OnCancelPairingError(
660 const std::string& error_name,
661 const std::string& error_message) {
662 LOG(WARNING) << object_path_.value() << ": Failed to cancel pairing: "
663 << error_name << ": " << error_message;
666 void BluetoothDeviceChromeOS::SetTrusted() {
667 // Unconditionally send the property change, rather than checking the value
668 // first; there's no harm in doing this and it solves any race conditions
669 // with the property becoming true or false and this call happening before
670 // we get the D-Bus signal about the earlier change.
671 DBusThreadManager::Get()->GetBluetoothDeviceClient()->
672 GetProperties(object_path_)->trusted.Set(
673 true,
674 base::Bind(&BluetoothDeviceChromeOS::OnSetTrusted,
675 weak_ptr_factory_.GetWeakPtr()));
678 void BluetoothDeviceChromeOS::OnSetTrusted(bool success) {
679 LOG_IF(WARNING, !success) << object_path_.value()
680 << ": Failed to set device as trusted";
683 void BluetoothDeviceChromeOS::OnStartConnectionMonitor(
684 const base::Closure& callback) {
685 connection_monitor_started_ = true;
686 callback.Run();
689 void BluetoothDeviceChromeOS::OnStartConnectionMonitorError(
690 const ErrorCallback& error_callback,
691 const std::string& error_name,
692 const std::string& error_message) {
693 LOG(WARNING) << object_path_.value()
694 << ": Failed to start connection monitor: " << error_name << ": "
695 << error_message;
696 error_callback.Run();
699 void BluetoothDeviceChromeOS::OnDisconnect(const base::Closure& callback) {
700 VLOG(1) << object_path_.value() << ": Disconnected";
701 callback.Run();
704 void BluetoothDeviceChromeOS::OnDisconnectError(
705 const ErrorCallback& error_callback,
706 const std::string& error_name,
707 const std::string& error_message) {
708 LOG(WARNING) << object_path_.value() << ": Failed to disconnect device: "
709 << error_name << ": " << error_message;
710 error_callback.Run();
713 void BluetoothDeviceChromeOS::OnForgetError(
714 const ErrorCallback& error_callback,
715 const std::string& error_name,
716 const std::string& error_message) {
717 LOG(WARNING) << object_path_.value() << ": Failed to remove device: "
718 << error_name << ": " << error_message;
719 error_callback.Run();
722 } // namespace chromeos