// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromeos/ash/components/hid_detection/hid_detection_manager_impl.h"
#include "base/containers/contains.h"
#include "base/no_destructor.h"
#include "chromeos/ash/components/hid_detection/bluetooth_hid_detector_impl.h"
#include "chromeos/ash/components/hid_detection/hid_detection_utils.h"
#include "components/device_event_log/device_event_log.h"
namespace ash::hid_detection {
namespace {
using BluetoothHidType = BluetoothHidDetector::BluetoothHidType;
using InputState = HidDetectionManager::InputState;
// In floss, a virtual device is created when a HID is bonded or paired.
// We do not want to include this virtual device to our list of added devices.
// (b/299955128)
const char* kBlockedDeviceNames[] = {"VIRTUAL_SUSPEND_UHID"};
HidDetectionManagerImpl::InputDeviceManagerBinder&
GetInputDeviceManagerBinderOverride() {
// InputDeviceManagerBinder instance that can be overridden in tests.
static base::NoDestructor<HidDetectionManagerImpl::InputDeviceManagerBinder>
binder;
return *binder;
}
} // namespace
// static
void HidDetectionManagerImpl::SetInputDeviceManagerBinderForTest(
InputDeviceManagerBinder binder) {
GetInputDeviceManagerBinderOverride() = std::move(binder);
}
HidDetectionManagerImpl::HidDetectionManagerImpl(
device::mojom::DeviceService* device_service)
: device_service_{device_service},
bluetooth_hid_detector_{std::make_unique<BluetoothHidDetectorImpl>()} {}
HidDetectionManagerImpl::~HidDetectionManagerImpl() = default;
void HidDetectionManagerImpl::GetIsHidDetectionRequired(
base::OnceCallback<void(bool)> callback) {
BindToInputDeviceManagerIfNeeded();
HID_LOG(EVENT) << "Fetching input devices for GetIsHidDetectionRequired().";
input_device_manager_->GetDevices(
base::BindOnce(&HidDetectionManagerImpl::OnGetDevicesForIsRequired,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
}
void HidDetectionManagerImpl::PerformStartHidDetection() {
BindToInputDeviceManagerIfNeeded();
HID_LOG(EVENT) << "Starting HID detection by fetching input devices.";
input_device_manager_->GetDevicesAndSetClient(
input_device_manager_receiver_.BindNewEndpointAndPassRemote(),
base::BindOnce(&HidDetectionManagerImpl::OnGetDevicesAndSetClient,
weak_ptr_factory_.GetWeakPtr()));
}
void HidDetectionManagerImpl::PerformStopHidDetection() {
HID_LOG(EVENT) << "Stopping HID detection.";
input_device_manager_receiver_.reset();
// Check if any of the connected input devices are connected via Bluetooth.
bool is_using_bluetooth = false;
for (const auto& [device_id, device] : device_id_to_device_map_) {
if (device->type == device::mojom::InputDeviceType::TYPE_BLUETOOTH) {
is_using_bluetooth = true;
break;
}
}
bluetooth_hid_detector_->StopBluetoothHidDetection(is_using_bluetooth);
}
HidDetectionManager::HidDetectionStatus
HidDetectionManagerImpl::ComputeHidDetectionStatus() const {
BluetoothHidDetector::BluetoothHidDetectionStatus bluetooth_status =
bluetooth_hid_detector_->GetBluetoothHidDetectionStatus();
return HidDetectionManager::HidDetectionStatus(
GetInputMetadata(connected_pointer_id_, BluetoothHidType::kPointer,
bluetooth_status.current_pairing_device),
GetInputMetadata(connected_keyboard_id_, BluetoothHidType::kKeyboard,
bluetooth_status.current_pairing_device),
connected_touchscreen_id_.has_value(),
std::move(bluetooth_status.pairing_state));
}
void HidDetectionManagerImpl::InputDeviceAdded(
device::mojom::InputDeviceInfoPtr info) {
// Special case where the added device is a blocked device.
if (std::find(std::begin(kBlockedDeviceNames), std::end(kBlockedDeviceNames),
info->name) != std::end(kBlockedDeviceNames)) {
return;
}
HID_LOG(EVENT) << "Input device added, id: " << info->id
<< ", name: " << info->name;
const std::string& device_id = info->id;
device_id_to_device_map_[device_id] = std::move(info);
hid_detection::RecordHidConnected(*device_id_to_device_map_[device_id]);
if (AttemptSetDeviceAsConnectedHid(*device_id_to_device_map_[device_id])) {
NotifyHidDetectionStatusChanged();
SetInputDevicesStatus();
}
}
void HidDetectionManagerImpl::InputDeviceRemoved(const std::string& id) {
if (!base::Contains(device_id_to_device_map_, id)) {
// Some devices may be removed that were not registered in
// InputDeviceAdded() or OnGetDevicesAndSetClient().
HID_LOG(EVENT)
<< "Input device with id: " << id
<< " was removed that was not in |device_id_to_device_map_|.";
return;
}
HID_LOG(EVENT) << "Input device removed, id: " << id
<< ", name: " << device_id_to_device_map_[id]->name;
hid_detection::RecordHidDisconnected(*device_id_to_device_map_[id]);
device_id_to_device_map_.erase(id);
bool was_connected_hid_disconnected_ = false;
if (id == connected_touchscreen_id_) {
HID_LOG(EVENT) << "Removing connected touchscreen: " << id;
connected_touchscreen_id_.reset();
was_connected_hid_disconnected_ = true;
}
if (id == connected_pointer_id_) {
HID_LOG(EVENT) << "Removing connected pointer: " << id;
connected_pointer_id_.reset();
was_connected_hid_disconnected_ = true;
}
if (id == connected_keyboard_id_) {
HID_LOG(EVENT) << "Removing connected keyboard: " << id;
connected_keyboard_id_.reset();
was_connected_hid_disconnected_ = true;
}
if (was_connected_hid_disconnected_) {
SetConnectedHids();
NotifyHidDetectionStatusChanged();
SetInputDevicesStatus();
}
}
void HidDetectionManagerImpl::OnBluetoothHidStatusChanged() {
NotifyHidDetectionStatusChanged();
}
void HidDetectionManagerImpl::BindToInputDeviceManagerIfNeeded() {
if (input_device_manager_.is_bound())
return;
mojo::PendingReceiver<device::mojom::InputDeviceManager> receiver =
input_device_manager_.BindNewPipeAndPassReceiver();
const auto& binder = GetInputDeviceManagerBinderOverride();
if (binder) {
binder.Run(std::move(receiver));
return;
}
DCHECK(device_service_);
device_service_->BindInputDeviceManager(std::move(receiver));
}
void HidDetectionManagerImpl::OnGetDevicesForIsRequired(
base::OnceCallback<void(bool)> callback,
std::vector<device::mojom::InputDeviceInfoPtr> devices) {
bool has_pointer = false;
bool has_keyboard = false;
for (const auto& device : devices) {
if (hid_detection::IsDevicePointer(*device))
has_pointer = true;
if (device->is_keyboard)
has_keyboard = true;
if (has_pointer && has_keyboard)
break;
}
hid_detection::HidsMissing hids_missing = hid_detection::HidsMissing::kNone;
if (!has_pointer) {
if (!has_keyboard) {
hids_missing = hid_detection::HidsMissing::kPointerAndKeyboard;
} else {
hids_missing = hid_detection::HidsMissing::kPointer;
}
} else if (!has_keyboard) {
hids_missing = hid_detection::HidsMissing::kKeyboard;
}
hid_detection::RecordInitialHidsMissing(hids_missing);
HID_LOG(EVENT)
<< "Fetched " << devices.size()
<< " input devices for GetIsHidDetectionRequired(). Pointer detected: "
<< has_pointer << ", keyboard detected: " << has_keyboard;
// HID detection is not required if both devices are present.
std::move(callback).Run(!(has_pointer && has_keyboard));
}
void HidDetectionManagerImpl::OnGetDevicesAndSetClient(
std::vector<device::mojom::InputDeviceInfoPtr> devices) {
DCHECK(device_id_to_device_map_.empty())
<< " |devices_| should be empty when fetching initial devices.";
for (auto& device : devices) {
device_id_to_device_map_[device->id] = std::move(device);
}
SetConnectedHids();
NotifyHidDetectionStatusChanged();
bluetooth_hid_detector_->StartBluetoothHidDetection(
this, {.pointer_is_missing = !connected_pointer_id_.has_value(),
.keyboard_is_missing = !connected_keyboard_id_.has_value()});
}
bool HidDetectionManagerImpl::SetConnectedHids() {
HID_LOG(EVENT) << "Setting connected HIDs";
bool is_any_device_newly_connected_hid = false;
for (const auto& [device_id, device] : device_id_to_device_map_) {
is_any_device_newly_connected_hid |=
AttemptSetDeviceAsConnectedHid(*device);
}
return is_any_device_newly_connected_hid;
}
bool HidDetectionManagerImpl::AttemptSetDeviceAsConnectedHid(
const device::mojom::InputDeviceInfo& device) {
bool is_device_newly_connected_hid = false;
if (!connected_touchscreen_id_.has_value() &&
hid_detection::IsDeviceTouchscreen(device)) {
HID_LOG(EVENT) << "Touchscreen detected: " << device.id;
connected_touchscreen_id_ = device.id;
is_device_newly_connected_hid = true;
}
if (!connected_pointer_id_.has_value() &&
hid_detection::IsDevicePointer(device)) {
HID_LOG(EVENT) << "Pointer detected: " << device.id;
connected_pointer_id_ = device.id;
is_device_newly_connected_hid = true;
}
if (!connected_keyboard_id_.has_value() && device.is_keyboard) {
HID_LOG(EVENT) << "Keyboard detected: " << device.id;
connected_keyboard_id_ = device.id;
is_device_newly_connected_hid = true;
}
return is_device_newly_connected_hid;
}
HidDetectionManager::InputMetadata HidDetectionManagerImpl::GetInputMetadata(
const std::optional<std::string>& connected_device_id,
BluetoothHidType input_type,
const std::optional<BluetoothHidDetector::BluetoothHidMetadata>&
current_pairing_device) const {
if (connected_device_id.has_value()) {
const device::mojom::InputDeviceInfoPtr& device =
device_id_to_device_map_.find(connected_device_id.value())->second;
DCHECK(device)
<< " |connected_device_id| not found in |device_id_to_device_map_|";
InputState state;
switch (device->type) {
case device::mojom::InputDeviceType::TYPE_BLUETOOTH:
state = InputState::kPairedViaBluetooth;
break;
case device::mojom::InputDeviceType::TYPE_USB:
state = InputState::kConnectedViaUsb;
break;
case device::mojom::InputDeviceType::TYPE_SERIO:
[[fallthrough]];
case device::mojom::InputDeviceType::TYPE_UNKNOWN:
state = InputState::kConnected;
break;
}
return InputMetadata{state, device->name};
}
if (current_pairing_device.has_value() &&
(current_pairing_device.value().type == input_type ||
current_pairing_device.value().type ==
BluetoothHidType::kKeyboardPointerCombo)) {
return InputMetadata{InputState::kPairingViaBluetooth,
current_pairing_device.value().name};
}
return InputMetadata();
}
void HidDetectionManagerImpl::SetInputDevicesStatus() {
bluetooth_hid_detector_->SetInputDevicesStatus(
{.pointer_is_missing = !connected_pointer_id_.has_value(),
.keyboard_is_missing = !connected_keyboard_id_.has_value()});
}
void HidDetectionManagerImpl::SetBluetoothHidDetectorForTest(
std::unique_ptr<BluetoothHidDetector> bluetooth_hid_detector) {
bluetooth_hid_detector_ = std::move(bluetooth_hid_detector);
}
} // namespace ash::hid_detection
Codebase Browser
chromium