Index: chrome/browser/chromeos/login/screens/hid_detection_screen.cc |
diff --git a/chrome/browser/chromeos/login/screens/hid_detection_screen.cc b/chrome/browser/chromeos/login/screens/hid_detection_screen.cc |
index 99b6e48098a52fc6fc06853437608cb022e30f90..d797df7f9e5fabcb965439958d6095c17a5c9ef9 100644 |
--- a/chrome/browser/chromeos/login/screens/hid_detection_screen.cc |
+++ b/chrome/browser/chromeos/login/screens/hid_detection_screen.cc |
@@ -4,48 +4,545 @@ |
#include "chrome/browser/chromeos/login/screens/hid_detection_screen.h" |
+#include "base/bind.h" |
+#include "base/metrics/histogram.h" |
+#include "base/strings/string_number_conversions.h" |
+#include "base/strings/utf_string_conversions.h" |
#include "chrome/browser/chromeos/login/screens/base_screen_delegate.h" |
+#include "chrome/browser/chromeos/login/screens/hid_detection_view.h" |
#include "chrome/browser/chromeos/login/wizard_controller.h" |
+#include "chrome/grit/generated_resources.h" |
+#include "device/bluetooth/bluetooth_adapter_factory.h" |
+#include "ui/base/l10n/l10n_util.h" |
+ |
+namespace { |
+ |
+// Possible ui-states for device-blocks. |
+const char kSearchingState[] = "searching"; |
+const char kUSBConnectedState[] = "connected"; |
+const char kBTPairedState[] = "paired"; |
+const char kBTPairingState[] = "pairing"; |
+ |
+// Standard length of pincode for pairing BT keyboards. |
+const int kPincodeLength = 6; |
+ |
+bool DeviceIsPointing(device::BluetoothDevice::DeviceType device_type) { |
+ return device_type == device::BluetoothDevice::DEVICE_MOUSE || |
+ device_type == device::BluetoothDevice::DEVICE_KEYBOARD_MOUSE_COMBO || |
+ device_type == device::BluetoothDevice::DEVICE_TABLET; |
+} |
+ |
+bool DeviceIsPointing(const device::InputServiceLinux::InputDeviceInfo& info) { |
+ return info.is_mouse || info.is_touchpad || info.is_touchscreen || |
+ info.is_tablet; |
+} |
+ |
+bool DeviceIsKeyboard(device::BluetoothDevice::DeviceType device_type) { |
+ return device_type == device::BluetoothDevice::DEVICE_KEYBOARD || |
+ device_type == device::BluetoothDevice::DEVICE_KEYBOARD_MOUSE_COMBO; |
+} |
+ |
+} // namespace |
namespace chromeos { |
HIDDetectionScreen::HIDDetectionScreen(BaseScreenDelegate* base_screen_delegate, |
- HIDDetectionScreenActor* actor) |
- : BaseScreen(base_screen_delegate), actor_(actor) { |
- DCHECK(actor_); |
- if (actor_) |
- actor_->SetDelegate(this); |
+ HIDDetectionView* view) |
+ : HIDDetectionModel(base_screen_delegate), |
+ view_(view), |
+ mouse_is_pairing_(false), |
+ pointing_device_connect_type_(InputDeviceInfo::TYPE_UNKNOWN), |
+ keyboard_is_pairing_(false), |
+ keyboard_device_connect_type_(InputDeviceInfo::TYPE_UNKNOWN), |
+ switch_on_adapter_when_ready_(false), |
+ showing_(false), |
+ weak_ptr_factory_(this) { |
+ DCHECK(view_); |
+ if (view_) |
+ view_->Bind(*this); |
+ |
} |
HIDDetectionScreen::~HIDDetectionScreen() { |
- if (actor_) |
- actor_->SetDelegate(NULL); |
+ adapter_initially_powered_.reset(); |
+ input_service_proxy_.RemoveObserver(this); |
+ if (view_) |
+ view_->Unbind(); |
+ if (discovery_session_.get()) |
+ discovery_session_->Stop(base::Bind(&base::DoNothing), |
+ base::Bind(&base::DoNothing)); |
+ if (adapter_.get()) |
+ adapter_->RemoveObserver(this); |
} |
void HIDDetectionScreen::PrepareToShow() { |
+ if (view_) |
+ view_->PrepareToShow(); |
} |
void HIDDetectionScreen::Show() { |
- if (actor_) |
- actor_->Show(); |
+ showing_ = true; |
+ context_.SetInteger(kContextKeyNumKeysEnteredExpected, false); |
+ SendPointingDeviceNotification(); |
+ SendKeyboardDeviceNotification(); |
+ |
+ input_service_proxy_.AddObserver(this); |
+ UpdateDevices(); |
+ |
+ if (view_) |
+ view_->Show(); |
} |
void HIDDetectionScreen::Hide() { |
- if (actor_) |
- actor_->Hide(); |
+ showing_ = false; |
+ input_service_proxy_.RemoveObserver(this); |
+ if (discovery_session_.get()) |
+ discovery_session_->Stop(base::Bind(&base::DoNothing), |
+ base::Bind(&base::DoNothing)); |
+ if (view_) |
+ view_->Hide(); |
} |
-std::string HIDDetectionScreen::GetName() const { |
- return WizardController::kHIDDetectionScreenName; |
+void HIDDetectionScreen::Initialize(::login::ScreenContext* context) { |
+ HIDDetectionModel::Initialize(context); |
+ |
+ device::BluetoothAdapterFactory::GetAdapter( |
+ base::Bind(&HIDDetectionScreen::InitializeAdapter, |
+ weak_ptr_factory_.GetWeakPtr())); |
} |
-void HIDDetectionScreen::OnExit() { |
+void HIDDetectionScreen::OnContinueButtonClicked() { |
+ |
+ ContinueScenarioType scenario_type; |
+ if (!pointing_device_id_.empty() && !keyboard_device_id_.empty()) |
+ scenario_type = All_DEVICES_DETECTED; |
+ else if (pointing_device_id_.empty()) |
+ scenario_type = KEYBOARD_DEVICE_ONLY_DETECTED; |
+ else |
+ scenario_type = POINTING_DEVICE_ONLY_DETECTED; |
+ |
+ UMA_HISTOGRAM_ENUMERATION( |
+ "HIDDetection.OOBEDevicesDetectedOnContinuePressed", |
+ scenario_type, |
+ CONTINUE_SCENARIO_TYPE_SIZE); |
+ |
+ // Switch off BT adapter if it was off before the screen and no BT device |
+ // connected. |
+ bool adapter_is_powered = |
+ adapter_.get() && adapter_->IsPresent() && adapter_->IsPowered(); |
+ bool use_bluetooth = |
+ pointing_device_connect_type_ == InputDeviceInfo::TYPE_BLUETOOTH || |
+ keyboard_device_connect_type_ == InputDeviceInfo::TYPE_BLUETOOTH; |
+ bool need_switching_off = adapter_initially_powered_ && |
+ !(*adapter_initially_powered_); |
+ if (adapter_is_powered && !use_bluetooth && need_switching_off) { |
+ VLOG(1) << "Switching off BT adapter after HID OOBE screen as unused."; |
+ adapter_->SetPowered( |
+ false, |
+ base::Bind(&base::DoNothing), |
+ base::Bind(&HIDDetectionScreen::SetPoweredOffError, |
+ weak_ptr_factory_.GetWeakPtr())); |
+ } |
+ |
Finish(BaseScreenDelegate::HID_DETECTION_COMPLETED); |
} |
-void HIDDetectionScreen::OnActorDestroyed(HIDDetectionScreenActor* actor) { |
- if (actor_ == actor) |
- actor_ = NULL; |
+void HIDDetectionScreen::CheckIsScreenRequired( |
+ const base::Callback<void(bool)>& on_check_done) { |
+ input_service_proxy_.GetDevices( |
+ base::Bind(&HIDDetectionScreen::OnGetInputDevicesListForCheck, |
+ weak_ptr_factory_.GetWeakPtr(), |
+ on_check_done)); |
+} |
+ |
+void HIDDetectionScreen::OnViewDestroyed(HIDDetectionView* view) { |
+ if (view_ == view) |
+ view_ = NULL; |
+} |
+ |
+void HIDDetectionScreen::RequestPinCode(device::BluetoothDevice* device) { |
+ VLOG(1) << "RequestPinCode id = " << device->GetDeviceID() |
+ << " name = " << device->GetName(); |
+ device->CancelPairing(); |
+} |
+ |
+void HIDDetectionScreen::RequestPasskey(device::BluetoothDevice* device) { |
+ VLOG(1) << "RequestPassKey id = " << device->GetDeviceID() |
+ << " name = " << device->GetName(); |
+ device->CancelPairing(); |
+} |
+ |
+void HIDDetectionScreen::DisplayPinCode(device::BluetoothDevice* device, |
+ const std::string& pincode) { |
+ VLOG(1) << "DisplayPinCode id = " << device->GetDeviceID() |
+ << " name = " << device->GetName(); |
+ context_.SetString(kContextKeyPinCode, pincode); |
+ SetKeyboardDeviceName_(base::UTF16ToUTF8(device->GetName())); |
+ SendKeyboardDeviceNotification(); |
+ CommitContextChanges(); |
+} |
+ |
+void HIDDetectionScreen::DisplayPasskey( |
+ device::BluetoothDevice* device, uint32 passkey) { |
+ VLOG(1) << "DisplayPassKey id = " << device->GetDeviceID() |
+ << " name = " << device->GetName(); |
+ std::string pincode = base::UintToString(passkey); |
+ pincode = std::string(kPincodeLength - pincode.length(), '0').append(pincode); |
+ // No differences in UI for passkey and pincode authentication calls. |
+ DisplayPinCode(device, pincode); |
+} |
+ |
+void HIDDetectionScreen::KeysEntered( |
+ device::BluetoothDevice* device, uint32 entered) { |
+ VLOG(1) << "Number of keys entered " << entered; |
+ base::DictionaryValue params; |
+ context_.SetInteger(kContextKeyNumKeysEnteredExpected, true); |
+ context_.SetInteger(kContextKeyNumKeysEnteredPinCode, entered); |
Denis Kuznetsov (DE-MUC)
2015/02/05 13:33:19
You can use a shortcut : context_.SetInteger(...).
merkulova
2015/02/09 08:54:36
Do you think it's ok from the point of readability
Denis Kuznetsov (DE-MUC)
2015/02/09 12:03:06
Yes. It would also result in fewer intermediate Ed
|
+ SendKeyboardDeviceNotification(); |
+} |
+ |
+void HIDDetectionScreen::ConfirmPasskey( |
+ device::BluetoothDevice* device, uint32 passkey) { |
+ VLOG(1) << "Confirm Passkey"; |
+ device->CancelPairing(); |
+} |
+ |
+void HIDDetectionScreen::AuthorizePairing(device::BluetoothDevice* device) { |
+ // There is never any circumstance where this will be called, since the |
+ // HID detection screen will only be used for outgoing pairing |
+ // requests, but play it safe. |
+ VLOG(1) << "Authorize pairing"; |
+ device->ConfirmPairing(); |
+} |
+ |
+void HIDDetectionScreen::AdapterPresentChanged( |
+ device::BluetoothAdapter* adapter, bool present) { |
+ if (present && switch_on_adapter_when_ready_) { |
+ VLOG(1) << "Switching on BT adapter on HID OOBE screen."; |
+ adapter_initially_powered_.reset(new bool(adapter_->IsPowered())); |
+ adapter_->SetPowered( |
+ true, |
+ base::Bind(&HIDDetectionScreen::StartBTDiscoverySession, |
+ weak_ptr_factory_.GetWeakPtr()), |
+ base::Bind(&HIDDetectionScreen::SetPoweredError, |
+ weak_ptr_factory_.GetWeakPtr())); |
+ } |
+} |
+ |
+void HIDDetectionScreen::TryPairingAsPointingDevice( |
+ device::BluetoothDevice* device) { |
+ if (pointing_device_id_.empty() && |
+ DeviceIsPointing(device->GetDeviceType()) && |
+ device->IsPairable() && |
+ !(device->IsConnected() && device->IsPaired()) && |
+ !mouse_is_pairing_) { |
+ ConnectBTDevice(device); |
+ } |
+} |
+ |
+void HIDDetectionScreen::TryPairingAsKeyboardDevice( |
+ device::BluetoothDevice* device) { |
+ if (keyboard_device_id_.empty() && |
+ DeviceIsKeyboard(device->GetDeviceType()) && |
+ device->IsPairable() && |
+ !(device->IsConnected() && device->IsPaired()) && |
+ !keyboard_is_pairing_) { |
+ ConnectBTDevice(device); |
+ } |
+} |
+ |
+void HIDDetectionScreen::ConnectBTDevice(device::BluetoothDevice* device) { |
+ bool device_busy = (device->IsConnected() && device->IsPaired()) || |
+ device->IsConnecting(); |
+ if (!device->IsPairable() || device_busy) |
+ return; |
+ device::BluetoothDevice::DeviceType device_type = device->GetDeviceType(); |
+ |
+ if (device_type == device::BluetoothDevice::DEVICE_MOUSE || |
+ device_type == device::BluetoothDevice::DEVICE_TABLET) { |
+ if (mouse_is_pairing_) |
+ return; |
+ mouse_is_pairing_ = true; |
+ } else if (device_type == device::BluetoothDevice::DEVICE_KEYBOARD) { |
+ if (keyboard_is_pairing_) |
+ return; |
+ keyboard_is_pairing_ = true; |
+ } else if (device_type == |
+ device::BluetoothDevice::DEVICE_KEYBOARD_MOUSE_COMBO) { |
+ if (mouse_is_pairing_ && keyboard_is_pairing_) |
+ return; |
+ mouse_is_pairing_ = true; |
+ keyboard_is_pairing_ = true; |
+ } |
+ device->Connect(this, |
+ base::Bind(&HIDDetectionScreen::BTConnected, |
+ weak_ptr_factory_.GetWeakPtr(), device_type), |
+ base::Bind(&HIDDetectionScreen::BTConnectError, |
+ weak_ptr_factory_.GetWeakPtr(), |
+ device->GetAddress(), device_type)); |
+} |
+ |
+void HIDDetectionScreen::BTConnected( |
+ device::BluetoothDevice::DeviceType device_type) { |
+ if (DeviceIsPointing(device_type)) |
+ mouse_is_pairing_ = false; |
+ if (DeviceIsKeyboard(device_type)) { |
+ keyboard_is_pairing_ = false; |
+ context_.SetInteger(kContextKeyNumKeysEnteredExpected, false); |
+ context_.SetString(kContextKeyPinCode, ""); |
Denis Kuznetsov (DE-MUC)
2015/02/05 13:33:19
Same as above
merkulova
2015/02/09 08:54:36
Acknowledged.
|
+ SendKeyboardDeviceNotification(); |
+ CommitContextChanges(); |
+ } |
+} |
+ |
+void HIDDetectionScreen::BTConnectError( |
+ const std::string& address, |
+ device::BluetoothDevice::DeviceType device_type, |
+ device::BluetoothDevice::ConnectErrorCode error_code) { |
+ LOG(WARNING) << "BTConnectError while connecting " << address |
+ << " error code = " << error_code; |
+ if (DeviceIsPointing(device_type)) |
+ mouse_is_pairing_ = false; |
+ if (DeviceIsKeyboard(device_type)) { |
+ keyboard_is_pairing_ = false; |
+ context_.SetInteger(kContextKeyNumKeysEnteredExpected, false); |
+ context_.SetString(kContextKeyPinCode, ""); |
+ SendKeyboardDeviceNotification(); |
+ } |
+ |
+ if (pointing_device_id_.empty() || keyboard_device_id_.empty()) |
+ UpdateDevices(); |
+} |
+ |
+void HIDDetectionScreen::SendPointingDeviceNotification() { |
+ std::string state; |
+ if (pointing_device_id_.empty()) |
+ state = kSearchingState; |
+ else if (pointing_device_connect_type_ == InputDeviceInfo::TYPE_BLUETOOTH) |
+ state = kBTPairedState; |
+ else |
+ state = kUSBConnectedState; |
+ context_.SetString(kContextKeyMouseState, state); |
+ context_.SetBoolean( |
+ kContextKeyContinueButtonEnabled, |
+ !(pointing_device_id_.empty() && keyboard_device_id_.empty())); |
+ CommitContextChanges(); |
+} |
+ |
+void HIDDetectionScreen::SendKeyboardDeviceNotification() { |
+ context_.SetString(kContextKeyKeyboardLabel, ""); |
+ if (keyboard_device_id_.empty()) { |
+ if (keyboard_is_pairing_) { |
+ context_.SetString(kContextKeyKeyboardState, kBTPairingState); |
+ context_.SetString(kContextKeyKeyboardLabel, |
+ l10n_util::GetStringFUTF8( |
+ IDS_HID_DETECTION_BLUETOOTH_REMOTE_PIN_CODE_REQUEST, |
+ base::UTF8ToUTF16(keyboard_device_name_))); |
+ } else { |
+ context_.SetString(kContextKeyKeyboardState, kSearchingState); |
+ } |
+ } else { |
+ if (keyboard_device_connect_type_ == InputDeviceInfo::TYPE_BLUETOOTH) { |
+ context_.SetString(kContextKeyKeyboardState, kBTPairedState); |
+ context_.SetString(kContextKeyKeyboardLabel, |
+ l10n_util::GetStringFUTF16( |
+ IDS_HID_DETECTION_PAIRED_BLUETOOTH_KEYBOARD, |
+ base::UTF8ToUTF16(keyboard_device_name_))); |
+ } else { |
+ context_.SetString(kContextKeyKeyboardState, kUSBConnectedState); |
+ } |
+ } |
+ context_.SetString(kContextKeyKeyboardDeviceName, keyboard_device_name_); |
+ context_.SetBoolean( |
+ kContextKeyContinueButtonEnabled, |
+ !(pointing_device_id_.empty() && keyboard_device_id_.empty())); |
+ CommitContextChanges(); |
+} |
+ |
+void HIDDetectionScreen::SetKeyboardDeviceName_(std::string name) { |
+ if (!(keyboard_device_id_.empty()) && name.empty()) |
+ name = l10n_util::GetStringUTF8(IDS_HID_DETECTION_DEFAULT_KEYBOARD_NAME); |
+ keyboard_device_name_ = name; |
+} |
+ |
+void HIDDetectionScreen::DeviceAdded( |
+ device::BluetoothAdapter* adapter, device::BluetoothDevice* device) { |
+ VLOG(1) << "BT input device added id = " << device->GetDeviceID() << |
+ " name = " << device->GetName(); |
+ TryPairingAsPointingDevice(device); |
+ TryPairingAsKeyboardDevice(device); |
+} |
+ |
+void HIDDetectionScreen::DeviceChanged( |
+ device::BluetoothAdapter* adapter, device::BluetoothDevice* device) { |
+ VLOG(1) << "BT device changed id = " << device->GetDeviceID() << " name = " << |
+ device->GetName(); |
+ TryPairingAsPointingDevice(device); |
+ TryPairingAsKeyboardDevice(device); |
+} |
+ |
+void HIDDetectionScreen::DeviceRemoved( |
+ device::BluetoothAdapter* adapter, device::BluetoothDevice* device) { |
+ VLOG(1) << "BT device removed id = " << device->GetDeviceID() << " name = " << |
+ device->GetName(); |
+} |
+ |
+void HIDDetectionScreen::OnInputDeviceAdded( |
+ const InputDeviceInfo& info) { |
+ VLOG(1) << "Input device added id = " << info.id << " name = " << info.name; |
+ // TODO(merkulova): deal with all available device types, e.g. joystick. |
+ if (!keyboard_device_id_.empty() && !pointing_device_id_.empty()) |
+ return; |
+ |
+ if (pointing_device_id_.empty() && DeviceIsPointing(info)) { |
+ pointing_device_id_ = info.id; |
+ context_.SetString(kContextKeyMouseDeviceName, info.name); |
+ pointing_device_connect_type_ = info.type; |
+ SendPointingDeviceNotification(); |
+ } |
+ if (keyboard_device_id_.empty() && info.is_keyboard) { |
+ keyboard_device_id_ = info.id; |
+ keyboard_device_connect_type_ = info.type; |
+ SetKeyboardDeviceName_(info.name); |
+ SendKeyboardDeviceNotification(); |
+ } |
+} |
+ |
+void HIDDetectionScreen::OnInputDeviceRemoved(const std::string& id) { |
+ if (id == keyboard_device_id_) { |
+ keyboard_device_id_.clear(); |
+ keyboard_device_connect_type_ = InputDeviceInfo::TYPE_UNKNOWN; |
+ SendKeyboardDeviceNotification(); |
+ UpdateDevices(); |
+ } |
+ if (id == pointing_device_id_) { |
+ pointing_device_id_.clear(); |
+ pointing_device_connect_type_ = InputDeviceInfo::TYPE_UNKNOWN; |
+ SendPointingDeviceNotification(); |
+ UpdateDevices(); |
+ } |
} |
+void HIDDetectionScreen::InitializeAdapter( |
+ scoped_refptr<device::BluetoothAdapter> adapter) { |
+ adapter_ = adapter; |
+ CHECK(adapter_.get()); |
+ |
+ adapter_->AddObserver(this); |
+ UpdateDevices(); |
+} |
+ |
+void HIDDetectionScreen::StartBTDiscoverySession() { |
+ adapter_->StartDiscoverySession( |
+ base::Bind(&HIDDetectionScreen::OnStartDiscoverySession, |
+ weak_ptr_factory_.GetWeakPtr()), |
+ base::Bind(&HIDDetectionScreen::FindDevicesError, |
+ weak_ptr_factory_.GetWeakPtr())); |
+} |
+ |
+void HIDDetectionScreen::ProcessConnectedDevicesList( |
+ const std::vector<InputDeviceInfo>& devices) { |
+ for (std::vector<InputDeviceInfo>::const_iterator it = devices.begin(); |
+ it != devices.end() && |
+ (pointing_device_id_.empty() || keyboard_device_id_.empty()); |
+ ++it) { |
+ if (pointing_device_id_.empty() && DeviceIsPointing(*it)) { |
+ pointing_device_id_ = it->id; |
+ context_.SetString(kContextKeyMouseDeviceName, it->name); |
+ pointing_device_connect_type_ = it->type; |
+ SendPointingDeviceNotification(); |
+ } |
+ if (keyboard_device_id_.empty() && it->is_keyboard) { |
+ keyboard_device_id_ = it->id; |
+ SetKeyboardDeviceName_(it->name); |
+ keyboard_device_connect_type_ = it->type; |
+ SendKeyboardDeviceNotification(); |
+ } |
+ } |
+} |
+ |
+void HIDDetectionScreen::TryInitiateBTDevicesUpdate() { |
+ if ((pointing_device_id_.empty() || keyboard_device_id_.empty()) && |
+ adapter_.get()) { |
+ if (!adapter_->IsPresent()) { |
+ // Switch on BT adapter later when it's available. |
+ switch_on_adapter_when_ready_ = true; |
+ } else if (!adapter_->IsPowered()) { |
+ VLOG(1) << "Switching on BT adapter on HID OOBE screen."; |
+ adapter_initially_powered_.reset(new bool(false)); |
+ adapter_->SetPowered( |
+ true, |
+ base::Bind(&HIDDetectionScreen::StartBTDiscoverySession, |
+ weak_ptr_factory_.GetWeakPtr()), |
+ base::Bind(&HIDDetectionScreen::SetPoweredError, |
+ weak_ptr_factory_.GetWeakPtr())); |
+ } else { |
+ UpdateBTDevices(); |
+ } |
+ } |
+} |
+ |
+void HIDDetectionScreen::OnGetInputDevicesListForCheck( |
+ const base::Callback<void(bool)>& on_check_done, |
+ const std::vector<InputDeviceInfo>& devices) { |
+ ProcessConnectedDevicesList(devices); |
+ |
+ // Screen is not required if both devices are present. |
+ bool all_devices_autodetected = !pointing_device_id_.empty() && |
+ !keyboard_device_id_.empty(); |
+ UMA_HISTOGRAM_BOOLEAN("HIDDetection.OOBEDialogShown", |
+ !all_devices_autodetected); |
+ |
+ on_check_done.Run(!all_devices_autodetected); |
+} |
+ |
+void HIDDetectionScreen::OnGetInputDevicesList( |
+ const std::vector<InputDeviceInfo>& devices) { |
+ ProcessConnectedDevicesList(devices); |
+ TryInitiateBTDevicesUpdate(); |
+} |
+ |
+void HIDDetectionScreen::UpdateDevices() { |
+ input_service_proxy_.GetDevices( |
+ base::Bind(&HIDDetectionScreen::OnGetInputDevicesList, |
+ weak_ptr_factory_.GetWeakPtr())); |
+} |
+ |
+void HIDDetectionScreen::UpdateBTDevices() { |
+ if (!adapter_.get() || !adapter_->IsPresent() || !adapter_->IsPowered()) |
+ return; |
+ |
+ // If no connected devices found as pointing device and keyboard, we try to |
+ // connect some type-suitable active bluetooth device. |
+ std::vector<device::BluetoothDevice*> bt_devices = adapter_->GetDevices(); |
+ for (std::vector<device::BluetoothDevice*>::const_iterator it = |
+ bt_devices.begin(); |
+ it != bt_devices.end() && |
+ (keyboard_device_id_.empty() || pointing_device_id_.empty()); |
+ ++it) { |
+ TryPairingAsPointingDevice(*it); |
+ TryPairingAsKeyboardDevice(*it); |
+ } |
+} |
+ |
+void HIDDetectionScreen::OnStartDiscoverySession( |
+ scoped_ptr<device::BluetoothDiscoverySession> discovery_session) { |
+ VLOG(1) << "BT Discovery session started"; |
+ discovery_session_ = discovery_session.Pass(); |
+ UpdateDevices(); |
+} |
+ |
+void HIDDetectionScreen::SetPoweredError() { |
+ LOG(ERROR) << "Failed to power BT adapter"; |
+} |
+ |
+void HIDDetectionScreen::SetPoweredOffError() { |
+ LOG(ERROR) << "Failed to power off BT adapter"; |
+} |
+ |
+void HIDDetectionScreen::FindDevicesError() { |
+ VLOG(1) << "Failed to start Bluetooth discovery."; |
+} |
+ |
+ |
} // namespace chromeos |