diff options
24 files changed, 759 insertions, 135 deletions
diff --git a/include/android/input.h b/include/android/input.h index fec56f02f9..ee98d7aee9 100644 --- a/include/android/input.h +++ b/include/android/input.h @@ -1002,7 +1002,6 @@ enum { * Keyboard types. * * Refer to the documentation on android.view.InputDevice for more details. - * Note: When adding a new keyboard type here InputDeviceInfo::setKeyboardType needs to be updated. */ enum { /** none */ diff --git a/include/input/Input.h b/include/input/Input.h index 3ca9c19876..dee3e7dcd0 100644 --- a/include/input/Input.h +++ b/include/input/Input.h @@ -258,6 +258,16 @@ enum class KeyState { ftl_last = VIRTUAL, }; +/** + * The keyboard type. This should have 1:1 correspondence with the values of anonymous enum + * defined in input.h + */ +enum class KeyboardType { + NONE = AINPUT_KEYBOARD_TYPE_NONE, + NON_ALPHABETIC = AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC, + ALPHABETIC = AINPUT_KEYBOARD_TYPE_ALPHABETIC, +}; + bool isStylusToolType(ToolType toolType); struct PointerProperties; diff --git a/include/input/KeyboardClassifier.h b/include/input/KeyboardClassifier.h new file mode 100644 index 0000000000..457d474ee7 --- /dev/null +++ b/include/input/KeyboardClassifier.h @@ -0,0 +1,53 @@ +/* + * Copyright 2024 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include <android-base/result.h> +#include <input/Input.h> +#include <input/InputDevice.h> + +#include "rust/cxx.h" + +namespace android { + +namespace input { +namespace keyboardClassifier { +struct KeyboardClassifier; +} +} // namespace input + +/* + * Keyboard classifier to classify keyboard into alphabetic and non-alphabetic keyboards + */ +class KeyboardClassifier { +public: + KeyboardClassifier(); + /** + * Get the type of keyboard that the classifier currently believes the device to be. + */ + KeyboardType getKeyboardType(DeviceId deviceId); + void notifyKeyboardChanged(DeviceId deviceId, const InputDeviceIdentifier& identifier, + uint32_t deviceClasses); + void processKey(DeviceId deviceId, int32_t evdevCode, uint32_t metaState); + +private: + std::optional<rust::Box<android::input::keyboardClassifier::KeyboardClassifier>> + mRustClassifier; + std::unordered_map<DeviceId, KeyboardType> mKeyboardTypeMap; +}; + +} // namespace android diff --git a/libs/input/Android.bp b/libs/input/Android.bp index 8f44b3a0e1..4123ffcde1 100644 --- a/libs/input/Android.bp +++ b/libs/input/Android.bp @@ -117,6 +117,27 @@ rust_bindgen { "--allowlist-var=AINPUT_SOURCE_HDMI", "--allowlist-var=AINPUT_SOURCE_SENSOR", "--allowlist-var=AINPUT_SOURCE_ROTARY_ENCODER", + "--allowlist-var=AINPUT_KEYBOARD_TYPE_NONE", + "--allowlist-var=AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC", + "--allowlist-var=AINPUT_KEYBOARD_TYPE_ALPHABETIC", + "--allowlist-var=AMETA_NONE", + "--allowlist-var=AMETA_ALT_ON", + "--allowlist-var=AMETA_ALT_LEFT_ON", + "--allowlist-var=AMETA_ALT_RIGHT_ON", + "--allowlist-var=AMETA_SHIFT_ON", + "--allowlist-var=AMETA_SHIFT_LEFT_ON", + "--allowlist-var=AMETA_SHIFT_RIGHT_ON", + "--allowlist-var=AMETA_SYM_ON", + "--allowlist-var=AMETA_FUNCTION_ON", + "--allowlist-var=AMETA_CTRL_ON", + "--allowlist-var=AMETA_CTRL_LEFT_ON", + "--allowlist-var=AMETA_CTRL_RIGHT_ON", + "--allowlist-var=AMETA_META_ON", + "--allowlist-var=AMETA_META_LEFT_ON", + "--allowlist-var=AMETA_META_RIGHT_ON", + "--allowlist-var=AMETA_CAPS_LOCK_ON", + "--allowlist-var=AMETA_NUM_LOCK_ON", + "--allowlist-var=AMETA_SCROLL_LOCK_ON", ], static_libs: [ @@ -208,6 +229,7 @@ cc_library { "InputVerifier.cpp", "Keyboard.cpp", "KeyCharacterMap.cpp", + "KeyboardClassifier.cpp", "KeyLayoutMap.cpp", "MotionPredictor.cpp", "MotionPredictorMetricsManager.cpp", diff --git a/libs/input/InputDevice.cpp b/libs/input/InputDevice.cpp index bc678103c2..9333ab83a6 100644 --- a/libs/input/InputDevice.cpp +++ b/libs/input/InputDevice.cpp @@ -273,10 +273,7 @@ void InputDeviceInfo::addLightInfo(const InputDeviceLightInfo& info) { } void InputDeviceInfo::setKeyboardType(int32_t keyboardType) { - static_assert(AINPUT_KEYBOARD_TYPE_NONE < AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC); - static_assert(AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC < AINPUT_KEYBOARD_TYPE_ALPHABETIC); - // There can be multiple subdevices with different keyboard types, set it to the highest type - mKeyboardType = std::max(mKeyboardType, keyboardType); + mKeyboardType = keyboardType; } void InputDeviceInfo::setKeyboardLayoutInfo(KeyboardLayoutInfo layoutInfo) { diff --git a/libs/input/KeyboardClassifier.cpp b/libs/input/KeyboardClassifier.cpp new file mode 100644 index 0000000000..0c2c7be582 --- /dev/null +++ b/libs/input/KeyboardClassifier.cpp @@ -0,0 +1,89 @@ +/* + * Copyright 2024 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "KeyboardClassifier" + +#include <android-base/logging.h> +#include <com_android_input_flags.h> +#include <ftl/flags.h> +#include <input/KeyboardClassifier.h> + +#include "input_cxx_bridge.rs.h" + +namespace input_flags = com::android::input::flags; + +using android::input::RustInputDeviceIdentifier; + +namespace android { + +KeyboardClassifier::KeyboardClassifier() { + if (input_flags::enable_keyboard_classifier()) { + mRustClassifier = android::input::keyboardClassifier::create(); + } +} + +KeyboardType KeyboardClassifier::getKeyboardType(DeviceId deviceId) { + if (mRustClassifier) { + return static_cast<KeyboardType>( + android::input::keyboardClassifier::getKeyboardType(**mRustClassifier, deviceId)); + } else { + auto it = mKeyboardTypeMap.find(deviceId); + if (it == mKeyboardTypeMap.end()) { + return KeyboardType::NONE; + } + return it->second; + } +} + +// Copied from EventHub.h +const uint32_t DEVICE_CLASS_KEYBOARD = android::os::IInputConstants::DEVICE_CLASS_KEYBOARD; +const uint32_t DEVICE_CLASS_ALPHAKEY = android::os::IInputConstants::DEVICE_CLASS_ALPHAKEY; + +void KeyboardClassifier::notifyKeyboardChanged(DeviceId deviceId, + const InputDeviceIdentifier& identifier, + uint32_t deviceClasses) { + if (mRustClassifier) { + RustInputDeviceIdentifier rustIdentifier; + rustIdentifier.name = identifier.name; + rustIdentifier.location = identifier.location; + rustIdentifier.unique_id = identifier.uniqueId; + rustIdentifier.bus = identifier.bus; + rustIdentifier.vendor = identifier.vendor; + rustIdentifier.product = identifier.product; + rustIdentifier.version = identifier.version; + rustIdentifier.descriptor = identifier.descriptor; + android::input::keyboardClassifier::notifyKeyboardChanged(**mRustClassifier, deviceId, + rustIdentifier, deviceClasses); + } else { + bool isKeyboard = (deviceClasses & DEVICE_CLASS_KEYBOARD) != 0; + bool hasAlphabeticKey = (deviceClasses & DEVICE_CLASS_ALPHAKEY) != 0; + mKeyboardTypeMap.insert_or_assign(deviceId, + isKeyboard ? (hasAlphabeticKey + ? KeyboardType::ALPHABETIC + : KeyboardType::NON_ALPHABETIC) + : KeyboardType::NONE); + } +} + +void KeyboardClassifier::processKey(DeviceId deviceId, int32_t evdevCode, uint32_t metaState) { + if (mRustClassifier && + !android::input::keyboardClassifier::isFinalized(**mRustClassifier, deviceId)) { + android::input::keyboardClassifier::processKey(**mRustClassifier, deviceId, evdevCode, + metaState); + } +} + +} // namespace android diff --git a/libs/input/android/os/IInputConstants.aidl b/libs/input/android/os/IInputConstants.aidl index 90ed2b7d06..e8746d000e 100644 --- a/libs/input/android/os/IInputConstants.aidl +++ b/libs/input/android/os/IInputConstants.aidl @@ -234,4 +234,157 @@ interface IInputConstants * time to adjust to changes in direction. */ const int VELOCITY_TRACKER_STRATEGY_LEGACY = 9; + + + /* + * Input device class: Keyboard + * The input device is a keyboard or has buttons. + * + * @hide + */ + const int DEVICE_CLASS_KEYBOARD = 0x00000001; + + /* + * Input device class: Alphakey + * The input device is an alpha-numeric keyboard (not just a dial pad). + * + * @hide + */ + const int DEVICE_CLASS_ALPHAKEY = 0x00000002; + + /* + * Input device class: Touch + * The input device is a touchscreen or a touchpad (either single-touch or multi-touch). + * + * @hide + */ + const int DEVICE_CLASS_TOUCH = 0x00000004; + + /* + * Input device class: Cursor + * The input device is a cursor device such as a trackball or mouse. + * + * @hide + */ + const int DEVICE_CLASS_CURSOR = 0x00000008; + + /* + * Input device class: Multi-touch + * The input device is a multi-touch touchscreen or touchpad. + * + * @hide + */ + const int DEVICE_CLASS_TOUCH_MT = 0x00000010; + + /* + * Input device class: Dpad + * The input device is a directional pad (implies keyboard, has DPAD keys). + * + * @hide + */ + const int DEVICE_CLASS_DPAD = 0x00000020; + + /* + * Input device class: Gamepad + * The input device is a gamepad (implies keyboard, has BUTTON keys). + * + * @hide + */ + const int DEVICE_CLASS_GAMEPAD = 0x00000040; + + /* + * Input device class: Switch + * The input device has switches. + * + * @hide + */ + const int DEVICE_CLASS_SWITCH = 0x00000080; + + /* + * Input device class: Joystick + * The input device is a joystick (implies gamepad, has joystick absolute axes). + * + * @hide + */ + const int DEVICE_CLASS_JOYSTICK = 0x00000100; + + /* + * Input device class: Vibrator + * The input device has a vibrator (supports FF_RUMBLE). + * + * @hide + */ + const int DEVICE_CLASS_VIBRATOR = 0x00000200; + + /* + * Input device class: Mic + * The input device has a microphone. + * + * @hide + */ + const int DEVICE_CLASS_MIC = 0x00000400; + + /* + * Input device class: External Stylus + * The input device is an external stylus (has data we want to fuse with touch data). + * + * @hide + */ + const int DEVICE_CLASS_EXTERNAL_STYLUS = 0x00000800; + + /* + * Input device class: Rotary Encoder + * The input device has a rotary encoder. + * + * @hide + */ + const int DEVICE_CLASS_ROTARY_ENCODER = 0x00001000; + + /* + * Input device class: Sensor + * The input device has a sensor like accelerometer, gyro, etc. + * + * @hide + */ + const int DEVICE_CLASS_SENSOR = 0x00002000; + + /* + * Input device class: Battery + * The input device has a battery. + * + * @hide + */ + const int DEVICE_CLASS_BATTERY = 0x00004000; + + /* + * Input device class: Light + * The input device has sysfs controllable lights. + * + * @hide + */ + const int DEVICE_CLASS_LIGHT = 0x00008000; + + /* + * Input device class: Touchpad + * The input device is a touchpad, requiring an on-screen cursor. + * + * @hide + */ + const int DEVICE_CLASS_TOUCHPAD = 0x00010000; + + /* + * Input device class: Virtual + * The input device is virtual (not a real device, not part of UI configuration). + * + * @hide + */ + const int DEVICE_CLASS_VIRTUAL = 0x20000000; + + /* + * Input device class: External + * The input device is external (not built-in). + * + * @hide + */ + const int DEVICE_CLASS_EXTERNAL = 0x40000000; } diff --git a/libs/input/input_flags.aconfig b/libs/input/input_flags.aconfig index 560166c2bd..a2192cbdc4 100644 --- a/libs/input/input_flags.aconfig +++ b/libs/input/input_flags.aconfig @@ -150,3 +150,10 @@ flag { description: "Hide touch and pointer indicators if a secure window is present on display" bug: "325252005" } + +flag { + name: "enable_keyboard_classifier" + namespace: "input" + description: "Keyboard classifier that classifies all keyboards into alphabetic or non-alphabetic" + bug: "263559234" +} diff --git a/libs/input/rust/input.rs b/libs/input/rust/input.rs index d0dbd6fa16..72b421cffe 100644 --- a/libs/input/rust/input.rs +++ b/libs/input/rust/input.rs @@ -16,22 +16,26 @@ //! Common definitions of the Android Input Framework in rust. +use crate::ffi::RustInputDeviceIdentifier; use bitflags::bitflags; -use inputconstants::aidl::android::os::IInputConstants::INPUT_EVENT_FLAG_CANCELED; -use inputconstants::aidl::android::os::IInputConstants::INPUT_EVENT_FLAG_IS_ACCESSIBILITY_EVENT; -use inputconstants::aidl::android::os::IInputConstants::INPUT_EVENT_FLAG_TAINTED; -use inputconstants::aidl::android::os::IInputConstants::MOTION_EVENT_FLAG_HOVER_EXIT_PENDING; -use inputconstants::aidl::android::os::IInputConstants::MOTION_EVENT_FLAG_IS_GENERATED_GESTURE; -use inputconstants::aidl::android::os::IInputConstants::MOTION_EVENT_FLAG_NO_FOCUS_CHANGE; -use inputconstants::aidl::android::os::IInputConstants::MOTION_EVENT_FLAG_TARGET_ACCESSIBILITY_FOCUS; -use inputconstants::aidl::android::os::IInputConstants::MOTION_EVENT_FLAG_WINDOW_IS_OBSCURED; -use inputconstants::aidl::android::os::IInputConstants::MOTION_EVENT_FLAG_WINDOW_IS_PARTIALLY_OBSCURED; +use inputconstants::aidl::android::os::IInputConstants; use std::fmt; /// The InputDevice ID. #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)] pub struct DeviceId(pub i32); +/// The InputDevice equivalent for Rust inputflinger +#[derive(Debug)] +pub struct InputDevice { + /// InputDevice ID + pub device_id: DeviceId, + /// InputDevice unique identifier + pub identifier: RustInputDeviceIdentifier, + /// InputDevice classes (equivalent to EventHub InputDeviceClass) + pub classes: DeviceClass, +} + #[repr(u32)] pub enum SourceClass { None = input_bindgen::AINPUT_SOURCE_CLASS_NONE, @@ -192,23 +196,23 @@ bitflags! { #[derive(Debug)] pub struct MotionFlags: u32 { /// FLAG_WINDOW_IS_OBSCURED - const WINDOW_IS_OBSCURED = MOTION_EVENT_FLAG_WINDOW_IS_OBSCURED as u32; + const WINDOW_IS_OBSCURED = IInputConstants::MOTION_EVENT_FLAG_WINDOW_IS_OBSCURED as u32; /// FLAG_WINDOW_IS_PARTIALLY_OBSCURED - const WINDOW_IS_PARTIALLY_OBSCURED = MOTION_EVENT_FLAG_WINDOW_IS_PARTIALLY_OBSCURED as u32; + const WINDOW_IS_PARTIALLY_OBSCURED = IInputConstants::MOTION_EVENT_FLAG_WINDOW_IS_PARTIALLY_OBSCURED as u32; /// FLAG_HOVER_EXIT_PENDING - const HOVER_EXIT_PENDING = MOTION_EVENT_FLAG_HOVER_EXIT_PENDING as u32; + const HOVER_EXIT_PENDING = IInputConstants::MOTION_EVENT_FLAG_HOVER_EXIT_PENDING as u32; /// FLAG_IS_GENERATED_GESTURE - const IS_GENERATED_GESTURE = MOTION_EVENT_FLAG_IS_GENERATED_GESTURE as u32; + const IS_GENERATED_GESTURE = IInputConstants::MOTION_EVENT_FLAG_IS_GENERATED_GESTURE as u32; /// FLAG_CANCELED - const CANCELED = INPUT_EVENT_FLAG_CANCELED as u32; + const CANCELED = IInputConstants::INPUT_EVENT_FLAG_CANCELED as u32; /// FLAG_NO_FOCUS_CHANGE - const NO_FOCUS_CHANGE = MOTION_EVENT_FLAG_NO_FOCUS_CHANGE as u32; + const NO_FOCUS_CHANGE = IInputConstants::MOTION_EVENT_FLAG_NO_FOCUS_CHANGE as u32; /// FLAG_IS_ACCESSIBILITY_EVENT - const IS_ACCESSIBILITY_EVENT = INPUT_EVENT_FLAG_IS_ACCESSIBILITY_EVENT as u32; + const IS_ACCESSIBILITY_EVENT = IInputConstants::INPUT_EVENT_FLAG_IS_ACCESSIBILITY_EVENT as u32; /// FLAG_TAINTED - const TAINTED = INPUT_EVENT_FLAG_TAINTED as u32; + const TAINTED = IInputConstants::INPUT_EVENT_FLAG_TAINTED as u32; /// FLAG_TARGET_ACCESSIBILITY_FOCUS - const TARGET_ACCESSIBILITY_FOCUS = MOTION_EVENT_FLAG_TARGET_ACCESSIBILITY_FOCUS as u32; + const TARGET_ACCESSIBILITY_FOCUS = IInputConstants::MOTION_EVENT_FLAG_TARGET_ACCESSIBILITY_FOCUS as u32; } } @@ -220,6 +224,107 @@ impl Source { } } +bitflags! { + /// Device class of the input device. These are duplicated from Eventhub.h + /// We need to make sure the two version remain in sync when adding new classes. + #[derive(Debug, PartialEq)] + pub struct DeviceClass: u32 { + /// The input device is a keyboard or has buttons + const Keyboard = IInputConstants::DEVICE_CLASS_KEYBOARD as u32; + /// The input device is an alpha-numeric keyboard (not just a dial pad) + const AlphabeticKey = IInputConstants::DEVICE_CLASS_ALPHAKEY as u32; + /// The input device is a touchscreen or a touchpad (either single-touch or multi-touch) + const Touch = IInputConstants::DEVICE_CLASS_TOUCH as u32; + /// The input device is a cursor device such as a trackball or mouse. + const Cursor = IInputConstants::DEVICE_CLASS_CURSOR as u32; + /// The input device is a multi-touch touchscreen or touchpad. + const MultiTouch = IInputConstants::DEVICE_CLASS_TOUCH_MT as u32; + /// The input device is a directional pad (implies keyboard, has DPAD keys). + const Dpad = IInputConstants::DEVICE_CLASS_DPAD as u32; + /// The input device is a gamepad (implies keyboard, has BUTTON keys). + const Gamepad = IInputConstants::DEVICE_CLASS_GAMEPAD as u32; + /// The input device has switches. + const Switch = IInputConstants::DEVICE_CLASS_SWITCH as u32; + /// The input device is a joystick (implies gamepad, has joystick absolute axes). + const Joystick = IInputConstants::DEVICE_CLASS_JOYSTICK as u32; + /// The input device has a vibrator (supports FF_RUMBLE). + const Vibrator = IInputConstants::DEVICE_CLASS_VIBRATOR as u32; + /// The input device has a microphone. + const Mic = IInputConstants::DEVICE_CLASS_MIC as u32; + /// The input device is an external stylus (has data we want to fuse with touch data). + const ExternalStylus = IInputConstants::DEVICE_CLASS_EXTERNAL_STYLUS as u32; + /// The input device has a rotary encoder + const RotaryEncoder = IInputConstants::DEVICE_CLASS_ROTARY_ENCODER as u32; + /// The input device has a sensor like accelerometer, gyro, etc + const Sensor = IInputConstants::DEVICE_CLASS_SENSOR as u32; + /// The input device has a battery + const Battery = IInputConstants::DEVICE_CLASS_BATTERY as u32; + /// The input device has sysfs controllable lights + const Light = IInputConstants::DEVICE_CLASS_LIGHT as u32; + /// The input device is a touchpad, requiring an on-screen cursor. + const Touchpad = IInputConstants::DEVICE_CLASS_TOUCHPAD as u32; + /// The input device is virtual (not a real device, not part of UI configuration). + const Virtual = IInputConstants::DEVICE_CLASS_VIRTUAL as u32; + /// The input device is external (not built-in). + const External = IInputConstants::DEVICE_CLASS_EXTERNAL as u32; + } +} + +bitflags! { + /// Modifier state flags + #[derive(Debug, PartialEq)] + pub struct ModifierState: u32 { + /// No meta keys are pressed + const None = input_bindgen::AMETA_NONE; + /// This mask is used to check whether one of the ALT meta keys is pressed + const AltOn = input_bindgen::AMETA_ALT_ON; + /// This mask is used to check whether the left ALT meta key is pressed + const AltLeftOn = input_bindgen::AMETA_ALT_LEFT_ON; + /// This mask is used to check whether the right ALT meta key is pressed + const AltRightOn = input_bindgen::AMETA_ALT_RIGHT_ON; + /// This mask is used to check whether one of the SHIFT meta keys is pressed + const ShiftOn = input_bindgen::AMETA_SHIFT_ON; + /// This mask is used to check whether the left SHIFT meta key is pressed + const ShiftLeftOn = input_bindgen::AMETA_SHIFT_LEFT_ON; + /// This mask is used to check whether the right SHIFT meta key is pressed + const ShiftRightOn = input_bindgen::AMETA_SHIFT_RIGHT_ON; + /// This mask is used to check whether the SYM meta key is pressed + const SymOn = input_bindgen::AMETA_SYM_ON; + /// This mask is used to check whether the FUNCTION meta key is pressed + const FunctionOn = input_bindgen::AMETA_FUNCTION_ON; + /// This mask is used to check whether one of the CTRL meta keys is pressed + const CtrlOn = input_bindgen::AMETA_CTRL_ON; + /// This mask is used to check whether the left CTRL meta key is pressed + const CtrlLeftOn = input_bindgen::AMETA_CTRL_LEFT_ON; + /// This mask is used to check whether the right CTRL meta key is pressed + const CtrlRightOn = input_bindgen::AMETA_CTRL_RIGHT_ON; + /// This mask is used to check whether one of the META meta keys is pressed + const MetaOn = input_bindgen::AMETA_META_ON; + /// This mask is used to check whether the left META meta key is pressed + const MetaLeftOn = input_bindgen::AMETA_META_LEFT_ON; + /// This mask is used to check whether the right META meta key is pressed + const MetaRightOn = input_bindgen::AMETA_META_RIGHT_ON; + /// This mask is used to check whether the CAPS LOCK meta key is on + const CapsLockOn = input_bindgen::AMETA_CAPS_LOCK_ON; + /// This mask is used to check whether the NUM LOCK meta key is on + const NumLockOn = input_bindgen::AMETA_NUM_LOCK_ON; + /// This mask is used to check whether the SCROLL LOCK meta key is on + const ScrollLockOn = input_bindgen::AMETA_SCROLL_LOCK_ON; + } +} + +/// A rust enum representation of a Keyboard type. +#[repr(u32)] +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub enum KeyboardType { + /// KEYBOARD_TYPE_NONE + None = input_bindgen::AINPUT_KEYBOARD_TYPE_NONE, + /// KEYBOARD_TYPE_NON_ALPHABETIC + NonAlphabetic = input_bindgen::AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC, + /// KEYBOARD_TYPE_ALPHABETIC + Alphabetic = input_bindgen::AINPUT_KEYBOARD_TYPE_ALPHABETIC, +} + #[cfg(test)] mod tests { use crate::input::SourceClass; diff --git a/libs/input/rust/keyboard_classifier.rs b/libs/input/rust/keyboard_classifier.rs new file mode 100644 index 0000000000..bd3a51cb51 --- /dev/null +++ b/libs/input/rust/keyboard_classifier.rs @@ -0,0 +1,62 @@ +/* + * Copyright 2024 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//! Contains the KeyboardClassifier, that tries to identify whether an Input device is an +//! alphabetic or non-alphabetic keyboard. It also tracks the KeyEvents produced by the device +//! in order to verify/change the inferred keyboard type. + +use crate::input::{DeviceId, InputDevice, KeyboardType}; +use crate::ModifierState; + +/// The KeyboardClassifier is used to classify a keyboard device into non-keyboard, alphabetic +/// keyboard or non-alphabetic keyboard +#[derive(Default)] +pub struct KeyboardClassifier {} + +impl KeyboardClassifier { + /// Create a new KeyboardClassifier + pub fn new() -> Self { + Default::default() + } + + /// Adds keyboard to KeyboardClassifier + pub fn notify_keyboard_changed(&mut self, _device: InputDevice) { + // TODO(b/263559234): Implement method + } + + /// Get keyboard type for a tracked keyboard in KeyboardClassifier + pub fn get_keyboard_type(&self, _device_id: DeviceId) -> KeyboardType { + // TODO(b/263559234): Implement method + KeyboardType::None + } + + /// Tells if keyboard type classification is finalized. Once finalized the classification can't + /// change until device is reconnected again. + pub fn is_finalized(&self, _device_id: DeviceId) -> bool { + // TODO(b/263559234): Implement method + false + } + + /// Process a key event and change keyboard type if required. + pub fn process_key( + &mut self, + _device_id: DeviceId, + _evdev_code: i32, + _modifier_state: ModifierState, + ) { + // TODO(b/263559234): Implement method + } +} diff --git a/libs/input/rust/lib.rs b/libs/input/rust/lib.rs index fb3f520c01..5010475334 100644 --- a/libs/input/rust/lib.rs +++ b/libs/input/rust/lib.rs @@ -18,9 +18,13 @@ mod input; mod input_verifier; +mod keyboard_classifier; -pub use input::{DeviceId, MotionAction, MotionFlags, Source}; +pub use input::{ + DeviceClass, DeviceId, InputDevice, ModifierState, MotionAction, MotionFlags, Source, +}; pub use input_verifier::InputVerifier; +pub use keyboard_classifier::KeyboardClassifier; #[cxx::bridge(namespace = "android::input")] #[allow(unsafe_op_in_unsafe_fn)] @@ -47,7 +51,8 @@ mod ffi { /// } /// ``` type InputVerifier; - fn create(name: String) -> Box<InputVerifier>; + #[cxx_name = create] + fn create_input_verifier(name: String) -> Box<InputVerifier>; fn process_movement( verifier: &mut InputVerifier, device_id: i32, @@ -59,15 +64,53 @@ mod ffi { fn reset_device(verifier: &mut InputVerifier, device_id: i32); } + #[namespace = "android::input::keyboardClassifier"] + extern "Rust" { + /// Used to classify a keyboard into alphabetic and non-alphabetic + type KeyboardClassifier; + #[cxx_name = create] + fn create_keyboard_classifier() -> Box<KeyboardClassifier>; + #[cxx_name = notifyKeyboardChanged] + fn notify_keyboard_changed( + classifier: &mut KeyboardClassifier, + device_id: i32, + identifier: RustInputDeviceIdentifier, + device_classes: u32, + ); + #[cxx_name = getKeyboardType] + fn get_keyboard_type(classifier: &mut KeyboardClassifier, device_id: i32) -> u32; + #[cxx_name = isFinalized] + fn is_finalized(classifier: &mut KeyboardClassifier, device_id: i32) -> bool; + #[cxx_name = processKey] + fn process_key( + classifier: &mut KeyboardClassifier, + device_id: i32, + evdev_code: i32, + modifier_state: u32, + ); + } + #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] pub struct RustPointerProperties { pub id: i32, } + + #[derive(Debug)] + pub struct RustInputDeviceIdentifier { + pub name: String, + pub location: String, + pub unique_id: String, + pub bus: u16, + pub vendor: u16, + pub product: u16, + pub version: u16, + pub descriptor: String, + } } -use crate::ffi::RustPointerProperties; +use crate::ffi::{RustInputDeviceIdentifier, RustPointerProperties}; -fn create(name: String) -> Box<InputVerifier> { +fn create_input_verifier(name: String) -> Box<InputVerifier> { Box::new(InputVerifier::new(&name, ffi::shouldLog("InputVerifierLogEvents"))) } @@ -103,3 +146,53 @@ fn process_movement( fn reset_device(verifier: &mut InputVerifier, device_id: i32) { verifier.reset_device(DeviceId(device_id)); } + +fn create_keyboard_classifier() -> Box<KeyboardClassifier> { + Box::new(KeyboardClassifier::new()) +} + +fn notify_keyboard_changed( + classifier: &mut KeyboardClassifier, + device_id: i32, + identifier: RustInputDeviceIdentifier, + device_classes: u32, +) { + let classes = DeviceClass::from_bits(device_classes); + if classes.is_none() { + panic!( + "The conversion of device class 0x{:08x} failed, please check if some device classes + have not been added to DeviceClass.", + device_classes + ); + } + classifier.notify_keyboard_changed(InputDevice { + device_id: DeviceId(device_id), + identifier, + classes: classes.unwrap(), + }); +} + +fn get_keyboard_type(classifier: &mut KeyboardClassifier, device_id: i32) -> u32 { + classifier.get_keyboard_type(DeviceId(device_id)) as u32 +} + +fn is_finalized(classifier: &mut KeyboardClassifier, device_id: i32) -> bool { + classifier.is_finalized(DeviceId(device_id)) +} + +fn process_key( + classifier: &mut KeyboardClassifier, + device_id: i32, + evdev_code: i32, + meta_state: u32, +) { + let modifier_state = ModifierState::from_bits(meta_state); + if modifier_state.is_none() { + panic!( + "The conversion of meta state 0x{:08x} failed, please check if some meta state + have not been added to ModifierState.", + meta_state + ); + } + classifier.process_key(DeviceId(device_id), evdev_code, modifier_state.unwrap()); +} diff --git a/services/inputflinger/reader/InputDevice.cpp b/services/inputflinger/reader/InputDevice.cpp index b807b2714f..2b33403737 100644 --- a/services/inputflinger/reader/InputDevice.cpp +++ b/services/inputflinger/reader/InputDevice.cpp @@ -237,6 +237,12 @@ std::list<NotifyArgs> InputDevice::configureInternal(nsecs_t when, mIsExternal = mClasses.test(InputDeviceClass::EXTERNAL); mHasMic = mClasses.test(InputDeviceClass::MIC); + // Update keyboard type + if (mClasses.test(InputDeviceClass::KEYBOARD)) { + mContext->getKeyboardClassifier().notifyKeyboardChanged(mId, mIdentifier, mClasses.get()); + mKeyboardType = mContext->getKeyboardClassifier().getKeyboardType(mId); + } + using Change = InputReaderConfiguration::Change; if (!changes.any() || !isIgnored()) { @@ -445,6 +451,7 @@ InputDeviceInfo InputDevice::getDeviceInfo() { mHasMic, getAssociatedDisplayId().value_or(ui::LogicalDisplayId::INVALID), {mShouldSmoothScroll}, isEnabled()); + outDeviceInfo.setKeyboardType(static_cast<int32_t>(mKeyboardType)); for_each_mapper( [&outDeviceInfo](InputMapper& mapper) { mapper.populateDeviceInfo(outDeviceInfo); }); @@ -517,13 +524,9 @@ std::vector<std::unique_ptr<InputMapper>> InputDevice::createMappers( // Keyboard-like devices. uint32_t keyboardSource = 0; - int32_t keyboardType = AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC; if (classes.test(InputDeviceClass::KEYBOARD)) { keyboardSource |= AINPUT_SOURCE_KEYBOARD; } - if (classes.test(InputDeviceClass::ALPHAKEY)) { - keyboardType = AINPUT_KEYBOARD_TYPE_ALPHABETIC; - } if (classes.test(InputDeviceClass::DPAD)) { keyboardSource |= AINPUT_SOURCE_DPAD; } @@ -532,8 +535,8 @@ std::vector<std::unique_ptr<InputMapper>> InputDevice::createMappers( } if (keyboardSource != 0) { - mappers.push_back(createInputMapper<KeyboardInputMapper>(contextPtr, readerConfig, - keyboardSource, keyboardType)); + mappers.push_back( + createInputMapper<KeyboardInputMapper>(contextPtr, readerConfig, keyboardSource)); } // Cursor-like devices. @@ -730,6 +733,13 @@ std::optional<int32_t> InputDevice::getBatteryEventHubId() const { return mController ? std::make_optional(mController->getEventHubId()) : std::nullopt; } +void InputDevice::setKeyboardType(KeyboardType keyboardType) { + if (mKeyboardType != keyboardType) { + mKeyboardType = keyboardType; + bumpGeneration(); + } +} + InputDeviceContext::InputDeviceContext(InputDevice& device, int32_t eventHubId) : mDevice(device), mContext(device.getContext()), diff --git a/services/inputflinger/reader/InputReader.cpp b/services/inputflinger/reader/InputReader.cpp index b9523ef332..ab13ad489b 100644 --- a/services/inputflinger/reader/InputReader.cpp +++ b/services/inputflinger/reader/InputReader.cpp @@ -102,6 +102,7 @@ InputReader::InputReader(std::shared_ptr<EventHubInterface> eventHub, mEventHub(eventHub), mPolicy(policy), mNextListener(listener), + mKeyboardClassifier(std::make_unique<KeyboardClassifier>()), mGlobalMetaState(AMETA_NONE), mLedMetaState(AMETA_NONE), mGeneration(1), @@ -1076,4 +1077,8 @@ int32_t InputReader::ContextImpl::getNextId() { return mIdGenerator.nextId(); } +KeyboardClassifier& InputReader::ContextImpl::getKeyboardClassifier() { + return *mReader->mKeyboardClassifier; +} + } // namespace android diff --git a/services/inputflinger/reader/include/EventHub.h b/services/inputflinger/reader/include/EventHub.h index 39d2f5baab..7cf584df78 100644 --- a/services/inputflinger/reader/include/EventHub.h +++ b/services/inputflinger/reader/include/EventHub.h @@ -85,64 +85,67 @@ std::ostream& operator<<(std::ostream& out, const RawAbsoluteAxisInfo& info); /* * Input device classes. + * + * These classes are duplicated in rust side here: /frameworks/native/libs/input/rust/input.rs. + * If any new classes are added, we need to add them in rust input side too. */ enum class InputDeviceClass : uint32_t { /* The input device is a keyboard or has buttons. */ - KEYBOARD = 0x00000001, + KEYBOARD = android::os::IInputConstants::DEVICE_CLASS_KEYBOARD, /* The input device is an alpha-numeric keyboard (not just a dial pad). */ - ALPHAKEY = 0x00000002, + ALPHAKEY = android::os::IInputConstants::DEVICE_CLASS_ALPHAKEY, /* The input device is a touchscreen or a touchpad (either single-touch or multi-touch). */ - TOUCH = 0x00000004, + TOUCH = android::os::IInputConstants::DEVICE_CLASS_TOUCH, /* The input device is a cursor device such as a trackball or mouse. */ - CURSOR = 0x00000008, + CURSOR = android::os::IInputConstants::DEVICE_CLASS_CURSOR, /* The input device is a multi-touch touchscreen or touchpad. */ - TOUCH_MT = 0x00000010, + TOUCH_MT = android::os::IInputConstants::DEVICE_CLASS_TOUCH_MT, /* The input device is a directional pad (implies keyboard, has DPAD keys). */ - DPAD = 0x00000020, + DPAD = android::os::IInputConstants::DEVICE_CLASS_DPAD, /* The input device is a gamepad (implies keyboard, has BUTTON keys). */ - GAMEPAD = 0x00000040, + GAMEPAD = android::os::IInputConstants::DEVICE_CLASS_GAMEPAD, /* The input device has switches. */ - SWITCH = 0x00000080, + SWITCH = android::os::IInputConstants::DEVICE_CLASS_SWITCH, /* The input device is a joystick (implies gamepad, has joystick absolute axes). */ - JOYSTICK = 0x00000100, + JOYSTICK = android::os::IInputConstants::DEVICE_CLASS_JOYSTICK, /* The input device has a vibrator (supports FF_RUMBLE). */ - VIBRATOR = 0x00000200, + VIBRATOR = android::os::IInputConstants::DEVICE_CLASS_VIBRATOR, /* The input device has a microphone. */ - MIC = 0x00000400, + MIC = android::os::IInputConstants::DEVICE_CLASS_MIC, /* The input device is an external stylus (has data we want to fuse with touch data). */ - EXTERNAL_STYLUS = 0x00000800, + EXTERNAL_STYLUS = android::os::IInputConstants::DEVICE_CLASS_EXTERNAL_STYLUS, /* The input device has a rotary encoder */ - ROTARY_ENCODER = 0x00001000, + ROTARY_ENCODER = android::os::IInputConstants::DEVICE_CLASS_ROTARY_ENCODER, /* The input device has a sensor like accelerometer, gyro, etc */ - SENSOR = 0x00002000, + SENSOR = android::os::IInputConstants::DEVICE_CLASS_SENSOR, /* The input device has a battery */ - BATTERY = 0x00004000, + BATTERY = android::os::IInputConstants::DEVICE_CLASS_BATTERY, /* The input device has sysfs controllable lights */ - LIGHT = 0x00008000, + LIGHT = android::os::IInputConstants::DEVICE_CLASS_LIGHT, /* The input device is a touchpad, requiring an on-screen cursor. */ - TOUCHPAD = 0x00010000, + TOUCHPAD = android::os::IInputConstants::DEVICE_CLASS_TOUCHPAD, /* The input device is virtual (not a real device, not part of UI configuration). */ - VIRTUAL = 0x40000000, + VIRTUAL = android::os::IInputConstants::DEVICE_CLASS_VIRTUAL, /* The input device is external (not built-in). */ - EXTERNAL = 0x80000000, + EXTERNAL = android::os::IInputConstants::DEVICE_CLASS_EXTERNAL, }; enum class SysfsClass : uint32_t { diff --git a/services/inputflinger/reader/include/InputDevice.h b/services/inputflinger/reader/include/InputDevice.h index 4c9af2e30e..2a7e262bf5 100644 --- a/services/inputflinger/reader/include/InputDevice.h +++ b/services/inputflinger/reader/include/InputDevice.h @@ -79,6 +79,8 @@ public: inline bool isIgnored() { return !getMapperCount() && !mController; } + inline KeyboardType getKeyboardType() const { return mKeyboardType; } + bool isEnabled(); void dump(std::string& dump, const std::string& eventHubDevStr); @@ -124,6 +126,8 @@ public: void addKeyRemapping(int32_t fromKeyCode, int32_t toKeyCode); + void setKeyboardType(KeyboardType keyboardType); + void bumpGeneration(); [[nodiscard]] NotifyDeviceResetArgs notifyReset(nsecs_t when); @@ -196,6 +200,7 @@ private: uint32_t mSources; bool mIsWaking; bool mIsExternal; + KeyboardType mKeyboardType = KeyboardType::NONE; std::optional<uint8_t> mAssociatedDisplayPort; std::optional<std::string> mAssociatedDisplayUniqueIdByPort; std::optional<std::string> mAssociatedDisplayUniqueIdByDescriptor; @@ -470,6 +475,10 @@ public: } inline void bumpGeneration() { mDevice.bumpGeneration(); } inline const PropertyMap& getConfiguration() const { return mDevice.getConfiguration(); } + inline KeyboardType getKeyboardType() const { return mDevice.getKeyboardType(); } + inline void setKeyboardType(KeyboardType keyboardType) { + return mDevice.setKeyboardType(keyboardType); + } private: InputDevice& mDevice; diff --git a/services/inputflinger/reader/include/InputReader.h b/services/inputflinger/reader/include/InputReader.h index 7e701c5341..6f8c289093 100644 --- a/services/inputflinger/reader/include/InputReader.h +++ b/services/inputflinger/reader/include/InputReader.h @@ -157,6 +157,7 @@ protected: void setLastKeyDownTimestamp(nsecs_t when) REQUIRES(mReader->mLock) REQUIRES(mLock) override; nsecs_t getLastKeyDownTimestamp() REQUIRES(mReader->mLock) REQUIRES(mLock) override; + KeyboardClassifier& getKeyboardClassifier() override; } mContext; friend class ContextImpl; @@ -176,6 +177,10 @@ private: // The next stage that should receive the events generated inside InputReader. InputListenerInterface& mNextListener; + + // Classifier for keyboard/keyboard-like devices + std::unique_ptr<KeyboardClassifier> mKeyboardClassifier; + // As various events are generated inside InputReader, they are stored inside this list. The // list can only be accessed with the lock, so the events inside it are well-ordered. // Once the reader is done working, these events will be swapped into a temporary storage and diff --git a/services/inputflinger/reader/include/InputReaderContext.h b/services/inputflinger/reader/include/InputReaderContext.h index 907a49faa2..e0e0ac2051 100644 --- a/services/inputflinger/reader/include/InputReaderContext.h +++ b/services/inputflinger/reader/include/InputReaderContext.h @@ -17,6 +17,7 @@ #pragma once #include <input/InputDevice.h> +#include <input/KeyboardClassifier.h> #include "NotifyArgs.h" #include <vector> @@ -64,6 +65,8 @@ public: virtual void setLastKeyDownTimestamp(nsecs_t when) = 0; virtual nsecs_t getLastKeyDownTimestamp() = 0; + + virtual KeyboardClassifier& getKeyboardClassifier() = 0; }; } // namespace android diff --git a/services/inputflinger/reader/mapper/KeyboardInputMapper.cpp b/services/inputflinger/reader/mapper/KeyboardInputMapper.cpp index 21245555a2..2e32380662 100644 --- a/services/inputflinger/reader/mapper/KeyboardInputMapper.cpp +++ b/services/inputflinger/reader/mapper/KeyboardInputMapper.cpp @@ -21,6 +21,7 @@ #include "KeyboardInputMapper.h" #include <ftl/enum.h> +#include <input/KeyboardClassifier.h> #include <ui/Rotation.h> namespace android { @@ -96,8 +97,8 @@ static bool isMediaKey(int32_t keyCode) { KeyboardInputMapper::KeyboardInputMapper(InputDeviceContext& deviceContext, const InputReaderConfiguration& readerConfig, - uint32_t source, int32_t keyboardType) - : InputMapper(deviceContext, readerConfig), mSource(source), mKeyboardType(keyboardType) {} + uint32_t source) + : InputMapper(deviceContext, readerConfig), mSource(source) {} uint32_t KeyboardInputMapper::getSources() const { return mSource; @@ -131,7 +132,6 @@ std::optional<KeyboardLayoutInfo> KeyboardInputMapper::getKeyboardLayoutInfo() c void KeyboardInputMapper::populateDeviceInfo(InputDeviceInfo& info) { InputMapper::populateDeviceInfo(info); - info.setKeyboardType(mKeyboardType); info.setKeyCharacterMap(getDeviceContext().getKeyCharacterMap()); std::optional keyboardLayoutInfo = getKeyboardLayoutInfo(); @@ -143,7 +143,6 @@ void KeyboardInputMapper::populateDeviceInfo(InputDeviceInfo& info) { void KeyboardInputMapper::dump(std::string& dump) { dump += INDENT2 "Keyboard Input Mapper:\n"; dumpParameters(dump); - dump += StringPrintf(INDENT3 "KeyboardType: %d\n", mKeyboardType); dump += StringPrintf(INDENT3 "Orientation: %s\n", ftl::enum_string(getOrientation()).c_str()); dump += StringPrintf(INDENT3 "KeyDowns: %zu keys currently down\n", mKeyDowns.size()); dump += StringPrintf(INDENT3 "MetaState: 0x%0x\n", mMetaState); @@ -327,13 +326,24 @@ std::list<NotifyArgs> KeyboardInputMapper::processKey(nsecs_t when, nsecs_t read keyMetaState = mMetaState; } + DeviceId deviceId = getDeviceId(); + + // On first down: Process key for keyboard classification (will send reconfiguration if the + // keyboard type change) + if (down && !keyDownIndex) { + KeyboardClassifier& classifier = getDeviceContext().getContext()->getKeyboardClassifier(); + classifier.processKey(deviceId, scanCode, keyMetaState); + getDeviceContext().setKeyboardType(classifier.getKeyboardType(deviceId)); + } + + KeyboardType keyboardType = getDeviceContext().getKeyboardType(); // Any key down on an external keyboard should wake the device. // We don't do this for internal keyboards to prevent them from waking up in your pocket. // For internal keyboards and devices for which the default wake behavior is explicitly // prevented (e.g. TV remotes), the key layout file should specify the policy flags for each // wake key individually. if (down && getDeviceContext().isExternal() && !mParameters.doNotWakeByDefault && - !(mKeyboardType != AINPUT_KEYBOARD_TYPE_ALPHABETIC && isMediaKey(keyCode))) { + !(keyboardType != KeyboardType::ALPHABETIC && isMediaKey(keyCode))) { policyFlags |= POLICY_FLAG_WAKE; } @@ -341,8 +351,8 @@ std::list<NotifyArgs> KeyboardInputMapper::processKey(nsecs_t when, nsecs_t read policyFlags |= POLICY_FLAG_DISABLE_KEY_REPEAT; } - out.emplace_back(NotifyKeyArgs(getContext()->getNextId(), when, readTime, getDeviceId(), - mSource, getDisplayId(), policyFlags, + out.emplace_back(NotifyKeyArgs(getContext()->getNextId(), when, readTime, deviceId, mSource, + getDisplayId(), policyFlags, down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP, flags, keyCode, scanCode, keyMetaState, downTime)); return out; diff --git a/services/inputflinger/reader/mapper/KeyboardInputMapper.h b/services/inputflinger/reader/mapper/KeyboardInputMapper.h index f2d3f4d7d8..bee2a99191 100644 --- a/services/inputflinger/reader/mapper/KeyboardInputMapper.h +++ b/services/inputflinger/reader/mapper/KeyboardInputMapper.h @@ -61,7 +61,6 @@ private: }; uint32_t mSource{}; - int32_t mKeyboardType{}; std::optional<KeyboardLayoutInfo> mKeyboardLayoutInfo; std::vector<KeyDown> mKeyDowns{}; // keys that are down @@ -85,8 +84,7 @@ private: } mParameters{}; KeyboardInputMapper(InputDeviceContext& deviceContext, - const InputReaderConfiguration& readerConfig, uint32_t source, - int32_t keyboardType); + const InputReaderConfiguration& readerConfig, uint32_t source); void configureParameters(); void dumpParameters(std::string& dump) const; diff --git a/services/inputflinger/tests/InputReader_test.cpp b/services/inputflinger/tests/InputReader_test.cpp index 8536ff0676..07fa59ff32 100644 --- a/services/inputflinger/tests/InputReader_test.cpp +++ b/services/inputflinger/tests/InputReader_test.cpp @@ -3314,6 +3314,10 @@ TEST_F(SensorInputMapperTest, ProcessGyroscopeSensor) { class KeyboardInputMapperTest : public InputMapperTest { protected: + void SetUp() override { + InputMapperTest::SetUp(DEVICE_CLASSES | InputDeviceClass::KEYBOARD | + InputDeviceClass::ALPHAKEY); + } const std::string UNIQUE_ID = "local:0"; const KeyboardLayoutInfo DEVICE_KEYBOARD_LAYOUT_INFO = KeyboardLayoutInfo("en-US", "qwerty"); void prepareDisplay(ui::Rotation orientation); @@ -3354,8 +3358,7 @@ void KeyboardInputMapperTest::testDPadKeyRotation(KeyboardInputMapper& mapper, TEST_F(KeyboardInputMapperTest, GetSources) { KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, mapper.getSources()); } @@ -3370,8 +3373,7 @@ TEST_F(KeyboardInputMapperTest, Process_SimpleKeyPress) { mFakeEventHub->addKey(EVENTHUB_ID, 0, KEY_SCROLLLOCK, AKEYCODE_SCROLL_LOCK, POLICY_FLAG_WAKE); KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); // Initial metastate is AMETA_NONE. ASSERT_EQ(AMETA_NONE, mapper.getMetaState()); @@ -3471,8 +3473,7 @@ TEST_F(KeyboardInputMapperTest, Process_KeyRemapping) { mFakeEventHub->addKeyRemapping(EVENTHUB_ID, AKEYCODE_A, AKEYCODE_B); KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); // Key down by scan code. process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_A, 1); @@ -3493,8 +3494,7 @@ TEST_F(KeyboardInputMapperTest, Process_SendsReadTime) { mFakeEventHub->addKey(EVENTHUB_ID, KEY_HOME, 0, AKEYCODE_HOME, POLICY_FLAG_WAKE); KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); NotifyKeyArgs args; // Key down @@ -3516,8 +3516,7 @@ TEST_F(KeyboardInputMapperTest, Process_ShouldUpdateMetaState) { mFakeEventHub->addKey(EVENTHUB_ID, 0, KEY_SCROLLLOCK, AKEYCODE_SCROLL_LOCK, 0); KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); // Initial metastate is AMETA_NONE. ASSERT_EQ(AMETA_NONE, mapper.getMetaState()); @@ -3557,8 +3556,7 @@ TEST_F(KeyboardInputMapperTest, Process_WhenNotOrientationAware_ShouldNotRotateD mFakeEventHub->addKey(EVENTHUB_ID, KEY_LEFT, 0, AKEYCODE_DPAD_LEFT, 0); KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); prepareDisplay(ui::ROTATION_90); ASSERT_NO_FATAL_FAILURE(testDPadKeyRotation(mapper, @@ -3579,8 +3577,7 @@ TEST_F(KeyboardInputMapperTest, Process_WhenOrientationAware_ShouldRotateDPad) { addConfigurationProperty("keyboard.orientationAware", "1"); KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); prepareDisplay(ui::ROTATION_0); ASSERT_NO_FATAL_FAILURE( @@ -3651,8 +3648,7 @@ TEST_F(KeyboardInputMapperTest, DisplayIdConfigurationChange_NotOrientationAware mFakeEventHub->addKey(EVENTHUB_ID, KEY_UP, 0, AKEYCODE_DPAD_UP, 0); KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); NotifyKeyArgs args; // Display id should be LogicalDisplayId::INVALID without any display configuration. @@ -3677,8 +3673,7 @@ TEST_F(KeyboardInputMapperTest, DisplayIdConfigurationChange_OrientationAware) { addConfigurationProperty("keyboard.orientationAware", "1"); KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); NotifyKeyArgs args; // Display id should be LogicalDisplayId::INVALID without any display configuration. @@ -3705,8 +3700,7 @@ TEST_F(KeyboardInputMapperTest, DisplayIdConfigurationChange_OrientationAware) { TEST_F(KeyboardInputMapperTest, GetKeyCodeState) { KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); mFakeEventHub->setKeyCodeState(EVENTHUB_ID, AKEYCODE_A, 1); ASSERT_EQ(1, mapper.getKeyCodeState(AINPUT_SOURCE_ANY, AKEYCODE_A)); @@ -3717,8 +3711,7 @@ TEST_F(KeyboardInputMapperTest, GetKeyCodeState) { TEST_F(KeyboardInputMapperTest, GetKeyCodeForKeyLocation) { KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); mFakeEventHub->addKeyCodeMapping(EVENTHUB_ID, AKEYCODE_Y, AKEYCODE_Z); ASSERT_EQ(AKEYCODE_Z, mapper.getKeyCodeForKeyLocation(AKEYCODE_Y)) @@ -3730,8 +3723,7 @@ TEST_F(KeyboardInputMapperTest, GetKeyCodeForKeyLocation) { TEST_F(KeyboardInputMapperTest, GetScanCodeState) { KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); mFakeEventHub->setScanCodeState(EVENTHUB_ID, KEY_A, 1); ASSERT_EQ(1, mapper.getScanCodeState(AINPUT_SOURCE_ANY, KEY_A)); @@ -3742,8 +3734,7 @@ TEST_F(KeyboardInputMapperTest, GetScanCodeState) { TEST_F(KeyboardInputMapperTest, MarkSupportedKeyCodes) { KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); mFakeEventHub->addKey(EVENTHUB_ID, KEY_A, 0, AKEYCODE_A, 0); @@ -3762,8 +3753,7 @@ TEST_F(KeyboardInputMapperTest, Process_LockedKeysShouldToggleMetaStateAndLeds) mFakeEventHub->addKey(EVENTHUB_ID, KEY_SCROLLLOCK, 0, AKEYCODE_SCROLL_LOCK, 0); KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); // Initial metastate is AMETA_NONE. ASSERT_EQ(AMETA_NONE, mapper.getMetaState()); @@ -3828,8 +3818,7 @@ TEST_F(KeyboardInputMapperTest, NoMetaStateWhenMetaKeysNotPresent) { mFakeEventHub->addKey(EVENTHUB_ID, BTN_Y, 0, AKEYCODE_BUTTON_Y, 0); KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); // Meta state should be AMETA_NONE after reset std::list<NotifyArgs> unused = mapper.reset(ARBITRARY_TIME); @@ -3878,16 +3867,14 @@ TEST_F(KeyboardInputMapperTest, Configure_AssignsDisplayPort) { mFakeEventHub->addKey(SECOND_EVENTHUB_ID, KEY_LEFT, 0, AKEYCODE_DPAD_LEFT, 0); KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); device2->addEmptyEventHubDevice(SECOND_EVENTHUB_ID); KeyboardInputMapper& mapper2 = device2->constructAndAddMapper<KeyboardInputMapper>(SECOND_EVENTHUB_ID, mFakePolicy ->getReaderConfiguration(), - AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + AINPUT_SOURCE_KEYBOARD); std::list<NotifyArgs> unused = device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), /*changes=*/{}); @@ -3949,8 +3936,7 @@ TEST_F(KeyboardInputMapperTest, Process_LockedKeysShouldToggleAfterReattach) { mFakeEventHub->addKey(EVENTHUB_ID, KEY_SCROLLLOCK, 0, AKEYCODE_SCROLL_LOCK, 0); KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); // Initial metastate is AMETA_NONE. ASSERT_EQ(AMETA_NONE, mapper.getMetaState()); @@ -4000,8 +3986,7 @@ TEST_F(KeyboardInputMapperTest, Process_LockedKeysShouldToggleAfterReattach) { device2->constructAndAddMapper<KeyboardInputMapper>(SECOND_EVENTHUB_ID, mFakePolicy ->getReaderConfiguration(), - AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + AINPUT_SOURCE_KEYBOARD); std::list<NotifyArgs> unused = device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), /*changes=*/{}); @@ -4020,11 +4005,9 @@ TEST_F(KeyboardInputMapperTest, Process_toggleCapsLockState) { mFakeEventHub->addKey(EVENTHUB_ID, KEY_SCROLLLOCK, 0, AKEYCODE_SCROLL_LOCK, 0); // Suppose we have two mappers. (DPAD + KEYBOARD) - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_DPAD, - AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_DPAD); KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); // Initial metastate is AMETA_NONE. ASSERT_EQ(AMETA_NONE, mapper.getMetaState()); @@ -4042,8 +4025,7 @@ TEST_F(KeyboardInputMapperTest, Process_LockedKeysShouldToggleInMultiDevices) { mFakeEventHub->addKey(EVENTHUB_ID, KEY_SCROLLLOCK, 0, AKEYCODE_SCROLL_LOCK, 0); KeyboardInputMapper& mapper1 = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); // keyboard 2. const std::string USB2 = "USB2"; @@ -4065,8 +4047,7 @@ TEST_F(KeyboardInputMapperTest, Process_LockedKeysShouldToggleInMultiDevices) { device2->constructAndAddMapper<KeyboardInputMapper>(SECOND_EVENTHUB_ID, mFakePolicy ->getReaderConfiguration(), - AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + AINPUT_SOURCE_KEYBOARD); std::list<NotifyArgs> unused = device2->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), /*changes=*/{}); @@ -4122,8 +4103,7 @@ TEST_F(KeyboardInputMapperTest, Process_DisabledDevice) { mFakeEventHub->addKey(EVENTHUB_ID, 0, USAGE_A, AKEYCODE_A, POLICY_FLAG_WAKE); KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); // Key down by scan code. process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_HOME, 1); NotifyKeyArgs args; @@ -4148,8 +4128,7 @@ TEST_F(KeyboardInputMapperTest, Process_DisabledDevice) { } TEST_F(KeyboardInputMapperTest, Configure_AssignKeyboardLayoutInfo) { - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); std::list<NotifyArgs> unused = mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), /*changes=*/{}); @@ -4180,8 +4159,7 @@ TEST_F(KeyboardInputMapperTest, LayoutInfoCorrectlyMapped) { RawLayoutInfo{.languageTag = "en", .layoutType = "extended"}); // Configuration - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); InputReaderConfiguration config; std::list<NotifyArgs> unused = mDevice->configure(ARBITRARY_TIME, config, /*changes=*/{}); @@ -4192,8 +4170,7 @@ TEST_F(KeyboardInputMapperTest, LayoutInfoCorrectlyMapped) { TEST_F(KeyboardInputMapperTest, Process_GesureEventToSetFlagKeepTouchMode) { mFakeEventHub->addKey(EVENTHUB_ID, KEY_LEFT, 0, AKEYCODE_DPAD_LEFT, POLICY_FLAG_GESTURE); KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); NotifyKeyArgs args; // Key down @@ -4202,14 +4179,27 @@ TEST_F(KeyboardInputMapperTest, Process_GesureEventToSetFlagKeepTouchMode) { ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_KEEP_TOUCH_MODE, args.flags); } -// --- KeyboardInputMapperTest_ExternalDevice --- +// --- KeyboardInputMapperTest_ExternalAlphabeticDevice --- -class KeyboardInputMapperTest_ExternalDevice : public InputMapperTest { +class KeyboardInputMapperTest_ExternalAlphabeticDevice : public InputMapperTest { protected: - void SetUp() override { InputMapperTest::SetUp(DEVICE_CLASSES | InputDeviceClass::EXTERNAL); } + void SetUp() override { + InputMapperTest::SetUp(DEVICE_CLASSES | InputDeviceClass::KEYBOARD | + InputDeviceClass::ALPHAKEY | InputDeviceClass::EXTERNAL); + } +}; + +// --- KeyboardInputMapperTest_ExternalNonAlphabeticDevice --- + +class KeyboardInputMapperTest_ExternalNonAlphabeticDevice : public InputMapperTest { +protected: + void SetUp() override { + InputMapperTest::SetUp(DEVICE_CLASSES | InputDeviceClass::KEYBOARD | + InputDeviceClass::EXTERNAL); + } }; -TEST_F(KeyboardInputMapperTest_ExternalDevice, WakeBehavior_AlphabeticKeyboard) { +TEST_F(KeyboardInputMapperTest_ExternalAlphabeticDevice, WakeBehavior_AlphabeticKeyboard) { // For external devices, keys will trigger wake on key down. Media keys should also trigger // wake if triggered from external devices. @@ -4219,8 +4209,7 @@ TEST_F(KeyboardInputMapperTest_ExternalDevice, WakeBehavior_AlphabeticKeyboard) POLICY_FLAG_WAKE); KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_HOME, 1); NotifyKeyArgs args; @@ -4248,7 +4237,7 @@ TEST_F(KeyboardInputMapperTest_ExternalDevice, WakeBehavior_AlphabeticKeyboard) ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags); } -TEST_F(KeyboardInputMapperTest_ExternalDevice, WakeBehavior_NoneAlphabeticKeyboard) { +TEST_F(KeyboardInputMapperTest_ExternalNonAlphabeticDevice, WakeBehavior_NonAlphabeticKeyboard) { // For external devices, keys will trigger wake on key down. Media keys should not trigger // wake if triggered from external non-alphaebtic keyboard (e.g. headsets). @@ -4257,8 +4246,7 @@ TEST_F(KeyboardInputMapperTest_ExternalDevice, WakeBehavior_NoneAlphabeticKeyboa POLICY_FLAG_WAKE); KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_PLAY, 1); NotifyKeyArgs args; @@ -4278,7 +4266,7 @@ TEST_F(KeyboardInputMapperTest_ExternalDevice, WakeBehavior_NoneAlphabeticKeyboa ASSERT_EQ(POLICY_FLAG_WAKE, args.policyFlags); } -TEST_F(KeyboardInputMapperTest_ExternalDevice, DoNotWakeByDefaultBehavior) { +TEST_F(KeyboardInputMapperTest_ExternalAlphabeticDevice, DoNotWakeByDefaultBehavior) { // Tv Remote key's wake behavior is prescribed by the keylayout file. mFakeEventHub->addKey(EVENTHUB_ID, KEY_HOME, 0, AKEYCODE_HOME, POLICY_FLAG_WAKE); @@ -4287,8 +4275,7 @@ TEST_F(KeyboardInputMapperTest_ExternalDevice, DoNotWakeByDefaultBehavior) { addConfigurationProperty("keyboard.doNotWakeByDefault", "1"); KeyboardInputMapper& mapper = - constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + constructAndAddMapper<KeyboardInputMapper>(AINPUT_SOURCE_KEYBOARD); process(mapper, ARBITRARY_TIME, READ_TIME, EV_KEY, KEY_HOME, 1); NotifyKeyArgs args; diff --git a/services/inputflinger/tests/InterfaceMocks.h b/services/inputflinger/tests/InterfaceMocks.h index 6389cdc5fb..2d4e917691 100644 --- a/services/inputflinger/tests/InterfaceMocks.h +++ b/services/inputflinger/tests/InterfaceMocks.h @@ -36,6 +36,7 @@ #include <input/InputDevice.h> #include <input/KeyCharacterMap.h> #include <input/KeyLayoutMap.h> +#include <input/KeyboardClassifier.h> #include <input/PropertyMap.h> #include <input/TouchVideoFrame.h> #include <input/VirtualKeyMap.h> @@ -75,8 +76,11 @@ public: MOCK_METHOD(void, setLastKeyDownTimestamp, (nsecs_t when)); MOCK_METHOD(nsecs_t, getLastKeyDownTimestamp, ()); + KeyboardClassifier& getKeyboardClassifier() override { return *mClassifier; }; + private: int32_t mGeneration = 0; + std::unique_ptr<KeyboardClassifier> mClassifier = std::make_unique<KeyboardClassifier>(); }; class MockEventHubInterface : public EventHubInterface { diff --git a/services/inputflinger/tests/KeyboardInputMapper_test.cpp b/services/inputflinger/tests/KeyboardInputMapper_test.cpp index 031b77d67a..ada841d28d 100644 --- a/services/inputflinger/tests/KeyboardInputMapper_test.cpp +++ b/services/inputflinger/tests/KeyboardInputMapper_test.cpp @@ -67,8 +67,7 @@ protected: EXPECT_CALL(mMockInputReaderContext, getPolicy).WillRepeatedly(Return(mFakePolicy.get())); mMapper = createInputMapper<KeyboardInputMapper>(*mDeviceContext, mReaderConfiguration, - AINPUT_SOURCE_KEYBOARD, - AINPUT_KEYBOARD_TYPE_ALPHABETIC); + AINPUT_SOURCE_KEYBOARD); } void testPointerVisibilityForKeys(const std::vector<int32_t>& keyCodes, bool expectVisible) { diff --git a/services/inputflinger/tests/fuzzers/KeyboardInputFuzzer.cpp b/services/inputflinger/tests/fuzzers/KeyboardInputFuzzer.cpp index 922cbdfb87..3b3f8d25c3 100644 --- a/services/inputflinger/tests/fuzzers/KeyboardInputFuzzer.cpp +++ b/services/inputflinger/tests/fuzzers/KeyboardInputFuzzer.cpp @@ -50,11 +50,10 @@ extern "C" int LLVMFuzzerTestOneInput(uint8_t* data, size_t size) { FuzzInputReaderContext context(eventHub, fdp); InputDevice device = getFuzzedInputDevice(*fdp, &context); - KeyboardInputMapper& mapper = getMapperForDevice< - ThreadSafeFuzzedDataProvider, - KeyboardInputMapper>(*fdp.get(), device, InputReaderConfiguration{}, - /*source=*/fdp->ConsumeIntegral<uint32_t>(), - /*keyboardType=*/fdp->ConsumeIntegral<int32_t>()); + KeyboardInputMapper& mapper = + getMapperForDevice<ThreadSafeFuzzedDataProvider, + KeyboardInputMapper>(*fdp.get(), device, InputReaderConfiguration{}, + /*source=*/fdp->ConsumeIntegral<uint32_t>()); // Loop through mapper operations until randomness is exhausted. while (fdp->remaining_bytes() > 0) { diff --git a/services/inputflinger/tests/fuzzers/MapperHelpers.h b/services/inputflinger/tests/fuzzers/MapperHelpers.h index 25f2f2ec76..ff425ddfb7 100644 --- a/services/inputflinger/tests/fuzzers/MapperHelpers.h +++ b/services/inputflinger/tests/fuzzers/MapperHelpers.h @@ -338,9 +338,11 @@ public: void setLastKeyDownTimestamp(nsecs_t when) { mLastKeyDownTimestamp = when; }; nsecs_t getLastKeyDownTimestamp() { return mLastKeyDownTimestamp; }; + KeyboardClassifier& getKeyboardClassifier() override { return *mClassifier; } private: nsecs_t mLastKeyDownTimestamp; + std::unique_ptr<KeyboardClassifier> mClassifier = std::make_unique<KeyboardClassifier>(); }; template <class Fdp> |