blob: 4adff98930c2806986dcd97043ba634c854e39dd [file]
// Copyright 2024 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
use crate::direct_input::DirectInputManager;
use crate::{
InputDevice, InputDeviceInfo, InputDeviceInfoHandle, InputDeviceStatus, InputFile, uinput,
};
// Add a fuchsia-specific vendor ID. 0xfc1a is currently not allocated
// to any vendor in the USB spec.
//
// May not be zero, see below.
pub(crate) const FUCHSIA_VENDOR_ID: u16 = 0xfc1a;
pub(crate) const FUCHSIA_KEYBOARD_PRODUCT_ID: u16 = 0x1;
pub(crate) const FUCHSIA_TOUCH_PRODUCT_ID: u16 = 0x2;
pub(crate) const FUCHSIA_MOUSE_PRODUCT_ID: u16 = 0x3;
// Touch, keyboard, and mouse input IDs should be distinct.
// Per https://www.linuxjournal.com/article/6429, the bus type should be populated with a
// sensible value, but other fields may not be.
//
// While this may be the case for Linux itself, Android is not so relaxed.
// Devices with apparently-invalid vendor or product IDs don't get extra
// device configuration. So we must make a minimum effort to present
// sensibly-looking product and vendor IDs. Zero version only means that
// version-specific config files will not be applied.
//
// For background, see:
//
// * Allowable file locations:
// https://source.android.com/docs/core/interaction/input/input-device-configuration-files#location
// * Android configuration selection code:
// https://source.corp.google.com/h/googleplex-android/platform/superproject/main/+/main:frameworks/native/libs/input/InputDevice.cpp;l=60;drc=285211e60bff87fc5a9c9b4105a4b4ccb7edffaf
pub const TOUCH_INPUT_ID: uapi::input_id = uapi::input_id {
bustype: uapi::BUS_VIRTUAL as u16,
vendor: FUCHSIA_VENDOR_ID,
product: FUCHSIA_TOUCH_PRODUCT_ID,
version: 0,
};
pub const KEYBOARD_INPUT_ID: uapi::input_id = uapi::input_id {
bustype: uapi::BUS_VIRTUAL as u16,
vendor: FUCHSIA_VENDOR_ID,
product: FUCHSIA_KEYBOARD_PRODUCT_ID,
version: 1,
};
pub const MOUSE_INPUT_ID: uapi::input_id = uapi::input_id {
bustype: uapi::BUS_VIRTUAL as u16,
vendor: FUCHSIA_VENDOR_ID,
product: FUCHSIA_MOUSE_PRODUCT_ID,
version: 1,
};
#[cfg(test)]
use crate::direct_input::{
DISPLAY_PLATFORM_OWNED_SIGNAL, INPUT_CLIENT_OWNED_SIGNAL, INPUT_PLATFORM_OWNED_SIGNAL,
spawn_fake_input_ownership, wait_for_ownership,
};
use fidl::endpoints::{ClientEnd, RequestStream, ServerEnd};
use fidl_fuchsia_ui_input::{self as fuiinput, TouchButton, TouchDeviceInfo};
use fidl_fuchsia_ui_input3::{
KeyEventStatus, KeyboardListenerMarker, KeyboardListenerRequest, KeyboardListenerRequestStream,
KeyboardSynchronousProxy,
};
use fidl_fuchsia_ui_pointer::{
MouseEvent as FidlMouseEvent, TouchEvent as FidlTouchEvent, TouchPointerSample,
{self as fuipointer},
};
use fidl_fuchsia_ui_policy as fuipolicy;
use fidl_fuchsia_ui_views as fuiviews;
#[cfg(test)]
use futures::channel::mpsc::{UnboundedReceiver, UnboundedSender, unbounded};
#[cfg(test)]
use futures::channel::oneshot;
#[cfg(test)]
use futures::channel::oneshot::Sender;
#[cfg(test)]
use futures::executor::block_on;
use futures::{FutureExt as _, StreamExt as _};
use sorted_vec_map::SortedVecMap;
use starnix_core::device::kobject::Device;
use starnix_core::power::{ContainerWakingStream, create_proxy_for_wake_events_counter};
use starnix_core::task::dynamic_thread_spawner::SpawnRequestBuilder;
use starnix_core::task::{CurrentTask, Kernel};
use starnix_logging::{log_debug, log_error, log_warn};
use starnix_modules_input_app_event_conversion::button_fuchsia_to_linux::{
new_touch_buttons_bitvec, parse_fidl_media_button_event, parse_fidl_touch_button_event,
};
use starnix_modules_input_app_event_conversion::key_fuchsia_to_linux::parse_fidl_keyboard_event_to_linux_input_event;
use starnix_modules_input_app_event_conversion::mouse_fuchsia_to_linux::FuchsiaMouseEventToLinuxMouseEventConverter;
use starnix_modules_input_app_event_conversion::touch_fuchsia_to_linux::FuchsiaTouchEventToLinuxTouchEventConverter;
use starnix_sync::{
InputEventRelayOpenedFilesLock, InputRelayDeviceInfosLock, InputRelayDisplaySizeLock,
LockDepMutex,
};
use starnix_types::time::{duration_from_timeval, timeval_from_time};
use starnix_uapi::errors::Errno;
use starnix_uapi::{error, uapi};
use std::collections::{HashSet, VecDeque};
use std::sync::atomic::{AtomicU8, AtomicU64, Ordering};
use std::sync::{Arc, Weak};
const INPUT_RELAY_ROLE_NAME: &str = "fuchsia.starnix.kthread.input_relay";
#[derive(Clone, Copy)]
pub enum EventProxyMode {
/// Don't proxy input events at all.
None,
/// Have the Starnix runner proxy events such that the container
/// will wake up if events are received while the container is
/// suspended.
WakeContainer,
}
pub struct StartRelaysArgs {
pub event_proxy_mode: EventProxyMode,
pub touch_source_client_end: ClientEnd<fuipointer::TouchSourceV2Marker>,
pub keyboard_proxy: KeyboardSynchronousProxy,
pub mouse_source_client_end: ClientEnd<fuipointer::MouseSourceV2Marker>,
pub view_ref: fuiviews::ViewRef,
pub registry_proxy: fuipolicy::DeviceListenerRegistrySynchronousProxy,
pub device_listener_registry: Option<fuiinput::DeviceListenerRegistrySynchronousProxy>,
pub display_width: i32,
pub display_height: i32,
}
const MAX_PRE_OPEN_BUFFERED_EVENTS: usize = 1024;
/// Computes the event timestamp in nanoseconds from the last event in a slice, using
/// `duration_from_timeval` and falling back to saturating arithmetic.
pub fn event_time_ns_from_events(events: &[uapi::input_event]) -> i64 {
events.last().map_or(0, |last| {
duration_from_timeval::<zx::MonotonicTimeline>(last.time)
.map(|d| d.into_nanos())
.unwrap_or_else(|_| {
(last.time.tv_sec as i64)
.saturating_mul(1_000_000_000)
.saturating_add((last.time.tv_usec as i64).saturating_mul(1_000))
})
})
}
#[derive(Default)]
pub struct OpenedFilesState {
files: Vec<Weak<InputFile>>,
has_been_opened: bool,
buffered_events: Vec<uapi::input_event>,
}
impl OpenedFilesState {
pub fn on_file_opened(&mut self, file: &Arc<InputFile>) {
if !self.has_been_opened {
self.has_been_opened = true;
if !self.buffered_events.is_empty() {
let events = std::mem::take(&mut self.buffered_events);
if let Some(inspect) = &file.inspect_status {
let event_time_ns = event_time_ns_from_events(&events);
inspect.count_generated_events(events.len() as u64, event_time_ns);
}
file.add_events(events);
}
}
self.files.push(Arc::downgrade(file));
}
pub fn dispatch_events(&mut self, events: &[uapi::input_event]) -> bool {
if events.is_empty() {
return false;
}
if !self.has_been_opened {
let available_space =
MAX_PRE_OPEN_BUFFERED_EVENTS.saturating_sub(self.buffered_events.len());
if events.len() <= available_space {
self.buffered_events.extend_from_slice(events);
return true;
} else {
log_warn!(
"Dropping {} pre-open input events: buffer capacity exceeded (buffered: {}, limit: {})",
events.len(),
self.buffered_events.len(),
MAX_PRE_OPEN_BUFFERED_EVENTS
);
return false;
}
}
let event_time_ns = event_time_ns_from_events(events);
self.files.retain(|f| {
let Some(file) = f.upgrade() else {
return false;
};
if let Some(inspect) = &file.inspect_status {
inspect.count_generated_events(events.len() as u64, event_time_ns);
}
file.add_events(events.to_vec());
true
});
true
}
}
impl std::ops::Deref for OpenedFilesState {
type Target = Vec<Weak<InputFile>>;
fn deref(&self) -> &Self::Target {
&self.files
}
}
impl std::ops::DerefMut for OpenedFilesState {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.files
}
}
pub type OpenedFiles = Arc<LockDepMutex<OpenedFilesState, InputEventRelayOpenedFilesLock>>;
pub enum InputDeviceType {
Touch(FuchsiaTouchEventToLinuxTouchEventConverter),
Keyboard,
Mouse(FuchsiaMouseEventToLinuxMouseEventConverter),
}
impl std::fmt::Display for InputDeviceType {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
InputDeviceType::Touch(_) => write!(f, "touch"),
InputDeviceType::Keyboard => write!(f, "keyboard"),
InputDeviceType::Mouse(_) => write!(f, "mouse"),
}
}
}
enum DeviceRegistration {
Pending { kernel: Arc<Kernel>, device: crate::InputDevice, device_id: DeviceId },
Registered,
Failed,
}
impl DeviceRegistration {
/// Creates a `Pending` registration for `device`, which will be registered with `kernel`
/// under `device_id` on the first call to `ensure_registered`.
///
/// `device` must not already be registered: `DeviceRegistry::add_device_with_dir` silently
/// overwrites an existing minor device entry, so a double registration would otherwise only
/// surface as a warning log.
fn pending(kernel: Arc<Kernel>, device: crate::InputDevice, device_id: DeviceId) -> Self {
debug_assert!(
{
let devt = starnix_uapi::device_id::DeviceId::new(
starnix_uapi::device_id::INPUT_MAJOR,
device_id,
);
let next_devt = starnix_uapi::device_id::DeviceId::new(
starnix_uapi::device_id::INPUT_MAJOR,
device_id + 1,
);
kernel
.device_registry
.list_minor_devices(starnix_core::device::DeviceMode::Char, devt..next_devt)
.is_empty()
},
"input device {device_id} must not be registered before lazy registration",
);
Self::Pending { kernel, device, device_id }
}
fn ensure_registered(&mut self) {
let Self::Pending { kernel, device, device_id } = self else { return };
match device.clone().register(kernel, *device_id) {
Ok(_) => *self = Self::Registered,
Err(e) => {
log_warn!("unable to register input device {device_id:?}: {e:?}");
// Intentionally abandon registering the mouse device after one failed attempt
// rather than retrying and logging on every subsequent input event.
*self = Self::Failed;
}
}
}
}
struct DeviceState {
device_type: InputDeviceType,
open_files: OpenedFiles,
inspect_status: Option<Arc<InputDeviceStatus>>,
registration: DeviceRegistration,
starnix_device: Option<Device>,
minor: u32,
active_touch_slots: HashSet<i32>,
active_mouse_buttons: HashSet<u16>,
active_keyboard_keys: HashSet<u16>,
}
impl DeviceState {
#[cfg(test)]
fn new_touch(
device_id: DeviceId,
open_files: OpenedFiles,
inspect_status: Option<Arc<InputDeviceStatus>>,
) -> Self {
Self {
device_type: InputDeviceType::Touch(
FuchsiaTouchEventToLinuxTouchEventConverter::create(),
),
open_files,
inspect_status,
registration: DeviceRegistration::Registered,
starnix_device: None,
minor: device_id,
active_touch_slots: HashSet::new(),
active_mouse_buttons: HashSet::new(),
active_keyboard_keys: HashSet::new(),
}
}
#[cfg(test)]
fn new_keyboard(
device_id: DeviceId,
open_files: OpenedFiles,
inspect_status: Option<Arc<InputDeviceStatus>>,
) -> Self {
Self {
device_type: InputDeviceType::Keyboard,
open_files,
inspect_status,
registration: DeviceRegistration::Registered,
starnix_device: None,
minor: device_id,
active_touch_slots: HashSet::new(),
active_mouse_buttons: HashSet::new(),
active_keyboard_keys: HashSet::new(),
}
}
fn new_mouse(
device_id: DeviceId,
open_files: OpenedFiles,
inspect_status: Option<Arc<InputDeviceStatus>>,
) -> Self {
Self {
device_type: InputDeviceType::Mouse(
FuchsiaMouseEventToLinuxMouseEventConverter::create(),
),
open_files,
inspect_status,
registration: DeviceRegistration::Registered,
starnix_device: None,
minor: device_id,
active_touch_slots: HashSet::new(),
active_mouse_buttons: HashSet::new(),
active_keyboard_keys: HashSet::new(),
}
}
fn new_pending_mouse(
kernel: Arc<Kernel>,
device: crate::InputDevice,
device_id: DeviceId,
) -> Self {
Self {
device_type: InputDeviceType::Mouse(
FuchsiaMouseEventToLinuxMouseEventConverter::create(),
),
open_files: device.open_files.clone(),
inspect_status: Some(device.inspect_status.clone()),
registration: DeviceRegistration::pending(kernel, device, device_id),
starnix_device: None,
minor: device_id,
active_touch_slots: HashSet::new(),
active_mouse_buttons: HashSet::new(),
active_keyboard_keys: HashSet::new(),
}
}
}
pub struct TrackedWakeLease {
_lease: fidl::EventPair,
device_status: Arc<InputDeviceStatus>,
}
impl TrackedWakeLease {
pub fn new(lease: fidl::EventPair, device_status: Arc<InputDeviceStatus>) -> Self {
device_status.increment_active_wake_leases(1);
device_status.count_events_with_wake_lease(1);
Self { _lease: lease, device_status }
}
}
impl Drop for TrackedWakeLease {
fn drop(&mut self) {
self.device_status.decrement_active_wake_leases(1);
}
}
pub type DeviceId = u32;
// TODO(https://fxbug.dev/502662433): Default devices are no longer needed because
// existing devices are enumerated via the DeviceIterator before start_relays().
// Remove them in a follow-up change.
pub const DEFAULT_TOUCH_DEVICE_ID: DeviceId = 0;
pub const DEFAULT_KEYBOARD_DEVICE_ID: DeviceId = 1;
pub const DEFAULT_MOUSE_DEVICE_ID: DeviceId = 2;
const DEVICE_LISTENER_NOT_ATTEMPTED: u8 = 0;
const DEVICE_LISTENER_REGISTERED: u8 = 1;
const DEVICE_LISTENER_DISCONNECTED: u8 = 2;
// TODO(https://fxbug.dev/502662433): Migrate `add_touch_device` and `add_keyboard_device`
// in tests to `DeviceListener`, and remove `DeviceStateChange` and this channel.
#[cfg(test)]
enum DeviceStateChange {
Add(DeviceId, Box<DeviceState>, Sender<()>),
}
pub fn new_input_relay() -> (InputEventsRelay, Arc<InputEventsRelayHandle>) {
#[cfg(test)]
let (sender, receiver) = unbounded();
let num_unregistered_device_events = Arc::new(AtomicU64::new(0));
let device_infos = Arc::new(LockDepMutex::new(SortedVecMap::new()));
let display_size = Arc::new(LockDepMutex::new(None));
(
InputEventsRelay {
devices: SortedVecMap::new(),
#[cfg(test)]
receiver: Some(receiver),
num_unregistered_device_events: num_unregistered_device_events.clone(),
num_devices: Arc::new(AtomicU64::new(0)),
device_listener_registered: Arc::new(AtomicU8::new(DEVICE_LISTENER_NOT_ATTEMPTED)),
_inspect_node: None,
device_infos: device_infos.clone(),
display_size: display_size.clone(),
direct_input_manager: None,
},
Arc::new(InputEventsRelayHandle {
#[cfg(test)]
sender,
num_unregistered_device_events,
device_infos,
display_size,
}),
)
}
/// Handle for managing input devices registered with the input event relay.
pub struct InputEventsRelayHandle {
#[cfg(test)]
sender: UnboundedSender<DeviceStateChange>,
num_unregistered_device_events: Arc<AtomicU64>,
pub(crate) device_infos:
Arc<LockDepMutex<SortedVecMap<DeviceId, InputDeviceInfoHandle>, InputRelayDeviceInfosLock>>,
pub(crate) display_size: Arc<LockDepMutex<Option<(i32, i32)>, InputRelayDisplaySizeLock>>,
}
impl InputEventsRelayHandle {
/// Returns the number of events received for unregistered devices across all input streams.
pub fn num_unregistered_device_events(&self) -> u64 {
self.num_unregistered_device_events.load(Ordering::Relaxed)
}
/// Updates or inserts metadata (such as device name and input ID) for a uinput device.
pub(crate) fn update_uinput_device(
&self,
device_id: DeviceId,
input_id: uapi::input_id,
name: String,
) {
let mut device_infos = self.device_infos.lock();
if let Some(info) = device_infos.get(&device_id) {
*info.lock() = InputDeviceInfo { input_id, name };
} else {
device_infos.insert(device_id, InputDeviceInfo::new(input_id, name));
}
}
/// Adds a touch device to the relay.
///
/// # Precondition / Lifecycle
/// Only call after [`InputEventsRelay::start_relays`].
#[cfg(test)]
pub fn add_touch_device(
&self,
device_id: DeviceId,
open_files: OpenedFiles,
inspect_status: Option<Arc<InputDeviceStatus>>,
) {
let (sender, receiver) = oneshot::channel();
let _ = self.sender.unbounded_send(DeviceStateChange::Add(
device_id,
Box::new(DeviceState::new_touch(device_id, open_files, inspect_status)),
sender,
));
let _ = block_on(receiver);
}
/// Adds a keyboard device to the relay.
///
/// # Precondition / Lifecycle
/// Only call after [`InputEventsRelay::start_relays`].
#[cfg(test)]
pub fn add_keyboard_device(
&self,
device_id: DeviceId,
open_files: OpenedFiles,
inspect_status: Option<Arc<InputDeviceStatus>>,
) {
let (sender, receiver) = oneshot::channel();
let _ = self.sender.unbounded_send(DeviceStateChange::Add(
device_id,
Box::new(DeviceState::new_keyboard(device_id, open_files, inspect_status)),
sender,
));
let _ = block_on(receiver);
}
}
pub struct InputEventsRelay {
devices: SortedVecMap<DeviceId, DeviceState>,
#[cfg(test)]
receiver: Option<UnboundedReceiver<DeviceStateChange>>,
num_unregistered_device_events: Arc<AtomicU64>,
/// Number of devices currently tracked by the relay, exposed via inspect.
num_devices: Arc<AtomicU64>,
device_listener_registered: Arc<AtomicU8>,
_inspect_node: Option<fuchsia_inspect::Node>,
device_infos:
Arc<LockDepMutex<SortedVecMap<DeviceId, InputDeviceInfoHandle>, InputRelayDeviceInfosLock>>,
display_size: Arc<LockDepMutex<Option<(i32, i32)>, InputRelayDisplaySizeLock>>,
direct_input_manager: Option<Arc<DirectInputManager>>,
}
impl InputEventsRelay {
/// Builder pattern setting `DirectInputManager`.
pub fn with_direct_input_manager(mut self, manager: Arc<DirectInputManager>) -> Self {
self.direct_input_manager = Some(manager);
self
}
/// Flushes release events for any currently active touches, mouse buttons, or pressed media/touch
/// buttons across all devices when ownership transitions to direct driver input.
fn flush_all_releases(
&mut self,
power_was_pressed: &mut bool,
function_was_pressed: &mut bool,
volume_up_was_pressed: &mut bool,
volume_down_was_pressed: &mut bool,
touch_buttons_were_pressed: &mut bit_vec::BitVec,
) {
let time = timeval_from_time(zx::MonotonicInstant::get());
let sync_event = uapi::input_event {
time,
type_: uapi::EV_SYN as u16,
code: uapi::SYN_REPORT as u16,
value: 0,
};
// 1. Flush releases for touch and mouse devices
for dev in self.devices.values_mut() {
match dev.device_type {
InputDeviceType::Touch(_) => {
let mut events = Vec::new();
if !dev.active_touch_slots.is_empty() {
for slot in dev.active_touch_slots.drain() {
events.push(uapi::input_event {
time,
type_: uapi::EV_ABS as u16,
code: uapi::ABS_MT_SLOT as u16,
value: slot,
});
events.push(uapi::input_event {
time,
type_: uapi::EV_ABS as u16,
code: uapi::ABS_MT_TRACKING_ID as u16,
value: -1,
});
}
events.push(uapi::input_event {
time,
type_: uapi::EV_KEY as u16,
code: uapi::BTN_TOUCH as u16,
value: 0,
});
events.push(sync_event);
}
// Reset touch converter state so subsequent touches start fresh.
dev.device_type = InputDeviceType::Touch(
FuchsiaTouchEventToLinuxTouchEventConverter::create(),
);
if !events.is_empty() {
dev.open_files.lock().retain(|f| {
if let Some(file) = f.upgrade() {
file.add_events(events.clone());
true
} else {
false
}
});
}
}
InputDeviceType::Mouse(_) => {
let mut events = Vec::new();
if !dev.active_mouse_buttons.is_empty() {
for code in dev.active_mouse_buttons.drain() {
events.push(uapi::input_event {
time,
type_: uapi::EV_KEY as u16,
code,
value: 0,
});
}
events.push(sync_event);
}
// Reset mouse converter state so subsequent clicks start fresh.
dev.device_type = InputDeviceType::Mouse(
FuchsiaMouseEventToLinuxMouseEventConverter::create(),
);
if !events.is_empty() {
dev.open_files.lock().retain(|f| {
if let Some(file) = f.upgrade() {
file.add_events(events.clone());
true
} else {
false
}
});
}
}
InputDeviceType::Keyboard => {
let mut events = Vec::new();
if !dev.active_keyboard_keys.is_empty() {
for code in dev.active_keyboard_keys.drain() {
events.push(uapi::input_event {
time,
type_: uapi::EV_KEY as u16,
code,
value: 0,
});
}
events.push(sync_event);
}
if !events.is_empty() {
dev.open_files.lock().retain(|f| {
if let Some(file) = f.upgrade() {
file.add_events(events.clone());
true
} else {
false
}
});
}
}
}
}
// 2. Flush media buttons if pressed
let mut key_events = Vec::new();
if *power_was_pressed {
key_events.push(uapi::input_event {
time,
type_: uapi::EV_KEY as u16,
code: uapi::KEY_POWER as u16,
value: 0,
});
*power_was_pressed = false;
}
if *function_was_pressed {
key_events.push(uapi::input_event {
time,
type_: uapi::EV_KEY as u16,
code: uapi::KEY_VOLUMEDOWN as u16,
value: 0,
});
*function_was_pressed = false;
}
if *volume_up_was_pressed {
key_events.push(uapi::input_event {
time,
type_: uapi::EV_KEY as u16,
code: uapi::KEY_VOLUMEUP as u16,
value: 0,
});
*volume_up_was_pressed = false;
}
if *volume_down_was_pressed {
key_events.push(uapi::input_event {
time,
type_: uapi::EV_KEY as u16,
code: uapi::KEY_VOLUMEDOWN as u16,
value: 0,
});
*volume_down_was_pressed = false;
}
if !key_events.is_empty() {
key_events.push(sync_event);
if let Some(dev) = self.get_device_mut(None, DEFAULT_KEYBOARD_DEVICE_ID, |t| {
matches!(t, InputDeviceType::Keyboard)
}) {
dev.open_files.lock().retain(|f| {
if let Some(file) = f.upgrade() {
file.add_events(key_events.clone());
true
} else {
false
}
});
}
}
// 3. Flush touch buttons if pressed
let mut touch_btn_events = Vec::new();
for (index, key_code) in [
(TouchButton::Palm.into_primitive() as usize, uapi::KEY_SLEEP),
(TouchButton::SwipeUp.into_primitive() as usize, uapi::KEY_UP),
(TouchButton::SwipeLeft.into_primitive() as usize, uapi::KEY_LEFT),
(TouchButton::SwipeRight.into_primitive() as usize, uapi::KEY_RIGHT),
(TouchButton::SwipeDown.into_primitive() as usize, uapi::KEY_DOWN),
] {
if touch_buttons_were_pressed.get(index).unwrap_or(false) {
touch_btn_events.push(uapi::input_event {
time,
type_: uapi::EV_KEY as u16,
code: key_code as u16,
value: 0,
});
}
}
if !touch_btn_events.is_empty() {
touch_btn_events.push(sync_event);
if let Some(dev) = self.get_device_mut(None, DEFAULT_TOUCH_DEVICE_ID, |t| {
matches!(t, InputDeviceType::Touch(_))
}) {
dev.open_files.lock().retain(|f| {
if let Some(file) = f.upgrade() {
file.add_events(touch_btn_events.clone());
true
} else {
false
}
});
}
}
*touch_buttons_were_pressed = new_touch_buttons_bitvec();
}
/// Updates the inspect-visible device count. Must be called after every mutation of
/// `self.devices` once the relay has started.
fn update_num_devices(&self) {
self.num_devices.store(self.devices.len() as u64, Ordering::Relaxed);
}
/// Adds a touch device to the relay prior to starting the relay loop.
#[cfg(test)]
pub fn add_touch_device(
&mut self,
device_id: DeviceId,
open_files: OpenedFiles,
inspect_status: Option<Arc<InputDeviceStatus>>,
) {
self.devices
.insert(device_id, DeviceState::new_touch(device_id, open_files, inspect_status));
self.update_num_devices();
}
/// Adds a keyboard device to the relay prior to starting the relay loop.
#[cfg(test)]
pub fn add_keyboard_device(
&mut self,
device_id: DeviceId,
open_files: OpenedFiles,
inspect_status: Option<Arc<InputDeviceStatus>>,
) {
self.devices
.insert(device_id, DeviceState::new_keyboard(device_id, open_files, inspect_status));
self.update_num_devices();
}
/// Adds a mouse device to the relay prior to starting the relay loop.
pub fn add_mouse_device(
&mut self,
device_id: DeviceId,
open_files: OpenedFiles,
inspect_status: Option<Arc<InputDeviceStatus>>,
) {
self.devices
.insert(device_id, DeviceState::new_mouse(device_id, open_files, inspect_status));
self.update_num_devices();
}
/// Adds a pending mouse device to the relay prior to starting the relay loop.
pub fn add_pending_mouse_device(
&mut self,
kernel: Arc<Kernel>,
device: crate::InputDevice,
device_id: DeviceId,
) {
self.devices.insert(device_id, DeviceState::new_pending_mouse(kernel, device, device_id));
self.update_num_devices();
}
fn record_inspect(&mut self, parent: &fuchsia_inspect::Node) {
let inspect_node = parent.create_child("input_events_relay");
let unregistered_counter = self.num_unregistered_device_events.clone();
let num_devices = self.num_devices.clone();
let device_listener_registered = self.device_listener_registered.clone();
// `record_lazy_values` records an inline lazy node (LinkNodeDisposition::Inline),
// exposing properties directly on `inspect_node` (input_events_relay).
inspect_node.record_lazy_values("status", move || {
let count = unregistered_counter.load(Ordering::Relaxed);
let num_devices = num_devices.load(Ordering::Relaxed);
let registration_state = device_listener_registered.load(Ordering::Relaxed);
async move {
let inspector = fuchsia_inspect::Inspector::default();
inspector.root().record_uint("num_unregistered_device_events", count);
inspector.root().record_uint("num_devices", num_devices);
match registration_state {
DEVICE_LISTENER_REGISTERED => {
inspector.root().record_bool("device_listener_registered", true);
}
DEVICE_LISTENER_DISCONNECTED => {
inspector.root().record_bool("device_listener_registered", false);
}
_ => {}
}
Ok(inspector)
}
.boxed()
});
self._inspect_node = Some(inspect_node);
}
#[cfg(test)]
pub fn with_inspect_node(mut self, parent: &fuchsia_inspect::Node) -> Self {
self.record_inspect(parent);
self
}
// TODO(https://fxbug.dev/371602479): Use `fuchsia.ui.SupportedInputDevices` to create
// relays.
// start_relays will take over the ownership of InputEventsRelay.
pub fn start_relays(mut self: Self, kernel: &Kernel, args: StartRelaysArgs) {
if self._inspect_node.is_none() {
self.record_inspect(&kernel.inspect_node);
}
self.update_num_devices();
let display_width = args.display_width;
let display_height = args.display_height;
let event_proxy_mode = args.event_proxy_mode;
let direct_input_manager = self.direct_input_manager.take();
#[cfg(test)]
let mut receiver = self.receiver.take().expect("start_relays called once");
*self.display_size.lock() = if display_width > 0 && display_height > 0 {
Some((display_width, display_height))
} else {
None
};
let f = async move |current_task: &CurrentTask| {
let kernel = current_task.kernel();
// touch
let (touch_source_proxy, mut touch_waking_stream) =
setup_touch_relay(kernel, event_proxy_mode, args.touch_source_client_end);
// mouse
let (mouse_source_proxy, mut mouse_waking_stream) =
setup_mouse_relay(kernel, event_proxy_mode, args.mouse_source_client_end);
// keyboard
// `_keyboard_proxy` is load-bearing despite being unused: it holds the channel to
// text_manager open for the lifetime of the relay loop below. Dropping it closes
// the channel, which deregisters our `KeyboardListener` and silently stops all
// key delivery. Do not remove it as an unused binding.
let (mut keyboard_event_stream, _keyboard_proxy) =
setup_keyboard_relay(args.keyboard_proxy, args.view_ref);
// button
let (mut media_buttons_waking_stream, mut touch_buttons_waking_stream) =
setup_button_relay(kernel, args.registry_proxy, event_proxy_mode);
let (mut device_listener_stream, existing_devices_iterator) =
if let Some(registry) = args.device_listener_registry {
let (client_end, server_end) =
fidl::endpoints::create_endpoints::<fuiinput::DeviceListenerMarker>();
let stream = setup_device_listener_relay(kernel, server_end, event_proxy_mode);
match registry.register_listener(client_end, zx::MonotonicInstant::INFINITE) {
Ok(iterator) => {
self.device_listener_registered
.store(DEVICE_LISTENER_REGISTERED, Ordering::Relaxed);
(Some(stream), Some(iterator))
}
Err(e) => {
log_error!("Failed to register device listener: {:?}", e);
self.device_listener_registered
.store(DEVICE_LISTENER_DISCONNECTED, Ordering::Relaxed);
drop(stream);
(None, None)
}
}
} else {
self.device_listener_registered
.store(DEVICE_LISTENER_DISCONNECTED, Ordering::Relaxed);
(None, None)
};
if let Some(iterator) = existing_devices_iterator {
let iterator_proxy = iterator.into_proxy();
loop {
match iterator_proxy.get_next().await {
Ok(devices) => {
if devices.is_empty() {
log_debug!("Finished getting existing devices (empty batch)");
break;
}
for device in devices {
match device.action {
Some(fuiinput::Action::Added) => {
let (Some(device_id), Some(descriptor)) =
(device.device_id, device.descriptor)
else {
log_warn!(
"DeviceEvent in existing devices iterator missing device_id or descriptor"
);
continue;
};
if let Err(e) = register_and_add_device(
current_task,
&mut self,
device_id,
descriptor,
display_width,
display_height,
) {
log_warn!(
"Failed to register existing device {}: {:?}",
device_id,
e
);
}
}
other => {
log_warn!(
"Unexpected action in existing devices iterator: {:?}",
other
);
}
}
}
}
Err(e) => {
log_warn!("Error getting existing devices: {:?}", e);
break;
}
}
}
}
let mut touch_future = touch_waking_stream.next().fuse();
let mut mouse_future = mouse_waking_stream.next().fuse();
let mut keyboard_future = keyboard_event_stream.next().fuse();
let mut media_buttons_future = media_buttons_waking_stream.next().fuse();
let mut touch_buttons_future = touch_buttons_waking_stream.next().fuse();
#[cfg(test)]
let mut receiver_future = receiver.next().fuse();
#[cfg(not(test))]
let mut receiver_future =
futures::future::Fuse::<futures::future::Pending<()>>::terminated();
let mut device_listener_future = futures::future::OptionFuture::from(
device_listener_stream.as_mut().map(|s| s.next()),
);
let mut power_was_pressed = false;
let mut function_was_pressed = false;
let mut volume_up_was_pressed = false;
let mut volume_down_was_pressed = false;
let mut touch_buttons_were_pressed = new_touch_buttons_bitvec();
let mut prev_direct_active = false;
let is_direct_active = |m: &Option<Arc<DirectInputManager>>| -> bool {
m.as_ref().is_some_and(|m| m.is_ownership_active())
};
let get_resume_gen = |m: &Option<Arc<DirectInputManager>>| -> u64 {
m.as_ref().map_or(0, |m| m.resume_generation())
};
let mut prev_resume_gen = get_resume_gen(&direct_input_manager);
loop {
futures::select! {
touch_res = touch_future => {
match touch_res {
Some(Ok(fuipointer::TouchSourceV2Event::OnTouchEvents {
events,
last_event_stamp,
})) => {
let direct_active = is_direct_active(&direct_input_manager);
let current_resume_gen = get_resume_gen(&direct_input_manager);
if current_resume_gen != prev_resume_gen {
self.flush_all_releases(
&mut power_was_pressed,
&mut function_was_pressed,
&mut volume_up_was_pressed,
&mut volume_down_was_pressed,
&mut touch_buttons_were_pressed,
);
}
if !prev_direct_active && direct_active {
// TODO(https://fxbug.dev/533426336): Inject cancel/release events when transitioning
// ownership between relay and direct input to prevent stuck pointers or stale media-button state mid-gesture.
self.flush_all_releases(
&mut power_was_pressed,
&mut function_was_pressed,
&mut volume_up_was_pressed,
&mut volume_down_was_pressed,
&mut touch_buttons_were_pressed,
);
}
prev_direct_active = direct_active;
prev_resume_gen = current_resume_gen;
if !direct_active {
self.process_touch_event(
events,
);
}
if let Err(e) = touch_source_proxy.acknowledge_events(last_event_stamp) {
log_warn!("error acknowledging touch events: {:?}", e);
}
drop(touch_future);
touch_future = touch_waking_stream.next().fuse();
}
Some(Ok(fuipointer::TouchSourceV2Event::_UnknownEvent { ordinal, .. })) => {
log_warn!("unknown event on TouchSourceV2: {}", ordinal);
drop(touch_future);
touch_future = touch_waking_stream.next().fuse();
}
Some(Err(e)) => {
log_warn!(
"error {:?} reading from TouchSourceV2Proxy; input is stopped",
e
);
touch_future = futures::future::Fuse::terminated();
}
None => {
touch_future = futures::future::Fuse::terminated();
}
}
}
mouse_res = mouse_future => {
match mouse_res {
Some(Ok(fuipointer::MouseSourceV2Event::OnMouseEvents {
events,
last_event_stamp,
})) => {
let direct_active = is_direct_active(&direct_input_manager);
let current_resume_gen = get_resume_gen(&direct_input_manager);
if (!prev_direct_active && direct_active)
|| current_resume_gen != prev_resume_gen
{
self.flush_all_releases(
&mut power_was_pressed,
&mut function_was_pressed,
&mut volume_up_was_pressed,
&mut volume_down_was_pressed,
&mut touch_buttons_were_pressed,
);
}
prev_direct_active = direct_active;
prev_resume_gen = current_resume_gen;
if !direct_active {
self.process_mouse_event(events);
}
if let Err(e) = mouse_source_proxy.acknowledge_events(last_event_stamp) {
log_warn!("error acknowledging mouse events: {:?}", e);
}
drop(mouse_future);
mouse_future = mouse_waking_stream.next().fuse();
}
Some(Ok(fuipointer::MouseSourceV2Event::_UnknownEvent { ordinal, .. })) => {
log_warn!("unknown event on MouseSourceV2: {}", ordinal);
drop(mouse_future);
mouse_future = mouse_waking_stream.next().fuse();
}
Some(Err(e)) => {
log_warn!(
"error {:?} reading from MouseSourceV2Proxy; input is stopped",
e
);
mouse_future = futures::future::Fuse::terminated();
}
None => {
mouse_future = futures::future::Fuse::terminated();
}
}
}
media_buttons_res = media_buttons_future => {
match media_buttons_res {
Some(Ok(event)) => {
let direct_active = is_direct_active(&direct_input_manager);
let current_resume_gen = get_resume_gen(&direct_input_manager);
if (!prev_direct_active && direct_active)
|| current_resume_gen != prev_resume_gen
{
self.flush_all_releases(
&mut power_was_pressed,
&mut function_was_pressed,
&mut volume_up_was_pressed,
&mut volume_down_was_pressed,
&mut touch_buttons_were_pressed,
);
}
prev_direct_active = direct_active;
prev_resume_gen = current_resume_gen;
if direct_active {
match event {
fuipolicy::MediaButtonsListenerRequest::OnEvent {
responder,
..
} => {
let _ = responder.send();
}
_ => {}
}
} else {
(
power_was_pressed,
function_was_pressed,
volume_up_was_pressed,
volume_down_was_pressed,
) = self.process_media_button_event(
event,
power_was_pressed,
function_was_pressed,
volume_up_was_pressed,
volume_down_was_pressed,
);
}
drop(media_buttons_future);
media_buttons_future = media_buttons_waking_stream.next().fuse();
}
_ => {
media_buttons_future = futures::future::Fuse::terminated();
}
}
}
touch_buttons_res = touch_buttons_future => {
match touch_buttons_res {
Some(Ok(event)) => {
let direct_active = is_direct_active(&direct_input_manager);
let current_resume_gen = get_resume_gen(&direct_input_manager);
if (!prev_direct_active && direct_active)
|| current_resume_gen != prev_resume_gen
{
self.flush_all_releases(
&mut power_was_pressed,
&mut function_was_pressed,
&mut volume_up_was_pressed,
&mut volume_down_was_pressed,
&mut touch_buttons_were_pressed,
);
}
prev_direct_active = direct_active;
prev_resume_gen = current_resume_gen;
if direct_active {
match event {
fuipolicy::TouchButtonsListenerRequest::OnEvent {
responder,
..
} => {
let _ = responder.send();
}
_ => {}
}
} else {
touch_buttons_were_pressed = self.process_touch_button_event(
event,
&touch_buttons_were_pressed,
);
}
drop(touch_buttons_future);
touch_buttons_future = touch_buttons_waking_stream.next().fuse();
}
_ => {
touch_buttons_future = futures::future::Fuse::terminated();
}
}
}
device_listener_res = device_listener_future => {
match device_listener_res {
Some(Some(Ok(request))) => {
self.process_device_listener_request(
current_task,
request,
display_width,
display_height,
);
device_listener_future = futures::future::OptionFuture::from(
device_listener_stream.as_mut().map(|s| s.next()),
);
}
Some(Some(Err(e))) => {
log_warn!("DeviceListener stream error: {:?}", e);
self.device_listener_registered
.store(DEVICE_LISTENER_DISCONNECTED, Ordering::Relaxed);
device_listener_stream = None;
device_listener_future = futures::future::OptionFuture::from(None);
}
Some(None) => {
log_warn!("DeviceListener stream closed by peer");
self.device_listener_registered
.store(DEVICE_LISTENER_DISCONNECTED, Ordering::Relaxed);
device_listener_stream = None;
device_listener_future = futures::future::OptionFuture::from(None);
}
None => {
self.device_listener_registered
.store(DEVICE_LISTENER_DISCONNECTED, Ordering::Relaxed);
device_listener_stream = None;
device_listener_future = futures::future::OptionFuture::from(None);
}
}
}
keyboard_res = keyboard_future => {
match keyboard_res {
Some(Ok(request)) => {
let direct_active = is_direct_active(&direct_input_manager);
let current_resume_gen = get_resume_gen(&direct_input_manager);
if (!prev_direct_active && direct_active)
|| current_resume_gen != prev_resume_gen
{
self.flush_all_releases(
&mut power_was_pressed,
&mut function_was_pressed,
&mut volume_up_was_pressed,
&mut volume_down_was_pressed,
&mut touch_buttons_were_pressed,
);
}
prev_direct_active = direct_active;
prev_resume_gen = current_resume_gen;
if direct_active {
match request {
KeyboardListenerRequest::OnKeyEvent { responder, .. } => {
let _ = responder.send(KeyEventStatus::NotHandled);
}
}
} else {
self.process_keyboard(request);
}
drop(keyboard_future);
keyboard_future = keyboard_event_stream.next().fuse();
}
_ => {
keyboard_future = futures::future::Fuse::terminated();
}
}
}
e = receiver_future => {
#[cfg(test)]
match e {
Some(event) => {
match event {
DeviceStateChange::Add(id, device_state, sender) => {
self.devices.insert(id, *device_state);
self.update_num_devices();
let _ = sender.send(());
}
}
drop(receiver_future);
receiver_future = receiver.next().fuse();
}
None => {
receiver_future = futures::future::Fuse::terminated();
}
}
#[cfg(not(test))]
let _ = e;
}
complete => break,
}
}
};
let req = SpawnRequestBuilder::new()
.with_debug_name("input-event-relay")
.with_role(INPUT_RELAY_ROLE_NAME)
.with_async_closure(f)
.build();
kernel.kthreads.spawner().spawn_from_request(req);
}
fn get_device_mut(
&mut self,
device_id: Option<DeviceId>,
default_id: DeviceId,
predicate: impl Fn(&InputDeviceType) -> bool,
) -> Option<&mut DeviceState> {
let target_device_id = device_id
.filter(|id| self.devices.get(id).is_some_and(|d| predicate(&d.device_type)))
.unwrap_or(default_id);
self.devices.get_mut(&target_device_id).filter(|d| predicate(&d.device_type))
}
fn process_touch_event(self: &mut Self, touch_events: Vec<FidlTouchEvent>) {
fuchsia_trace::duration!("input", "starnix_process_touch_event");
for e in &touch_events {
match e.trace_flow_id {
Some(trace_flow_id) => {
fuchsia_trace::flow_end!(
"input",
"dispatch_event_to_client",
trace_flow_id.into()
);
}
None => {
log_warn!("touch event has no tracing id");
}
}
}
let num_received_events: u64 = touch_events.len().try_into().unwrap();
let mut num_ignored_events: u64 = 0;
// 1 vec may contains events from different device.
let (events_by_device, ignored_events) = group_touch_events_by_device_id(touch_events);
num_ignored_events += ignored_events;
for (device_id, mut events) in events_by_device {
fuchsia_trace::duration_begin!("input", "starnix_process_per_device_touch_event");
// TODO(https://fxbug.dev/502662433): Default devices are no longer needed because
// existing devices are enumerated via the DeviceIterator before start_relays().
// Remove them in a follow-up change.
let Some(dev) = self.get_device_mut(Some(device_id), DEFAULT_TOUCH_DEVICE_ID, |t| {
matches!(t, InputDeviceType::Touch(_))
}) else {
fuchsia_trace::duration_end!("input", "starnix_process_per_device_touch_event");
log_warn!(
"Received touch event for unregistered device {} and default touch device is missing",
device_id
);
self.num_unregistered_device_events
.fetch_add(events.len() as u64, Ordering::Relaxed);
continue;
};
let mut num_converted_events: u64 = 0;
let mut num_unexpected_events: u64 = 0;
let mut new_events: VecDeque<uapi::input_event> = VecDeque::new();
#[allow(clippy::collection_is_never_read)]
let mut tracked_leases = vec![];
for event in &mut events {
if let Some(lease) = event.wake_lease.take() {
if let Some(status) = &dev.inspect_status {
tracked_leases.push(TrackedWakeLease::new(lease, status.clone()));
}
}
}
let InputDeviceType::Touch(ref mut converter) = dev.device_type else { unreachable!() };
let mut batch = converter.handle(events);
new_events.append(&mut batch.events);
num_converted_events += batch.count_converted_fidl_events;
num_ignored_events += batch.count_ignored_fidl_events;
num_unexpected_events += batch.count_unexpected_fidl_events;
let last_event_time_ns = batch.last_event_time_ns;
let mut current_slot = 0i32;
for ev in &new_events {
if ev.type_ == uapi::EV_ABS as u16 && ev.code == uapi::ABS_MT_SLOT as u16 {
current_slot = ev.value;
} else if ev.type_ == uapi::EV_ABS as u16
&& ev.code == uapi::ABS_MT_TRACKING_ID as u16
{
if ev.value < 0 {
dev.active_touch_slots.remove(&current_slot);
} else {
dev.active_touch_slots.insert(current_slot);
}
}
}
if let Some(dev_inspect_status) = &dev.inspect_status {
dev_inspect_status.count_total_received_events(num_received_events);
dev_inspect_status.count_total_ignored_events(num_ignored_events);
dev_inspect_status.count_total_unexpected_events(num_unexpected_events);
dev_inspect_status.count_total_converted_events(num_converted_events);
dev_inspect_status.count_total_generated_events(
new_events.len().try_into().unwrap(),
last_event_time_ns,
);
} else {
log_warn!(
"unable to record inspect for device_id: {}, device_type: {}",
device_id,
dev.device_type
);
}
fuchsia_trace::duration_end!("input", "starnix_process_per_device_touch_event");
dev.open_files.lock().retain(|f| {
let Some(file) = f.upgrade() else {
log_warn!("Dropping input file for touch that failed to upgrade");
return false;
};
match &file.inspect_status {
Some(file_inspect_status) => {
file_inspect_status.count_received_events(num_received_events);
file_inspect_status.count_ignored_events(num_ignored_events);
file_inspect_status.count_unexpected_events(num_unexpected_events);
file_inspect_status.count_converted_events(num_converted_events);
}
None => {
log_warn!("unable to record inspect within the input file")
}
}
if !new_events.is_empty() {
// TODO(https://fxbug.dev/42075438): Reading from an `InputFile` should
// not provide access to events that occurred before the file was
// opened.
if let Some(file_inspect_status) = &file.inspect_status {
file_inspect_status.count_generated_events(
new_events.len().try_into().unwrap(),
last_event_time_ns,
);
}
file.add_events(new_events.clone().into_iter().collect());
}
true
});
}
}
fn process_keyboard(self: &mut Self, request: KeyboardListenerRequest) {
match request {
KeyboardListenerRequest::OnKeyEvent { event, responder } => {
fuchsia_trace::duration!("input", "starnix_process_keyboard_event");
let Some(dev) =
self.get_device_mut(event.device_id, DEFAULT_KEYBOARD_DEVICE_ID, |t| {
matches!(t, InputDeviceType::Keyboard)
})
else {
log_warn!(
"Received key event for device {:?} but neither it nor default keyboard device is registered",
event.device_id
);
self.num_unregistered_device_events.fetch_add(1, Ordering::Relaxed);
let _ = responder.send(KeyEventStatus::NotHandled);
return;
};
let new_events = parse_fidl_keyboard_event_to_linux_input_event(
&event,
uinput::uinput_running(),
);
// These counters are denominated in FIDL events, not uapi events: the
// documented invariant is received = ignored + unexpected + converted (see
// `InputDeviceStatus`). One FIDL key event converts to several uapi events
// (the key itself plus a SYN), so only the *generated* counters take
// `new_events.len()`.
let (converted_events, ignored_events, generated_events) = match new_events.len() {
0 => (0u64, 1u64, 0u64),
len => (1u64, 0u64, len as u64),
};
let last_time = event.timestamp.unwrap_or(0);
if let Some(dev_inspect_status) = &dev.inspect_status {
dev_inspect_status.count_total_received_events(1);
dev_inspect_status.count_total_ignored_events(ignored_events);
dev_inspect_status.count_total_converted_events(converted_events);
// Guarded because `count_total_generated_events` *stores* the timestamp:
// calling it with a count of 0 would move
// `last_generated_uapi_event_timestamp_ns` on an event that generated
// nothing.
if generated_events > 0 {
dev_inspect_status
.count_total_generated_events(generated_events, last_time);
}
} else {
log_warn!("unable to record inspect for keyboard device");
}
for ev in &new_events {
if ev.type_ == uapi::EV_KEY as u16 {
if ev.value == 0 {
dev.active_keyboard_keys.remove(&ev.code);
} else if ev.value == 1 {
dev.active_keyboard_keys.insert(ev.code);
}
}
}
dev.open_files.lock().retain(|f| {
let Some(file) = f.upgrade() else {
log_warn!("Dropping input file for keyboard that failed to upgrade");
return false;
};
match &file.inspect_status {
Some(file_inspect_status) => {
file_inspect_status.count_received_events(1);
file_inspect_status.count_ignored_events(ignored_events);
file_inspect_status.count_converted_events(converted_events);
if generated_events > 0 {
file_inspect_status
.count_generated_events(generated_events, last_time);
}
}
None => {
log_warn!("unable to record inspect within the input file")
}
}
if !new_events.is_empty() {
file.add_events(new_events.clone().into_iter().collect());
}
true
});
let _ = responder.send(KeyEventStatus::Handled);
}
}
}
fn process_device_listener_request(
&mut self,
current_task: &CurrentTask,
request: fuiinput::DeviceListenerRequest,
display_width: i32,
display_height: i32,
) {
match request {
fuiinput::DeviceListenerRequest::OnDeviceChanged { event, control_handle: _ } => {
let action = match event.action {
Some(fuiinput::Action::Added) => "add",
Some(fuiinput::Action::Removed) => "remove",
_ => "unknown",
};
fuchsia_trace::duration!(
"input",
"starnix_process_device_changed",
"action" => action
);
match event.action {
Some(fuiinput::Action::Added) => {
let (Some(device_id), Some(descriptor)) =
(event.device_id, event.descriptor)
else {
log_warn!("DeviceEvent missing device_id or descriptor");
return;
};
if let Err(e) = register_and_add_device(
current_task,
self,
device_id,
descriptor,
display_width,
display_height,
) {
log_warn!("Failed to register dynamic device {}: {:?}", device_id, e);
}
}
Some(fuiinput::Action::Removed) => {
let Some(device_id) = event.device_id else {
log_warn!("DeviceEvent missing device_id");
return;
};
self.device_infos.lock().remove(&device_id);
if let Some(device_state) = self.devices.remove(&device_id) {
self.update_num_devices();
if let Some(starnix_device) = device_state.starnix_device {
InputDevice::unregister(current_task, starnix_device);
}
}
}
action => {
log_warn!("Unexpected action in DeviceListener event: {:?}", action);
}
}
}
}
}
fn process_media_button_event(
&mut self,
button_event: fuipolicy::MediaButtonsListenerRequest,
power_was_pressed: bool,
function_was_pressed: bool,
volume_up_was_pressed: bool,
volume_down_was_pressed: bool,
) -> (bool, bool, bool, bool) {
let mut power_was_pressed_after = power_was_pressed;
let mut function_was_pressed_after = function_was_pressed;
let mut volume_up_was_pressed_after = volume_up_was_pressed;
let mut volume_down_was_pressed_after = volume_down_was_pressed;
match button_event {
fuipolicy::MediaButtonsListenerRequest::OnEvent { mut event, responder } => {
if let Some(trace_flow_id) = event.trace_flow_id {
fuchsia_trace::flow_end!(
"input",
"dispatch_media_buttons_to_listeners",
trace_flow_id.into()
);
}
fuchsia_trace::duration!("input", "starnix_process_media_button_event");
let Some(dev) =
self.get_device_mut(event.device_id, DEFAULT_KEYBOARD_DEVICE_ID, |t| {
matches!(t, InputDeviceType::Keyboard)
})
else {
log_warn!(
"Received media button event for device {:?} but neither it nor default keyboard device is registered",
event.device_id
);
self.num_unregistered_device_events.fetch_add(1, Ordering::Relaxed);
let _ = responder.send();
return (
power_was_pressed,
function_was_pressed,
volume_up_was_pressed,
volume_down_was_pressed,
);
};
let batch = parse_fidl_media_button_event(
&event,
power_was_pressed,
function_was_pressed,
volume_up_was_pressed,
volume_down_was_pressed,
);
power_was_pressed_after = batch.power_is_pressed;
function_was_pressed_after = batch.function_is_pressed;
volume_up_was_pressed_after = batch.volume_up_is_pressed;
volume_down_was_pressed_after = batch.volume_down_is_pressed;
let (converted_events, ignored_events, generated_events) = match batch.events.len()
{
0 => (0u64, 1u64, 0u64),
len => {
if len % 2 == 1 {
log_warn!(
"unexpectedly received {} events: there should always be an even number of non-empty events.",
len
);
}
(1u64, 0u64, len as u64)
}
};
#[allow(clippy::collection_is_never_read)]
let mut tracked_leases = vec![];
if let Some(lease) = event.wake_lease.take() {
if let Some(status) = &dev.inspect_status {
tracked_leases.push(TrackedWakeLease::new(lease, status.clone()));
}
}
if let Some(dev_inspect_status) = &dev.inspect_status {
dev_inspect_status.count_total_received_events(1);
dev_inspect_status.count_total_ignored_events(ignored_events);
dev_inspect_status.count_total_converted_events(converted_events);
dev_inspect_status.count_total_generated_events(
generated_events,
batch.event_time.into_nanos().try_into().unwrap(),
);
} else {
log_warn!("unable to record inspect for button device");
}
dev.open_files.lock().retain(|f| {
let Some(file) = f.upgrade() else {
log_warn!("Dropping input file for buttons that failed to upgrade");
return false;
};
match &file.inspect_status {
Some(file_inspect_status) => {
file_inspect_status.count_received_events(1);
file_inspect_status.count_ignored_events(ignored_events);
file_inspect_status.count_converted_events(converted_events);
}
None => {
log_warn!("unable to record inspect within the input file")
}
}
if !batch.events.is_empty() {
if let Some(file_inspect_status) = &file.inspect_status {
file_inspect_status.count_generated_events(
generated_events,
batch.event_time.into_nanos().try_into().unwrap(),
);
}
file.add_events(batch.events.clone());
}
true
});
let _ = responder.send();
}
_ => { /* Ignore deprecated OnMediaButtonsEvent */ }
}
(
power_was_pressed_after,
function_was_pressed_after,
volume_up_was_pressed_after,
volume_down_was_pressed_after,
)
}
fn process_touch_button_event(
&mut self,
button_event: fuipolicy::TouchButtonsListenerRequest,
touch_buttons_were_pressed: &bit_vec::BitVec,
) -> bit_vec::BitVec {
fuchsia_trace::duration!("input", "starnix_process_touch_button_event");
match button_event {
fuipolicy::TouchButtonsListenerRequest::OnEvent { mut event, responder } => {
if let Some(trace_flow_id) = event.trace_flow_id {
fuchsia_trace::flow_end!(
"input",
"dispatch_touch_button_to_listeners",
trace_flow_id.into()
);
}
let device_id = match &event.device_info {
Some(TouchDeviceInfo { id: Some(id), .. }) => Some(*id),
_ => None,
};
let Some(dev) = self.get_device_mut(device_id, DEFAULT_TOUCH_DEVICE_ID, |t| {
matches!(t, InputDeviceType::Touch(_))
}) else {
log_warn!(
"Received touch button event for device {:?} but neither it nor default touch device is registered",
device_id
);
self.num_unregistered_device_events.fetch_add(1, Ordering::Relaxed);
let _ = responder.send();
return touch_buttons_were_pressed.clone();
};
let batch = parse_fidl_touch_button_event(&event, touch_buttons_were_pressed);
let (converted_events, ignored_events, generated_events) = match batch.events.len()
{
0 => (0u64, 1u64, 0u64),
len => {
if len % 2 == 1 {
log_warn!(
"unexpectedly received {} events: there should always be an even number of non-empty events.",
len
);
}
(1u64, 0u64, len as u64)
}
};
#[allow(clippy::collection_is_never_read)]
let mut tracked_leases = vec![];
if let Some(lease) = event.wake_lease.take() {
if let Some(status) = &dev.inspect_status {
tracked_leases.push(TrackedWakeLease::new(lease, status.clone()));
}
}
if let Some(dev_inspect_status) = &dev.inspect_status {
dev_inspect_status.count_total_received_events(1);
dev_inspect_status.count_total_ignored_events(ignored_events);
dev_inspect_status.count_total_converted_events(converted_events);
dev_inspect_status.count_total_generated_events(
generated_events,
batch.event_time.into_nanos().try_into().unwrap(),
);
} else {
log_warn!("unable to record inspect for touch device");
}
dev.open_files.lock().retain(|f| {
let Some(file) = f.upgrade() else {
log_warn!("Dropping input file for touch that failed to upgrade");
return false;
};
match &file.inspect_status {
Some(file_inspect_status) => {
file_inspect_status.count_received_events(1);
file_inspect_status.count_ignored_events(ignored_events);
file_inspect_status.count_converted_events(converted_events);
}
None => {
log_warn!("unable to record inspect within the input file")
}
}
if !batch.events.is_empty() {
if let Some(file_inspect_status) = &file.inspect_status {
file_inspect_status.count_generated_events(
generated_events,
batch.event_time.into_nanos().try_into().unwrap(),
);
}
file.add_events(batch.events.clone());
}
true
});
let _ = responder.send();
batch.touch_buttons
}
fuipolicy::TouchButtonsListenerRequest::_UnknownMethod { ordinal, .. } => {
log_warn!("Received an unknown method with ordinal {ordinal}");
touch_buttons_were_pressed.clone()
}
}
}
fn process_mouse_event(self: &mut Self, mouse_events: Vec<FidlMouseEvent>) {
fuchsia_trace::duration!("input", "starnix_process_mouse_event");
for e in &mouse_events {
if let Some(trace_flow_id) = e.trace_flow_id {
fuchsia_trace::flow_end!("input", "dispatch_event_to_client", trace_flow_id.into());
}
}
// TODO(https://fxbug.dev/563345995): `num_received_events` counts the whole
// batch and `num_ignored_events` accumulates across devices, yet both are
// recorded against every device in the loop below. With more than one mouse
// device in use simultaneously these counters over-report and violate the
// inspect invariants. Scope them per device before multi-mouse is supported.
let num_received_events: u64 = mouse_events.len().try_into().unwrap();
let mut num_ignored_events: u64 = 0;
let (events_by_device, ignored_events) = group_mouse_events_by_device_id(mouse_events);
num_ignored_events += ignored_events;
for (device_id, mut events) in events_by_device {
fuchsia_trace::duration_begin!("input", "starnix_process_per_device_mouse_event");
let Some(dev) = self.get_device_mut(Some(device_id), DEFAULT_MOUSE_DEVICE_ID, |t| {
matches!(t, InputDeviceType::Mouse(_))
}) else {
fuchsia_trace::duration_end!("input", "starnix_process_per_device_mouse_event");
log_warn!(
"Received mouse event for unregistered device {} and default mouse device is missing",
device_id
);
self.num_unregistered_device_events
.fetch_add(events.len() as u64, Ordering::Relaxed);
continue;
};
let mut num_converted_events: u64 = 0;
let mut num_unexpected_events: u64 = 0;
let mut new_events: VecDeque<uapi::input_event> = VecDeque::new();
#[allow(clippy::collection_is_never_read)]
let mut tracked_leases = vec![];
for event in &mut events {
if let Some(lease) = event.wake_lease.take() {
if let Some(status) = &dev.inspect_status {
tracked_leases.push(TrackedWakeLease::new(lease, status.clone()));
}
}
}
let InputDeviceType::Mouse(ref mut converter) = dev.device_type else { unreachable!() };
let mut batch = converter.handle(events);
new_events.append(&mut batch.events);
num_converted_events += batch.count_converted_events;
num_ignored_events += batch.count_ignored_events;
num_unexpected_events += batch.count_unexpected_events;
let last_event_time_ns = batch.last_event_time_ns;
for ev in &new_events {
if ev.type_ == uapi::EV_KEY as u16 {
if ev.value == 0 {
dev.active_mouse_buttons.remove(&ev.code);
} else if ev.value == 1 {
dev.active_mouse_buttons.insert(ev.code);
}
}
}
if !new_events.is_empty() {
dev.registration.ensure_registered();
}
if let Some(dev_inspect_status) = &dev.inspect_status {
dev_inspect_status.count_total_received_events(num_received_events);
dev_inspect_status.count_total_ignored_events(num_ignored_events);
dev_inspect_status.count_total_unexpected_events(num_unexpected_events);
dev_inspect_status.count_total_converted_events(num_converted_events);
if !new_events.is_empty() {
dev_inspect_status.count_total_generated_events(
new_events.len().try_into().unwrap(),
last_event_time_ns,
);
}
} else {
log_warn!(
"unable to record inspect for device_id: {}, device_type: {}",
device_id,
dev.device_type
);
}
fuchsia_trace::duration_end!("input", "starnix_process_per_device_mouse_event");
let mut open_files = dev.open_files.lock();
if !open_files.has_been_opened && !new_events.is_empty() {
open_files.buffered_events.extend(new_events.iter().copied());
}
open_files.retain(|f| {
let Some(file) = f.upgrade() else {
log_warn!("Dropping input file for mouse that failed to upgrade");
return false;
};
if let Some(file_inspect_status) = &file.inspect_status {
file_inspect_status.count_received_events(num_received_events);
file_inspect_status.count_ignored_events(num_ignored_events);
file_inspect_status.count_unexpected_events(num_unexpected_events);
file_inspect_status.count_converted_events(num_converted_events);
}
if !new_events.is_empty() {
if let Some(file_inspect_status) = &file.inspect_status {
file_inspect_status.count_generated_events(
new_events.len().try_into().unwrap(),
last_event_time_ns,
);
}
file.add_events(new_events.clone().into_iter().collect());
}
true
});
}
}
}
fn setup_touch_relay(
kernel: &Arc<Kernel>,
event_proxy_mode: EventProxyMode,
touch_source_client_end: ClientEnd<fuipointer::TouchSourceV2Marker>,
) -> (fuipointer::TouchSourceV2Proxy, ContainerWakingStream<fuipointer::TouchSourceV2EventStream>) {
let touch_counter_name = "touch";
let (touch_source_proxy, counter) = match event_proxy_mode {
EventProxyMode::WakeContainer => {
// Proxy the touch events through the Starnix runner. This allows touch events to
// wake the container when it is suspended.
let (touch_source_channel, counter) = create_proxy_for_wake_events_counter(
touch_source_client_end.into_channel(),
touch_counter_name.to_string(),
);
(
fuipointer::TouchSourceV2Proxy::new(fidl::AsyncChannel::from_channel(
touch_source_channel,
)),
Some(counter),
)
}
EventProxyMode::None => (touch_source_client_end.into_proxy(), None),
};
let waking_stream = ContainerWakingStream::new(
kernel.suspend_resume_manager.add_message_counter(touch_counter_name, counter),
touch_source_proxy.take_event_stream(),
);
(touch_source_proxy, waking_stream)
}
fn setup_keyboard_relay(
keyboard: KeyboardSynchronousProxy,
view_ref: fuiviews::ViewRef,
) -> (KeyboardListenerRequestStream, KeyboardSynchronousProxy) {
let (keyboard_listener, event_stream) =
fidl::endpoints::create_request_stream::<KeyboardListenerMarker>();
if let Err(e) =
keyboard.add_listener(view_ref, keyboard_listener, zx::MonotonicInstant::INFINITE)
{
log_warn!("Could not register keyboard listener: {:?}", e);
}
(event_stream, keyboard)
}
fn setup_button_relay(
kernel: &Arc<Kernel>,
registry_proxy: fuipolicy::DeviceListenerRegistrySynchronousProxy,
event_proxy_mode: EventProxyMode,
) -> (
ContainerWakingStream<fuipolicy::MediaButtonsListenerRequestStream>,
ContainerWakingStream<fuipolicy::TouchButtonsListenerRequestStream>,
) {
let media_buttons_name = "media buttons";
let touch_buttons_name = "touch buttons";
let (remote_media_button_client, remote_media_button_server) =
fidl::endpoints::create_endpoints::<fuipolicy::MediaButtonsListenerMarker>();
if let Err(e) =
registry_proxy.register_listener(remote_media_button_client, zx::MonotonicInstant::INFINITE)
{
log_warn!("Failed to register media buttons listener: {:?}", e);
}
let (remote_touch_button_client, remote_touch_button_server) =
fidl::endpoints::create_endpoints::<fuipolicy::TouchButtonsListenerMarker>();
if let Err(e) = registry_proxy
.register_touch_buttons_listener(remote_touch_button_client, zx::MonotonicInstant::INFINITE)
{
log_warn!("Failed to register touch buttons listener: {:?}", e);
}
let (
local_media_buttons_listener_stream,
media_buttons_counter,
local_touch_buttons_listener_stream,
touch_buttons_counter,
) = match event_proxy_mode {
EventProxyMode::WakeContainer => {
let (local_media_buttons_channel, media_buttons_counter) =
create_proxy_for_wake_events_counter(
remote_media_button_server.into_channel(),
media_buttons_name.to_string(),
);
let local_media_buttons_listener_stream =
fuipolicy::MediaButtonsListenerRequestStream::from_channel(
fidl::AsyncChannel::from_channel(local_media_buttons_channel),
);
let (local_touch_buttons_channel, touch_buttons_counter) =
create_proxy_for_wake_events_counter(
remote_touch_button_server.into_channel(),
touch_buttons_name.to_string(),
);
let local_touch_buttons_listener_stream =
fuipolicy::TouchButtonsListenerRequestStream::from_channel(
fidl::AsyncChannel::from_channel(local_touch_buttons_channel),
);
(
local_media_buttons_listener_stream,
Some(media_buttons_counter),
local_touch_buttons_listener_stream,
Some(touch_buttons_counter),
)
}
EventProxyMode::None => (
remote_media_button_server.into_stream(),
None,
remote_touch_button_server.into_stream(),
None,
),
};
(
ContainerWakingStream::new(
kernel
.suspend_resume_manager
.add_message_counter(media_buttons_name, media_buttons_counter),
local_media_buttons_listener_stream,
),
ContainerWakingStream::new(
kernel
.suspend_resume_manager
.add_message_counter(touch_buttons_name, touch_buttons_counter),
local_touch_buttons_listener_stream,
),
)
}
fn setup_device_listener_relay(
kernel: &Arc<Kernel>,
device_listener_server: ServerEnd<fuiinput::DeviceListenerMarker>,
event_proxy_mode: EventProxyMode,
) -> ContainerWakingStream<fuiinput::DeviceListenerRequestStream> {
let device_listener_name = "device listener";
let (local_device_listener_stream, device_listener_counter) = match event_proxy_mode {
EventProxyMode::WakeContainer => {
let (local_device_listener_channel, device_listener_counter) =
create_proxy_for_wake_events_counter(
device_listener_server.into_channel(),
device_listener_name.to_string(),
);
let local_device_listener_stream = fuiinput::DeviceListenerRequestStream::from_channel(
fidl::AsyncChannel::from_channel(local_device_listener_channel),
);
(local_device_listener_stream, Some(device_listener_counter))
}
EventProxyMode::None => (device_listener_server.into_stream(), None),
};
ContainerWakingStream::new(
kernel
.suspend_resume_manager
.add_message_counter(device_listener_name, device_listener_counter),
local_device_listener_stream,
)
}
fn parse_input_id(
info: Option<&fuiinput::DeviceInformation>,
fallback: uapi::input_id,
) -> uapi::input_id {
if let Some(info) = info {
uapi::input_id {
bustype: fallback.bustype,
vendor: info.vendor_id.filter(|&id| id != 0).unwrap_or(fallback.vendor as u32) as u16,
product: info.product_id.filter(|&id| id != 0).unwrap_or(fallback.product as u32)
as u16,
version: info.version.unwrap_or(fallback.version as u32) as u16,
}
} else {
fallback
}
}
fn register_and_add_device(
current_task: &CurrentTask,
devices_relay: &mut InputEventsRelay,
device_id: u32,
descriptor: fuiinput::DeviceDescriptor,
display_width: i32,
display_height: i32,
) -> Result<(), Errno> {
let kernel = current_task.kernel();
// Composite devices are registered under their primary function only
// (priority: touch > keyboard/consumer control > mouse).
let (default_name, default_input_id, device_type) = if let Some(_touch) = &descriptor.touch {
let name = descriptor
.device_information
.as_ref()
.and_then(|info| info.product_name.clone())
.unwrap_or_else(|| "starnix_touch".to_string());
let input_id = parse_input_id(descriptor.device_information.as_ref(), TOUCH_INPUT_ID);
(
name,
input_id,
InputDeviceType::Touch(FuchsiaTouchEventToLinuxTouchEventConverter::create()),
)
} else if descriptor.keyboard.is_some() || descriptor.consumer_control.is_some() {
let name = descriptor
.device_information
.as_ref()
.and_then(|info| info.product_name.clone())
.unwrap_or_else(|| "starnix_buttons".to_string());
let input_id = parse_input_id(descriptor.device_information.as_ref(), KEYBOARD_INPUT_ID);
(name, input_id, InputDeviceType::Keyboard)
} else if descriptor.mouse.is_some() {
let name = descriptor
.device_information
.as_ref()
.and_then(|info| info.product_name.clone())
.unwrap_or_else(|| "starnix_mouse".to_string());
let input_id = parse_input_id(descriptor.device_information.as_ref(), MOUSE_INPUT_ID);
(
name,
input_id,
InputDeviceType::Mouse(FuchsiaMouseEventToLinuxMouseEventConverter::create()),
)
} else {
return error!(ENOTSUP);
};
let info = {
let mut device_infos = devices_relay.device_infos.lock();
if let Some(info) = device_infos.get(&device_id) {
info.clone()
} else {
let info = InputDeviceInfo::new(default_input_id, default_name);
device_infos.insert(device_id, info.clone());
info
}
};
let input_device = match &device_type {
InputDeviceType::Touch(_) => InputDevice::new_touch(
display_width,
display_height,
info,
&format!("touch_device_{}", device_id),
&kernel.inspect_node,
),
InputDeviceType::Keyboard => InputDevice::new_keyboard(
info,
&format!("keyboard_device_{}", device_id),
&kernel.inspect_node,
),
InputDeviceType::Mouse(_) => InputDevice::new_mouse(
info,
&format!("mouse_device_{}", device_id),
&kernel.inspect_node,
),
};
if let Some(old_state) = devices_relay.devices.remove(&device_id) {
devices_relay.update_num_devices();
if let Some(old_starnix_device) = old_state.starnix_device {
InputDevice::unregister(current_task, old_starnix_device);
}
}
// Allocate the lowest available minor number for this device within the relay range.
// Note: `DeviceRegistry` does not provide dynamic minor allocation or recycling for
// `INPUT_MAJOR`, so minors are tracked and recycled locally here.
let minor = crate::RELAY_MINOR_RANGE
.clone()
.find(|&m| !devices_relay.devices.values().any(|s| s.minor == m))
.expect("failed to allocate minor number");
let starnix_device = input_device.clone().register(kernel, minor)?;
let device_state = DeviceState {
device_type,
open_files: input_device.open_files,
inspect_status: Some(input_device.inspect_status),
registration: DeviceRegistration::Registered,
starnix_device: Some(starnix_device),
minor,
active_touch_slots: HashSet::new(),
active_mouse_buttons: HashSet::new(),
active_keyboard_keys: HashSet::new(),
};
devices_relay.devices.insert(device_id, device_state);
devices_relay.update_num_devices();
Ok(())
}
fn setup_mouse_relay(
kernel: &Arc<Kernel>,
event_proxy_mode: EventProxyMode,
mouse_source_client_end: ClientEnd<fuipointer::MouseSourceV2Marker>,
) -> (fuipointer::MouseSourceV2Proxy, ContainerWakingStream<fuipointer::MouseSourceV2EventStream>) {
let mouse_counter_name = "mouse";
let (mouse_source_proxy, counter) = match event_proxy_mode {
EventProxyMode::WakeContainer => {
// Proxy the mouse events through the Starnix runner. This allows mouse events to
// wake the container when it is suspended.
let (mouse_source_channel, resume_event) = create_proxy_for_wake_events_counter(
mouse_source_client_end.into_channel(),
"mouse".to_string(),
);
(
fuipointer::MouseSourceV2Proxy::new(fidl::AsyncChannel::from_channel(
mouse_source_channel,
)),
Some(resume_event),
)
}
EventProxyMode::None => (mouse_source_client_end.into_proxy(), None),
};
let waking_stream = ContainerWakingStream::new(
kernel.suspend_resume_manager.add_message_counter(mouse_counter_name, counter),
mouse_source_proxy.take_event_stream(),
);
(mouse_source_proxy, waking_stream)
}
fn group_mouse_events_by_device_id(
events: Vec<FidlMouseEvent>,
) -> (SortedVecMap<DeviceId, Vec<FidlMouseEvent>>, u64) {
let mut events_by_device: SortedVecMap<u32, Vec<FidlMouseEvent>> = SortedVecMap::new();
let mut ignored_events: u64 = 0;
for e in events {
match e {
FidlMouseEvent { pointer_sample: Some(ref sample), .. } => {
let id = sample.device_id.unwrap_or(DEFAULT_MOUSE_DEVICE_ID);
if let Some(vec) = events_by_device.get_mut(&id) {
vec.push(e);
} else {
events_by_device.insert(id, vec![e]);
}
}
_ => {
ignored_events += 1;
}
}
}
(events_by_device, ignored_events)
}
fn group_touch_events_by_device_id(
events: Vec<FidlTouchEvent>,
) -> (SortedVecMap<DeviceId, Vec<FidlTouchEvent>>, u64) {
let mut events_by_device: SortedVecMap<u32, Vec<FidlTouchEvent>> = SortedVecMap::new();
let mut ignored_events: u64 = 0;
for e in events {
match e {
FidlTouchEvent {
pointer_sample: Some(TouchPointerSample { interaction: Some(id), .. }),
..
} => {
if let Some(vec) = events_by_device.get_mut(&id.device_id) {
vec.push(e);
} else {
events_by_device.insert(id.device_id, vec![e]);
}
}
_ => {
ignored_events += 1;
}
}
}
(events_by_device, ignored_events)
}
#[cfg(test)]
pub async fn start_input_relays_for_test(
current_task: &starnix_core::task::CurrentTask,
event_proxy_mode: EventProxyMode,
) -> (
Arc<InputEventsRelayHandle>,
crate::InputDevice,
crate::InputDevice,
crate::InputDevice,
starnix_core::vfs::FileHandle,
starnix_core::vfs::FileHandle,
starnix_core::vfs::FileHandle,
fuipointer::TouchSourceV2RequestStream,
fuipointer::MouseSourceV2RequestStream,
fidl_fuchsia_ui_input3::KeyboardListenerProxy,
fuipolicy::MediaButtonsListenerProxy,
fuipolicy::TouchButtonsListenerProxy,
) {
let inspector = fuchsia_inspect::Inspector::default();
let touch_device = crate::InputDevice::new_touch(
700,
1200,
crate::InputDeviceInfo::new(TOUCH_INPUT_ID, "starnix_touch".to_string()),
"touch_device",
inspector.root(),
);
let touch_file = touch_device.open_test(current_task).expect("Failed to create input file");
let keyboard_device = crate::InputDevice::new_keyboard(
crate::InputDeviceInfo::new(KEYBOARD_INPUT_ID, "starnix_buttons".to_string()),
"keyboard_device",
inspector.root(),
);
let keyboard_file =
keyboard_device.open_test(current_task).expect("Failed to create input file");
let mouse_device = crate::InputDevice::new_mouse(
crate::InputDeviceInfo::new(MOUSE_INPUT_ID, "starnix_mouse".to_string()),
"mouse_device",
inspector.root(),
);
let mouse_file = mouse_device.open_test(current_task).expect("Failed to create input file");
let (touch_source_client_end, touch_source_stream) =
fidl::endpoints::create_request_stream::<fuipointer::TouchSourceV2Marker>();
let (mouse_source_client_end, mouse_stream) =
fidl::endpoints::create_request_stream::<fuipointer::MouseSourceV2Marker>();
let (keyboard_proxy, mut keyboard_stream) =
fidl::endpoints::create_sync_proxy_and_stream::<fidl_fuchsia_ui_input3::KeyboardMarker>();
let view_ref_pair = fuchsia_scenic::ViewRefPair::new().expect("Failed to create ViewRefPair");
let (device_registry_proxy, mut device_listener_stream) =
fidl::endpoints::create_sync_proxy_and_stream::<fuipolicy::DeviceListenerRegistryMarker>();
let (mut relay, relay_handle) = new_input_relay();
// TODO(https://fxbug.dev/502662433): Default devices are no longer needed because
// existing devices are enumerated via the DeviceIterator before start_relays().
// Remove them in a follow-up change.
relay.add_touch_device(
DEFAULT_TOUCH_DEVICE_ID,
touch_device.open_files.clone(),
Some(touch_device.inspect_status.clone()),
);
relay.add_keyboard_device(
DEFAULT_KEYBOARD_DEVICE_ID,
keyboard_device.open_files.clone(),
Some(keyboard_device.inspect_status.clone()),
);
relay.add_mouse_device(
DEFAULT_MOUSE_DEVICE_ID,
mouse_device.open_files.clone(),
Some(mouse_device.inspect_status.clone()),
);
relay.start_relays(
&current_task.kernel(),
StartRelaysArgs {
event_proxy_mode,
touch_source_client_end,
keyboard_proxy,
mouse_source_client_end,
view_ref: view_ref_pair.view_ref,
registry_proxy: device_registry_proxy,
device_listener_registry: None,
display_width: 700,
display_height: 1200,
},
);
let keyboard_listener = match keyboard_stream.next().await {
Some(Ok(fidl_fuchsia_ui_input3::KeyboardRequest::AddListener {
view_ref: _,
listener,
responder,
})) => {
let _ = responder.send();
listener.into_proxy()
}
_ => {
panic!("Failed to get event");
}
};
let media_buttons_listener = match device_listener_stream.next().await {
Some(Ok(fuipolicy::DeviceListenerRegistryRequest::RegisterListener {
listener,
responder,
})) => {
let _ = responder.send();
listener.into_proxy()
}
_ => {
panic!("Failed to get event");
}
};
let touch_buttons_listener = match device_listener_stream.next().await {
Some(Ok(fuipolicy::DeviceListenerRegistryRequest::RegisterTouchButtonsListener {
listener,
responder,
})) => {
let _ = responder.send();
listener.into_proxy()
}
_ => {
panic!("Failed to get event");
}
};
(
relay_handle,
touch_device,
keyboard_device,
mouse_device,
touch_file,
keyboard_file,
mouse_file,
touch_source_stream,
mouse_stream,
keyboard_listener,
media_buttons_listener,
touch_buttons_listener,
)
}
#[cfg(test)]
mod test {
use super::*;
use anyhow::anyhow;
use diagnostics_assertions::assert_data_tree;
use fidl_fuchsia_ui_input::{
MediaButtonsEvent, TouchButton, TouchButtonsEvent, TouchDeviceInfo,
};
use fidl_fuchsia_ui_input3 as fuiinput;
use fuipointer::{
EventPhase, MouseEvent, MousePointerSample, TouchEvent, TouchInteractionId,
TouchPointerSample, TouchSourceV2Request, TouchSourceV2RequestStream,
};
use starnix_core::task::CurrentTask;
use starnix_core::testing::spawn_kernel_and_run;
use starnix_core::vfs::{FileHandle, FileObject, VecOutputBuffer};
use starnix_types::time::timeval_from_time;
use starnix_uapi::errors::{EAGAIN, Errno};
use starnix_uapi::input_id;
use starnix_uapi::open_flags::OpenFlags;
use zerocopy::FromBytes as _;
const INPUT_EVENT_SIZE: usize = std::mem::size_of::<uapi::input_event>();
// Sends `touch_events` to the client stream and waits for `AcknowledgeEvents`.
async fn answer_next_touch_watch_request(
request_stream: &mut TouchSourceV2RequestStream,
touch_events: Vec<TouchEvent>,
) {
let control_handle = request_stream.control_handle();
control_handle
.send_on_touch_events(touch_events, 1)
.expect("failure sending OnTouchEvents");
match request_stream.next().await {
Some(Ok(TouchSourceV2Request::AcknowledgeEvents { .. })) => {}
unexpected_request => panic!("unexpected request {:?}", unexpected_request),
}
}
// Sends `mouse_events` to the client stream and waits for `AcknowledgeEvents`.
async fn answer_next_mouse_watch_request(
request_stream: &mut fuipointer::MouseSourceV2RequestStream,
mouse_events: Vec<MouseEvent>,
) {
let control_handle = request_stream.control_handle();
control_handle
.send_on_mouse_events(mouse_events, 1)
.expect("failure sending OnMouseEvents");
match request_stream.next().await {
Some(Ok(fuipointer::MouseSourceV2Request::AcknowledgeEvents { .. })) => {}
unexpected_request => panic!("unexpected request {:?}", unexpected_request),
}
}
fn make_empty_touch_event(device_id: u32) -> TouchEvent {
TouchEvent {
pointer_sample: Some(TouchPointerSample {
interaction: Some(TouchInteractionId {
pointer_id: 0,
device_id,
interaction_id: 0,
}),
..Default::default()
}),
..Default::default()
}
}
fn make_touch_event_with_phase_device_id(
phase: EventPhase,
pointer_id: u32,
device_id: u32,
) -> TouchEvent {
make_touch_event_with_phase_device_id_position(phase, pointer_id, device_id, 0.0, 0.0)
}
fn make_touch_event_with_phase_device_id_position(
phase: EventPhase,
pointer_id: u32,
device_id: u32,
x: f32,
y: f32,
) -> TouchEvent {
TouchEvent {
timestamp: Some(0),
pointer_sample: Some(TouchPointerSample {
position_in_viewport: Some([x, y]),
phase: Some(phase),
interaction: Some(TouchInteractionId { pointer_id, device_id, interaction_id: 0 }),
..Default::default()
}),
..Default::default()
}
}
fn make_mouse_wheel_event(scroll_v_ticks: i64, device_id: u32) -> MouseEvent {
MouseEvent {
timestamp: Some(0),
pointer_sample: Some(MousePointerSample {
device_id: Some(device_id),
scroll_v: Some(scroll_v_ticks),
..Default::default()
}),
..Default::default()
}
}
fn read_uapi_events(file: &FileHandle, current_task: &CurrentTask) -> Vec<uapi::input_event> {
std::iter::from_fn(|| {
let mut event_bytes = VecOutputBuffer::new(INPUT_EVENT_SIZE);
match file.read(current_task, &mut event_bytes) {
Ok(INPUT_EVENT_SIZE) => Some(
uapi::input_event::read_from_bytes(Vec::from(event_bytes).as_slice())
.map_err(|_| anyhow!("failed to read input_event from buffer")),
),
Ok(other_size) => {
Some(Err(anyhow!("got {} bytes (expected {})", other_size, INPUT_EVENT_SIZE)))
}
Err(Errno { code: EAGAIN, .. }) => None,
Err(other_error) => Some(Err(anyhow!("read failed: {:?}", other_error))),
}
})
.enumerate()
.map(|(i, read_res)| match read_res {
Ok(event) => event,
Err(e) => panic!("unexpected result {:?} on iteration {}", e, i),
})
.collect()
}
fn create_test_touch_device(
current_task: &CurrentTask,
input_relay: Arc<InputEventsRelayHandle>,
device_id: u32,
) -> FileHandle {
let open_files: OpenedFiles = Default::default();
input_relay.add_touch_device(device_id, open_files.clone(), None);
let inspector = fuchsia_inspect::Inspector::default();
let device_file = Arc::new(InputFile::new_touch(
InputDeviceInfo::new(
input_id { bustype: 0, vendor: 0, product: 0, version: 0 },
"touch_device".to_string(),
),
1000,
1000,
inspector.root(),
));
open_files.lock().push(Arc::downgrade(&device_file));
let root_namespace_node = current_task
.lookup_path_from_root(".".into())
.expect("failed to get namespace node for root");
FileObject::new(
&current_task,
Box::new(crate::input_file::ArcInputFile(device_file)),
root_namespace_node,
OpenFlags::empty(),
)
.expect("FileObject::new failed")
}
fn make_uapi_input_event(ty: u32, code: u32, value: i32) -> uapi::input_event {
uapi::input_event {
time: timeval_from_time(zx::MonotonicInstant::from_nanos(0)),
type_: ty as u16,
code: code as u16,
value,
}
}
#[::fuchsia::test]
async fn route_touch_event_by_device_id() {
spawn_kernel_and_run(async move |current_task| {
// Set up resources.
let (
input_relay,
_touch_device,
_keyboard_device,
_mouse_device,
input_file,
_keyboard_file,
_mouse_file,
mut touch_source_stream,
_mouse_source_stream,
_keyboard_listener,
_media_buttons_listener,
_touch_buttons_listener,
) = start_input_relays_for_test(&current_task, EventProxyMode::None).await;
const DEVICE_ID: u32 = 10;
answer_next_touch_watch_request(
&mut touch_source_stream,
vec![make_touch_event_with_phase_device_id(EventPhase::Add, 1, DEVICE_ID)],
)
.await;
// Wait for another `Watch` to ensure input_file done processing the first reply.
// Use an empty `TouchEvent`, to minimize the chance that this event creates unexpected
// `uapi::input_event`s.
answer_next_touch_watch_request(
&mut touch_source_stream,
vec![make_empty_touch_event(DEVICE_ID)],
)
.await;
// Consume all of the `uapi::input_event`s that are available.
let events = read_uapi_events(&input_file, &current_task);
// Default device should receive events because device id 10 falls back to default.
assert_ne!(events.len(), 0);
assert_eq!(input_relay.num_unregistered_device_events(), 0);
// add a device, mock uinput.
let device_id_10_file =
create_test_touch_device(&current_task, input_relay.clone(), DEVICE_ID);
answer_next_touch_watch_request(
&mut touch_source_stream,
vec![make_touch_event_with_phase_device_id(EventPhase::Add, 1, DEVICE_ID)],
)
.await;
answer_next_touch_watch_request(
&mut touch_source_stream,
vec![make_empty_touch_event(DEVICE_ID)],
)
.await;
let events = read_uapi_events(&input_file, &current_task);
// Default device should not receive events because they matched device id 10.
assert_eq!(events.len(), 0);
let events = read_uapi_events(&device_id_10_file, &current_task);
// file of device id 10 should receive events.
assert_ne!(events.len(), 0);
})
.await;
}
#[::fuchsia::test]
async fn route_touch_event_with_wake_lease() {
spawn_kernel_and_run(async move |current_task| {
let (
_input_relay,
touch_device,
_keyboard_device,
_mouse_device,
_input_file,
_keyboard_file,
_mouse_file,
mut touch_source_stream,
_mouse_source_stream,
_keyboard_listener,
_media_buttons_listener,
_touch_buttons_listener,
) = start_input_relays_for_test(&current_task, EventProxyMode::None).await;
const DEVICE_ID: u32 = DEFAULT_TOUCH_DEVICE_ID;
let mut event = make_touch_event_with_phase_device_id(EventPhase::Add, 1, DEVICE_ID);
let (p1, _p2) = fidl::EventPair::create();
event.wake_lease = Some(p1);
answer_next_touch_watch_request(&mut touch_source_stream, vec![event]).await;
// Wait for another `Watch` to ensure input_file done processing the first reply.
answer_next_touch_watch_request(
&mut touch_source_stream,
vec![make_empty_touch_event(DEVICE_ID)],
)
.await;
let status = &touch_device.inspect_status;
assert_eq!(
status
.total_events_with_wake_lease_count
.load(std::sync::atomic::Ordering::Relaxed),
1
);
assert_eq!(
status.active_wake_leases_count.load(std::sync::atomic::Ordering::Relaxed),
0
);
})
.await;
}
#[::fuchsia::test]
async fn route_touch_event_by_device_id_multi_device_events_in_one_sequence() {
spawn_kernel_and_run(async move |current_task| {
let (
input_relay,
_touch_device,
_keyboard_device,
_mouse_device,
_input_file,
_keyboard_file,
_mouse_file,
mut touch_source_stream,
_mouse_source_stream,
_keyboard_listener,
_media_buttons_listener,
_touch_buttons_listener,
) = start_input_relays_for_test(&current_task, EventProxyMode::None).await;
const DEVICE_ID_10: u32 = 10;
const DEVICE_ID_11: u32 = 11;
let device_id_10_file =
create_test_touch_device(&current_task, input_relay.clone(), DEVICE_ID_10);
let device_id_11_file =
create_test_touch_device(&current_task, input_relay.clone(), DEVICE_ID_11);
// 2 pointer down on different touch device.
answer_next_touch_watch_request(
&mut touch_source_stream,
vec![
make_touch_event_with_phase_device_id_position(
EventPhase::Add,
1,
DEVICE_ID_10,
10.0,
20.0,
),
make_touch_event_with_phase_device_id_position(
EventPhase::Add,
2,
DEVICE_ID_11,
30.0,
40.0,
),
],
)
.await;
answer_next_touch_watch_request(&mut touch_source_stream, vec![]).await;
let events_10 = read_uapi_events(&device_id_10_file, &current_task);
let events_11 = read_uapi_events(&device_id_11_file, &current_task);
assert_eq!(events_10.len(), events_11.len());
assert_eq!(
events_10,
vec![
make_uapi_input_event(uapi::EV_ABS, uapi::ABS_MT_SLOT, 0),
make_uapi_input_event(uapi::EV_ABS, uapi::ABS_MT_TRACKING_ID, 1),
make_uapi_input_event(uapi::EV_ABS, uapi::ABS_MT_POSITION_X, 10),
make_uapi_input_event(uapi::EV_ABS, uapi::ABS_MT_POSITION_Y, 20),
make_uapi_input_event(uapi::EV_KEY, uapi::BTN_TOUCH, 1),
make_uapi_input_event(uapi::EV_SYN, uapi::SYN_REPORT, 0),
]
);
assert_eq!(
events_11,
vec![
make_uapi_input_event(uapi::EV_ABS, uapi::ABS_MT_SLOT, 0),
make_uapi_input_event(uapi::EV_ABS, uapi::ABS_MT_TRACKING_ID, 2),
make_uapi_input_event(uapi::EV_ABS, uapi::ABS_MT_POSITION_X, 30),
make_uapi_input_event(uapi::EV_ABS, uapi::ABS_MT_POSITION_Y, 40),
make_uapi_input_event(uapi::EV_KEY, uapi::BTN_TOUCH, 1),
make_uapi_input_event(uapi::EV_SYN, uapi::SYN_REPORT, 0),
]
);
})
.await;
}
#[::fuchsia::test]
async fn route_key_event_by_device_id() {
spawn_kernel_and_run(async move |current_task| {
// Set up resources.
let (
input_relay,
_touch_device,
_keyboard_device,
_mouse_device,
_touch_file,
keyboard_file,
_mouse_file,
_touch_source_stream,
_mouse_source_stream,
keyboard_listener,
_media_buttons_listener,
_touch_buttons_listener,
) = start_input_relays_for_test(&current_task, EventProxyMode::None).await;
const DEVICE_ID: u32 = 10;
let key_event = fuiinput::KeyEvent {
timestamp: Some(0),
type_: Some(fuiinput::KeyEventType::Pressed),
key: Some(fidl_fuchsia_input::Key::A),
device_id: Some(DEVICE_ID),
..Default::default()
};
let _ = keyboard_listener.on_key_event(&key_event).await;
let events = read_uapi_events(&keyboard_file, &current_task);
// Default device should receive events because device id 10 falls back to default.
assert_ne!(events.len(), 0);
assert_eq!(input_relay.num_unregistered_device_events(), 0);
// add a device, mock uinput.
let open_files: OpenedFiles = Default::default();
input_relay.add_keyboard_device(DEVICE_ID, open_files.clone(), None);
let inspector = fuchsia_inspect::Inspector::default();
let device_id_10_file = Arc::new(InputFile::new_keyboard(
InputDeviceInfo::new(
input_id { bustype: 0, vendor: 0, product: 0, version: 0 },
"keyboard_10".to_string(),
),
inspector.root(),
));
open_files.lock().push(Arc::downgrade(&device_id_10_file));
let root_namespace_node = current_task
.lookup_path_from_root(".".into())
.expect("failed to get namespace node for root");
let device_id_10_file_object = FileObject::new(
&current_task,
Box::new(crate::input_file::ArcInputFile(device_id_10_file)),
root_namespace_node,
OpenFlags::empty(),
)
.expect("FileObject::new failed");
let _ = keyboard_listener.on_key_event(&key_event).await;
let events = read_uapi_events(&keyboard_file, &current_task);
// Default device should not receive events because they matched device id 10.
assert_eq!(events.len(), 0);
let events = read_uapi_events(&device_id_10_file_object, &current_task);
// file of device id 10 should receive events.
assert_ne!(events.len(), 0);
std::mem::drop(keyboard_listener); // Close Zircon channel.
})
.await;
}
#[::fuchsia::test]
async fn route_media_button_event_by_device_id() {
spawn_kernel_and_run(async move |current_task| {
// Set up resources.
let (
input_relay,
_touch_device,
_keyboard_device,
_mouse_device,
_touch_file,
keyboard_file,
_mouse_file,
_touch_source_stream,
_mouse_source_stream,
_keyboard_listener,
media_buttons_listener,
_touch_buttons_listener,
) = start_input_relays_for_test(&current_task, EventProxyMode::None).await;
const DEVICE_ID: u32 = 10;
let power_pressed_event = MediaButtonsEvent {
volume: Some(0),
mic_mute: Some(false),
pause: Some(false),
camera_disable: Some(false),
power: Some(true),
function: Some(false),
device_id: Some(DEVICE_ID),
..Default::default()
};
let _ = media_buttons_listener.on_event(power_pressed_event).await;
let events = read_uapi_events(&keyboard_file, &current_task);
// Default device should receive events because device id 10 falls back to default.
assert_ne!(events.len(), 0);
assert_eq!(input_relay.num_unregistered_device_events(), 0);
// add a device, mock uinput.
let open_files: OpenedFiles = Default::default();
input_relay.add_keyboard_device(DEVICE_ID, open_files.clone(), None);
let inspector = fuchsia_inspect::Inspector::default();
let device_id_10_file = Arc::new(InputFile::new_keyboard(
InputDeviceInfo::new(
input_id { bustype: 0, vendor: 0, product: 0, version: 0 },
"keyboard_10".to_string(),
),
inspector.root(),
));
open_files.lock().push(Arc::downgrade(&device_id_10_file));
let root_namespace_node = current_task
.lookup_path_from_root(".".into())
.expect("failed to get namespace node for root");
let device_id_10_file_object = FileObject::new(
&current_task,
Box::new(crate::input_file::ArcInputFile(device_id_10_file)),
root_namespace_node,
OpenFlags::empty(),
)
.expect("FileObject::new failed");
let power_released_event = MediaButtonsEvent {
volume: Some(0),
mic_mute: Some(false),
pause: Some(false),
camera_disable: Some(false),
power: Some(false),
function: Some(false),
device_id: Some(DEVICE_ID),
..Default::default()
};
let _ = media_buttons_listener.on_event(power_released_event).await;
let events = read_uapi_events(&keyboard_file, &current_task);
// Default device should not receive events because they matched device id 10.
assert_eq!(events.len(), 0);
let events = read_uapi_events(&device_id_10_file_object, &current_task);
// file of device id 10 should receive events.
assert_ne!(events.len(), 0);
std::mem::drop(media_buttons_listener); // Close Zircon channel.
})
.await;
}
#[::fuchsia::test]
async fn route_touch_button_event_by_device_id() {
spawn_kernel_and_run(async move |current_task| {
// Set up resources.
let (
input_relay,
_touch_device,
_keyboard_device,
_mouse_device,
touch_file,
_keyboard_file,
_mouse_file,
_touch_source_stream,
_mouse_source_stream,
_keyboard_listener,
_media_buttons_listener,
touch_buttons_listener,
) = start_input_relays_for_test(&current_task, EventProxyMode::None).await;
const DEVICE_ID: u32 = 10;
let palm_pressed_event: TouchButtonsEvent = TouchButtonsEvent {
pressed_buttons: Some(vec![TouchButton::Palm]),
device_info: Some(TouchDeviceInfo { id: Some(DEVICE_ID), ..Default::default() }),
..Default::default()
};
let _ = touch_buttons_listener.on_event(palm_pressed_event).await;
let events = read_uapi_events(&touch_file, &current_task);
// Default device should receive events because device id 10 falls back to default.
assert_ne!(events.len(), 0);
assert_eq!(input_relay.num_unregistered_device_events(), 0);
// add a device, mock uinput.
let device_id_10_file =
create_test_touch_device(&current_task, input_relay.clone(), DEVICE_ID);
let palm_released_event: TouchButtonsEvent = TouchButtonsEvent {
pressed_buttons: Some(vec![]),
device_info: Some(TouchDeviceInfo { id: Some(DEVICE_ID), ..Default::default() }),
..Default::default()
};
let _ = touch_buttons_listener.on_event(palm_released_event).await;
let events = read_uapi_events(&touch_file, &current_task);
// Default device should not receive events because they matched device id 10.
assert_eq!(events.len(), 0);
let events = read_uapi_events(&device_id_10_file, &current_task);
// file of device id 10 should receive events.
assert_ne!(events.len(), 0);
std::mem::drop(touch_buttons_listener); // Close Zircon channel.
})
.await;
}
#[::fuchsia::test]
async fn touch_device_multi_reader() {
spawn_kernel_and_run(async move |current_task| {
// Set up resources.
let (
_input_relay,
touch_device,
_keyboard_device,
_mouse_device,
touch_reader1,
_keyboard_file,
_mouse_file,
mut touch_source_stream,
_mouse_source_stream,
_keyboard_listener,
_media_buttons_listener,
_touch_buttons_listener,
) = start_input_relays_for_test(&current_task, EventProxyMode::None).await;
let touch_reader2 =
touch_device.open_test(&current_task).expect("Failed to create input file");
const DEVICE_ID: u32 = DEFAULT_TOUCH_DEVICE_ID;
answer_next_touch_watch_request(
&mut touch_source_stream,
vec![make_touch_event_with_phase_device_id(EventPhase::Add, 1, DEVICE_ID)],
)
.await;
// Wait for another `Watch` to ensure input_file done processing the first reply.
// Use an empty `TouchEvent`, to minimize the chance that this event creates unexpected
// `uapi::input_event`s.
answer_next_touch_watch_request(
&mut touch_source_stream,
vec![make_empty_touch_event(DEVICE_ID)],
)
.await;
// Consume all of the `uapi::input_event`s that are available.
let events_from_reader1 = read_uapi_events(&touch_reader1, &current_task);
let events_from_reader2 = read_uapi_events(&touch_reader2, &current_task);
assert_ne!(events_from_reader1.len(), 0);
assert_eq!(events_from_reader1.len(), events_from_reader2.len());
})
.await;
}
#[::fuchsia::test]
async fn keyboard_device_multi_reader() {
spawn_kernel_and_run(async move |current_task| {
// Set up resources.
let (
_input_relay,
_touch_device,
keyboard_device,
_mouse_device,
_touch_file,
keyboard_reader1,
_mouse_file,
_touch_source_stream,
_mouse_source_stream,
keyboard_listener,
_media_buttons_listener,
_touch_buttons_listener,
) = start_input_relays_for_test(&current_task, EventProxyMode::None).await;
let keyboard_reader2 =
keyboard_device.open_test(&current_task).expect("Failed to create input file");
const DEVICE_ID: u32 = DEFAULT_KEYBOARD_DEVICE_ID;
let key_event = fuiinput::KeyEvent {
timestamp: Some(0),
type_: Some(fuiinput::KeyEventType::Pressed),
key: Some(fidl_fuchsia_input::Key::A),
device_id: Some(DEVICE_ID),
..Default::default()
};
let _ = keyboard_listener.on_key_event(&key_event).await;
// Consume all of the `uapi::input_event`s that are available.
let events_from_reader1 = read_uapi_events(&keyboard_reader1, &current_task);
let events_from_reader2 = read_uapi_events(&keyboard_reader2, &current_task);
assert_ne!(events_from_reader1.len(), 0);
assert_eq!(events_from_reader1.len(), events_from_reader2.len());
})
.await;
}
#[::fuchsia::test]
async fn button_device_multi_reader() {
spawn_kernel_and_run(async move |current_task| {
// Set up resources.
let (
_input_relay,
_touch_device,
keyboard_device,
_mouse_device,
_touch_file,
keyboard_reader1,
_mouse_file,
_touch_source_stream,
_mouse_source_stream,
_keyboard_listener,
media_buttons_listener,
_touch_buttons_listener,
) = start_input_relays_for_test(&current_task, EventProxyMode::None).await;
let keyboard_reader2 =
keyboard_device.open_test(&current_task).expect("Failed to create input file");
const DEVICE_ID: u32 = DEFAULT_KEYBOARD_DEVICE_ID;
let power_pressed_event = MediaButtonsEvent {
volume: Some(0),
mic_mute: Some(false),
pause: Some(false),
camera_disable: Some(false),
power: Some(true),
function: Some(false),
device_id: Some(DEVICE_ID),
..Default::default()
};
let _ = media_buttons_listener.on_event(power_pressed_event).await;
// Consume all of the `uapi::input_event`s that are available.
let events_from_reader1 = read_uapi_events(&keyboard_reader1, &current_task);
let events_from_reader2 = read_uapi_events(&keyboard_reader2, &current_task);
assert_ne!(events_from_reader1.len(), 0);
assert_eq!(events_from_reader1.len(), events_from_reader2.len());
})
.await;
}
#[::fuchsia::test]
async fn mouse_device_multi_reader() {
spawn_kernel_and_run(async move |current_task| {
// Set up resources.
let (
_input_relay,
_touch_device,
_keyboard_device,
mouse_device,
_touch_file,
_keyboard_file,
mouse_reader1,
_touch_stream,
mut mouse_stream,
_keyboard_listener,
_media_buttons_listener,
_touch_buttons_listener,
) = start_input_relays_for_test(&current_task, EventProxyMode::None).await;
let mouse_reader2 =
mouse_device.open_test(&current_task).expect("Failed to create input file");
const DEVICE_ID: u32 = DEFAULT_MOUSE_DEVICE_ID;
answer_next_mouse_watch_request(
&mut mouse_stream,
vec![make_mouse_wheel_event(1, DEVICE_ID)],
)
.await;
// Wait for another `Watch` to ensure input_file done processing the first reply.
// Use an empty `MouseEvent`, to minimize the chance that this event creates unexpected
// `uapi::input_event`s.
answer_next_mouse_watch_request(
&mut mouse_stream,
vec![make_mouse_wheel_event(0, DEVICE_ID)],
)
.await;
// Consume all of the `uapi::input_event`s that are available.
let events_from_reader1 = read_uapi_events(&mouse_reader1, &current_task);
let events_from_reader2 = read_uapi_events(&mouse_reader2, &current_task);
assert_ne!(events_from_reader1.len(), 0);
assert_eq!(events_from_reader1.len(), events_from_reader2.len());
})
.await;
}
#[::fuchsia::test]
async fn input_message_counters() {
spawn_kernel_and_run(async move |current_task| {
// Set up resources.
let kernel = current_task.kernel().clone();
let (
_input_relay,
_touch_device,
_keyboard_device,
_mouse_device,
_touch_file,
keyboard_file,
_mouse_file,
_touch_source_stream,
_mouse_source_stream,
keyboard_listener,
_media_buttons_listener,
_touch_buttons_listener,
) = start_input_relays_for_test(&current_task, EventProxyMode::WakeContainer).await;
const DEVICE_ID: u32 = DEFAULT_KEYBOARD_DEVICE_ID;
let key_event = fuiinput::KeyEvent {
timestamp: Some(0),
type_: Some(fuiinput::KeyEventType::Pressed),
key: Some(fidl_fuchsia_input::Key::A),
device_id: Some(DEVICE_ID),
..Default::default()
};
let _ = keyboard_listener.on_key_event(&key_event).await;
let events = read_uapi_events(&keyboard_file, &current_task);
assert_ne!(events.len(), 0);
assert!(!kernel.suspend_resume_manager.has_nonzero_message_counter());
})
.await;
}
#[::fuchsia::test]
async fn mouse_device_lazily_registered_on_first_mouse_event() {
spawn_kernel_and_run(async move |current_task| {
let kernel = current_task.kernel().clone();
let inspector = fuchsia_inspect::Inspector::default();
let touch_device = crate::InputDevice::new_touch(
700,
1200,
crate::InputDeviceInfo::new(TOUCH_INPUT_ID, "starnix_touch".to_string()),
"touch_device",
inspector.root(),
);
let keyboard_device = crate::InputDevice::new_keyboard(
crate::InputDeviceInfo::new(KEYBOARD_INPUT_ID, "starnix_buttons".to_string()),
"keyboard_device",
inspector.root(),
);
// Do not open `mouse_device` before registration so we test production ordering:
// userspace can only open `/dev/input/event2` after `DeviceRegistry` registration.
let mouse_device = crate::InputDevice::new_mouse(
crate::InputDeviceInfo::new(MOUSE_INPUT_ID, "starnix_mouse".to_string()),
"mouse_device",
inspector.root(),
);
let (touch_source_client_end, _touch_source_stream) =
fidl::endpoints::create_request_stream::<fuipointer::TouchSourceV2Marker>();
let (mouse_source_client_end, mut mouse_stream) =
fidl::endpoints::create_request_stream::<fuipointer::MouseSourceV2Marker>();
let (keyboard_proxy, mut keyboard_stream) =
fidl::endpoints::create_sync_proxy_and_stream::<fuiinput::KeyboardMarker>();
let view_ref_pair =
fuchsia_scenic::ViewRefPair::new().expect("Failed to create ViewRefPair");
let (device_registry_proxy, mut device_listener_stream) =
fidl::endpoints::create_sync_proxy_and_stream::<
fuipolicy::DeviceListenerRegistryMarker,
>();
let (mut relay, _relay_handle) = new_input_relay();
relay.add_touch_device(
DEFAULT_TOUCH_DEVICE_ID,
touch_device.open_files.clone(),
Some(touch_device.inspect_status.clone()),
);
relay.add_keyboard_device(
DEFAULT_KEYBOARD_DEVICE_ID,
keyboard_device.open_files.clone(),
Some(keyboard_device.inspect_status.clone()),
);
relay.add_pending_mouse_device(
kernel.clone(),
mouse_device.clone(),
DEFAULT_MOUSE_DEVICE_ID,
);
relay.start_relays(
&kernel,
StartRelaysArgs {
event_proxy_mode: EventProxyMode::None,
touch_source_client_end,
keyboard_proxy,
mouse_source_client_end,
view_ref: view_ref_pair.view_ref,
registry_proxy: device_registry_proxy,
device_listener_registry: None,
display_width: 700,
display_height: 1200,
},
);
if let Some(Ok(fuiinput::KeyboardRequest::AddListener { responder, .. })) =
keyboard_stream.next().await
{
let _ = responder.send();
}
if let Some(Ok(fuipolicy::DeviceListenerRegistryRequest::RegisterListener {
responder,
..
})) = device_listener_stream.next().await
{
let _ = responder.send();
}
if let Some(Ok(
fuipolicy::DeviceListenerRegistryRequest::RegisterTouchButtonsListener {
responder,
..
},
)) = device_listener_stream.next().await
{
let _ = responder.send();
}
let mouse_dev_id = starnix_uapi::device_id::DeviceId::new(
starnix_uapi::device_id::INPUT_MAJOR,
DEFAULT_MOUSE_DEVICE_ID,
);
let next_dev_id = starnix_uapi::device_id::DeviceId::new(
starnix_uapi::device_id::INPUT_MAJOR,
DEFAULT_MOUSE_DEVICE_ID + 1,
);
// Before any mouse event occurs, the mouse device should not be registered in
// DeviceRegistry.
assert!(
kernel
.device_registry
.list_minor_devices(
starnix_core::device::DeviceMode::Char,
mouse_dev_id..next_dev_id,
)
.is_empty()
);
// Send an empty/no-op mouse event (wheel delta 0) that produces no uapi input_events.
answer_next_mouse_watch_request(
&mut mouse_stream,
vec![make_mouse_wheel_event(0, DEFAULT_MOUSE_DEVICE_ID)],
)
.await;
// Still should not be registered.
assert!(
kernel
.device_registry
.list_minor_devices(
starnix_core::device::DeviceMode::Char,
mouse_dev_id..next_dev_id,
)
.is_empty()
);
// Send a real mouse event (wheel delta 1) to trigger Pending -> Registered, followed by
// a second real mouse event (wheel delta 1) to synchronize the stream and exercise the
// DeviceRegistration::Registered idempotency path.
answer_next_mouse_watch_request(
&mut mouse_stream,
vec![make_mouse_wheel_event(1, DEFAULT_MOUSE_DEVICE_ID)],
)
.await;
answer_next_mouse_watch_request(
&mut mouse_stream,
vec![make_mouse_wheel_event(1, DEFAULT_MOUSE_DEVICE_ID)],
)
.await;
answer_next_mouse_watch_request(
&mut mouse_stream,
vec![make_mouse_wheel_event(0, DEFAULT_MOUSE_DEVICE_ID)],
)
.await;
// The mouse device should now be registered in DeviceRegistry.
let registered = kernel.device_registry.list_minor_devices(
starnix_core::device::DeviceMode::Char,
mouse_dev_id..next_dev_id,
);
assert_eq!(registered.len(), 1);
assert_eq!(registered[0].0, mouse_dev_id);
// Open the mouse device *after* registration (matching production ordering) and verify
// that the converted events from the pre-open batches were buffered and flushed on
// first open (2 wheel events * 2 uapi events [EV_REL, EV_SYN] each = 4 events).
let mouse_file =
mouse_device.open_test(&current_task).expect("Failed to open mouse file");
let events = read_uapi_events(&mouse_file, &current_task);
assert_eq!(events.len(), 4);
})
.await;
}
#[::fuchsia::test]
async fn events_dropped_and_counted_when_no_default_device_registered() {
spawn_kernel_and_run(async move |current_task| {
let kernel = current_task.kernel().clone();
let (touch_source_client_end, mut touch_source_stream) =
fidl::endpoints::create_request_stream::<fuipointer::TouchSourceV2Marker>();
let (mouse_source_client_end, mut mouse_stream) =
fidl::endpoints::create_request_stream::<fuipointer::MouseSourceV2Marker>();
let (keyboard_proxy, mut keyboard_stream) =
fidl::endpoints::create_sync_proxy_and_stream::<
fidl_fuchsia_ui_input3::KeyboardMarker,
>();
let view_ref_pair =
fuchsia_scenic::ViewRefPair::new().expect("Failed to create ViewRefPair");
let (device_registry_proxy, mut device_listener_stream) =
fidl::endpoints::create_sync_proxy_and_stream::<
fuipolicy::DeviceListenerRegistryMarker,
>();
let inspector = fuchsia_inspect::Inspector::default();
let (relay, relay_handle) = new_input_relay();
let relay = relay.with_inspect_node(inspector.root());
relay.start_relays(
&kernel,
StartRelaysArgs {
event_proxy_mode: EventProxyMode::None,
touch_source_client_end,
keyboard_proxy,
mouse_source_client_end,
view_ref: view_ref_pair.view_ref,
registry_proxy: device_registry_proxy,
device_listener_registry: None,
display_width: 0,
display_height: 0,
},
);
let keyboard_listener = match keyboard_stream.next().await {
Some(Ok(fidl_fuchsia_ui_input3::KeyboardRequest::AddListener {
listener,
responder,
..
})) => {
let _ = responder.send();
listener.into_proxy()
}
_ => panic!("Failed to get AddListener event"),
};
let media_buttons_listener = match device_listener_stream.next().await {
Some(Ok(fuipolicy::DeviceListenerRegistryRequest::RegisterListener {
listener,
responder,
})) => {
let _ = responder.send();
listener.into_proxy()
}
_ => panic!("Failed to get RegisterListener event"),
};
let touch_buttons_listener = match device_listener_stream.next().await {
Some(Ok(
fuipolicy::DeviceListenerRegistryRequest::RegisterTouchButtonsListener {
listener,
responder,
},
)) => {
let _ = responder.send();
listener.into_proxy()
}
_ => panic!("Failed to get RegisterTouchButtonsListener event"),
};
const UNREGISTERED_ID: u32 = 42;
// 1. Key event with unregistered ID and no default keyboard device.
let key_event = fidl_fuchsia_ui_input3::KeyEvent {
timestamp: Some(0),
type_: Some(fidl_fuchsia_ui_input3::KeyEventType::Pressed),
key: Some(fidl_fuchsia_input::Key::A),
device_id: Some(UNREGISTERED_ID),
..Default::default()
};
let status = keyboard_listener.on_key_event(&key_event).await.unwrap();
assert_eq!(status, KeyEventStatus::NotHandled);
assert_eq!(relay_handle.num_unregistered_device_events(), 1);
// 2. Media button event with unregistered ID and no default keyboard device.
let media_event = MediaButtonsEvent {
volume: Some(0),
power: Some(true),
device_id: Some(UNREGISTERED_ID),
..Default::default()
};
let _ = media_buttons_listener.on_event(media_event).await;
assert_eq!(relay_handle.num_unregistered_device_events(), 2);
// 3. Touch button event with unregistered ID and no default touch device.
let touch_btn_event = TouchButtonsEvent {
pressed_buttons: Some(vec![TouchButton::Palm]),
device_info: Some(TouchDeviceInfo {
id: Some(UNREGISTERED_ID),
..Default::default()
}),
..Default::default()
};
let _ = touch_buttons_listener.on_event(touch_btn_event).await;
assert_eq!(relay_handle.num_unregistered_device_events(), 3);
// 4. Touch event with unregistered ID and no default touch device.
answer_next_touch_watch_request(
&mut touch_source_stream,
vec![make_touch_event_with_phase_device_id(EventPhase::Add, 1, UNREGISTERED_ID)],
)
.await;
answer_next_touch_watch_request(&mut touch_source_stream, vec![]).await;
assert_eq!(relay_handle.num_unregistered_device_events(), 4);
// 5. Mouse event with unregistered ID and no default mouse device.
answer_next_mouse_watch_request(
&mut mouse_stream,
vec![make_mouse_wheel_event(1, UNREGISTERED_ID)],
)
.await;
assert_eq!(relay_handle.num_unregistered_device_events(), 5);
assert_data_tree!(inspector, root: contains {
input_events_relay: {
num_unregistered_device_events: 5u64,
num_devices: 0u64,
device_listener_registered: false,
}
});
})
.await;
}
#[::fuchsia::test]
fn test_opened_files_state_bounding_and_buffering() {
let mut state = OpenedFilesState::default();
let dummy_event = uapi::input_event {
time: uapi::timeval { tv_sec: 0, tv_usec: 0 },
type_: uapi::EV_KEY as u16,
code: 1,
value: 1,
};
// Dispatch batch that fits within MAX_PRE_OPEN_BUFFERED_EVENTS (1024)
let batch = vec![dummy_event; 1000];
assert!(state.dispatch_events(&batch));
assert_eq!(state.buffered_events.len(), 1000);
// Dispatch a batch that exceeds remaining space (24); entire batch should be dropped
let overflow_batch = vec![dummy_event; 50];
assert!(!state.dispatch_events(&overflow_batch));
assert_eq!(state.buffered_events.len(), 1000);
// Flushing buffered pre-open events into the first opened InputFile via on_file_opened
let inspector = fuchsia_inspect::Inspector::default();
let file1 = Arc::new(InputFile::new_keyboard(
InputDeviceInfo::new(
uapi::input_id { bustype: 0, vendor: 0, product: 0, version: 0 },
"keyboard_1".to_string(),
),
inspector.root(),
));
file1.init_inspect_status();
state.on_file_opened(&file1);
assert_eq!(file1.read_events(2000).len(), 1000);
assert_eq!(
file1
.inspect_status
.as_ref()
.unwrap()
.uapi_events_generated_count
.load(Ordering::Relaxed),
1000
);
// A second opened file should not receive the flushed pre-open events
let file2 = Arc::new(InputFile::new_keyboard(
InputDeviceInfo::new(
uapi::input_id { bustype: 0, vendor: 0, product: 0, version: 0 },
"keyboard_2".to_string(),
),
inspector.root(),
));
file2.init_inspect_status();
state.on_file_opened(&file2);
assert!(file2.read_events(2000).is_empty());
assert_eq!(
file2
.inspect_status
.as_ref()
.unwrap()
.uapi_events_generated_count
.load(Ordering::Relaxed),
0
);
}
#[::fuchsia::test]
fn test_input_device_dispatch_events_and_inspect_counters() {
let inspector = fuchsia_inspect::Inspector::default();
let input_device = InputDevice::new_keyboard(
InputDeviceInfo::new(
uapi::input_id { bustype: 0, vendor: 0, product: 0, version: 0 },
"test_keyboard".to_string(),
),
"test_keyboard",
inspector.root(),
);
// 1. Dispatch events prior to any files being opened (buffered and counted)
let pre_open_event = uapi::input_event {
time: uapi::timeval { tv_sec: 1, tv_usec: 0 },
type_: uapi::EV_KEY as u16,
code: 10,
value: 1,
};
input_device.dispatch_events(&[pre_open_event]);
assert_eq!(
input_device.inspect_status.total_uapi_events_generated_count.load(Ordering::Relaxed),
1
);
// 2. Open first file; receives buffered pre-open event and updates its inspect counter
let _file_ops1 = input_device.open_internal();
let file1 = input_device.open_files.lock()[0].upgrade().expect("file1 upgraded");
assert_eq!(file1.read_events(10).len(), 1);
assert_eq!(
file1
.inspect_status
.as_ref()
.unwrap()
.uapi_events_generated_count
.load(Ordering::Relaxed),
1
);
// 3. Open second file; does NOT receive flushed pre-open event
let _file_ops2 = input_device.open_internal();
let file2 = input_device.open_files.lock()[1].upgrade().expect("file2 upgraded");
assert!(file2.read_events(10).is_empty());
assert_eq!(
file2
.inspect_status
.as_ref()
.unwrap()
.uapi_events_generated_count
.load(Ordering::Relaxed),
0
);
// 4. Dispatch events while files are open; delivers to both files and updates counters
let live_event = uapi::input_event {
time: uapi::timeval { tv_sec: 2, tv_usec: 0 },
type_: uapi::EV_KEY as u16,
code: 20,
value: 1,
};
input_device.dispatch_events(&[live_event]);
assert_eq!(file1.read_events(10).len(), 1);
assert_eq!(file2.read_events(10).len(), 1);
let total_device_events =
input_device.inspect_status.total_uapi_events_generated_count.load(Ordering::Relaxed);
let file1_events = file1
.inspect_status
.as_ref()
.unwrap()
.uapi_events_generated_count
.load(Ordering::Relaxed);
let file2_events = file2
.inspect_status
.as_ref()
.unwrap()
.uapi_events_generated_count
.load(Ordering::Relaxed);
assert_eq!(total_device_events, 2);
assert_eq!(file1_events, 2);
assert_eq!(file2_events, 1);
}
#[::fuchsia::test]
async fn test_direct_input_coordination_suppresses_scenic_events() {
spawn_kernel_and_run(async move |current_task| {
let kernel = current_task.kernel().clone();
let inspector = fuchsia_inspect::Inspector::default();
let touch_device = crate::InputDevice::new_touch(
700,
1200,
crate::InputDeviceInfo::new(TOUCH_INPUT_ID, "starnix_touch".to_string()),
"touch_device",
inspector.root(),
);
let touch_file =
touch_device.open_test(&current_task).expect("Failed to create input file");
let keyboard_device = crate::InputDevice::new_keyboard(
crate::InputDeviceInfo::new(KEYBOARD_INPUT_ID, "starnix_keyboard".to_string()),
"keyboard_device",
inspector.root(),
);
let keyboard_file =
keyboard_device.open_test(&current_task).expect("Failed to create input file");
let mouse_device = crate::InputDevice::new_mouse(
crate::InputDeviceInfo::new(MOUSE_INPUT_ID, "starnix_mouse".to_string()),
"mouse_device",
inspector.root(),
);
let mouse_file =
mouse_device.open_test(&current_task).expect("Failed to create input file");
let (touch_source_client_end, mut touch_source_stream) =
fidl::endpoints::create_request_stream::<fuipointer::TouchSourceV2Marker>();
let (mouse_source_client_end, mut mouse_source_stream) =
fidl::endpoints::create_request_stream::<fuipointer::MouseSourceV2Marker>();
let (keyboard_proxy, mut keyboard_stream) =
fidl::endpoints::create_sync_proxy_and_stream::<
fidl_fuchsia_ui_input3::KeyboardMarker,
>();
let view_ref_pair =
fuchsia_scenic::ViewRefPair::new().expect("Failed to create ViewRefPair");
let (device_registry_proxy, mut device_listener_stream) =
fidl::endpoints::create_sync_proxy_and_stream::<
fuipolicy::DeviceListenerRegistryMarker,
>();
let (mut relay, _relay_handle) = new_input_relay();
relay.add_touch_device(
DEFAULT_TOUCH_DEVICE_ID,
touch_device.open_files.clone(),
Some(touch_device.inspect_status.clone()),
);
relay.add_keyboard_device(
DEFAULT_KEYBOARD_DEVICE_ID,
keyboard_device.open_files.clone(),
Some(keyboard_device.inspect_status.clone()),
);
relay.add_mouse_device(
DEFAULT_MOUSE_DEVICE_ID,
mouse_device.open_files.clone(),
Some(mouse_device.inspect_status.clone()),
);
let direct_input = DirectInputManager::new(Arc::downgrade(&kernel), None, None);
direct_input.set_ownership_active(true);
assert!(direct_input.is_ownership_active());
let relay = relay.with_direct_input_manager(direct_input.clone());
relay.start_relays(
&current_task.kernel(),
StartRelaysArgs {
event_proxy_mode: EventProxyMode::None,
touch_source_client_end,
keyboard_proxy,
mouse_source_client_end,
view_ref: view_ref_pair.view_ref,
registry_proxy: device_registry_proxy,
device_listener_registry: None,
display_width: 700,
display_height: 1200,
},
);
let keyboard_listener = match keyboard_stream.next().await {
Some(Ok(fuiinput::KeyboardRequest::AddListener {
listener, responder, ..
})) => {
let _ = responder.send();
listener.into_proxy()
}
_ => panic!("Failed to get keyboard listener"),
};
if let Some(Ok(fuipolicy::DeviceListenerRegistryRequest::RegisterListener {
responder,
..
})) = device_listener_stream.next().await
{
let _ = responder.send();
}
if let Some(Ok(
fuipolicy::DeviceListenerRegistryRequest::RegisterTouchButtonsListener {
responder,
..
},
)) = device_listener_stream.next().await
{
let _ = responder.send();
}
const DEVICE_ID: u32 = DEFAULT_TOUCH_DEVICE_ID;
let event1 = make_touch_event_with_phase_device_id(EventPhase::Add, 1, DEVICE_ID);
// While direct_input ownership is active, Scenic touch, mouse, and keyboard events must be suppressed
answer_next_touch_watch_request(&mut touch_source_stream, vec![event1]).await;
answer_next_touch_watch_request(
&mut touch_source_stream,
vec![make_empty_touch_event(DEVICE_ID)],
)
.await;
let touch_received = read_uapi_events(&touch_file, &current_task);
assert!(
touch_received.is_empty(),
"Touch events must be suppressed while direct input ownership is active"
);
answer_next_mouse_watch_request(
&mut mouse_source_stream,
vec![make_mouse_wheel_event(1, DEFAULT_MOUSE_DEVICE_ID)],
)
.await;
answer_next_mouse_watch_request(
&mut mouse_source_stream,
vec![make_mouse_wheel_event(0, DEFAULT_MOUSE_DEVICE_ID)],
)
.await;
let mouse_received = read_uapi_events(&mouse_file, &current_task);
assert!(
mouse_received.is_empty(),
"Mouse events must be suppressed while direct input ownership is active"
);
let key_event1 = fuiinput::KeyEvent {
timestamp: Some(10),
type_: Some(fuiinput::KeyEventType::Pressed),
key: Some(fidl_fuchsia_input::Key::A),
device_id: Some(DEFAULT_KEYBOARD_DEVICE_ID),
..Default::default()
};
let status = keyboard_listener.on_key_event(&key_event1).await.unwrap();
assert_eq!(status, KeyEventStatus::NotHandled);
let key_received = read_uapi_events(&keyboard_file, &current_task);
assert!(
key_received.is_empty(),
"Keyboard events must be suppressed while direct input ownership is active"
);
// Pause direct input ownership (e.g. lost ownership to Scenic)
direct_input.pause();
assert!(!direct_input.is_ownership_active());
// Now send Scenic touch, mouse, and keyboard events; they should NOT be suppressed
let event2 = make_touch_event_with_phase_device_id(EventPhase::Add, 2, DEVICE_ID);
answer_next_touch_watch_request(&mut touch_source_stream, vec![event2]).await;
answer_next_touch_watch_request(
&mut touch_source_stream,
vec![make_empty_touch_event(DEVICE_ID)],
)
.await;
let touch_received_after = read_uapi_events(&touch_file, &current_task);
assert!(
!touch_received_after.is_empty(),
"Touch events must be processed after direct input ownership is paused"
);
answer_next_mouse_watch_request(
&mut mouse_source_stream,
vec![make_mouse_wheel_event(1, DEFAULT_MOUSE_DEVICE_ID)],
)
.await;
answer_next_mouse_watch_request(
&mut mouse_source_stream,
vec![make_mouse_wheel_event(0, DEFAULT_MOUSE_DEVICE_ID)],
)
.await;
let mouse_received_after = read_uapi_events(&mouse_file, &current_task);
assert!(
!mouse_received_after.is_empty(),
"Mouse events must be processed after direct input ownership is paused"
);
let key_event2 = fuiinput::KeyEvent {
timestamp: Some(20),
type_: Some(fuiinput::KeyEventType::Pressed),
key: Some(fidl_fuchsia_input::Key::B),
device_id: Some(DEFAULT_KEYBOARD_DEVICE_ID),
..Default::default()
};
let status2 = keyboard_listener.on_key_event(&key_event2).await.unwrap();
assert_eq!(status2, KeyEventStatus::Handled);
let key_received_after = read_uapi_events(&keyboard_file, &current_task);
assert!(
!key_received_after.is_empty(),
"Keyboard events must be processed after direct input ownership is paused"
);
})
.await;
}
#[::fuchsia::test]
async fn test_relay_handoff_flushes_releases() {
spawn_kernel_and_run(async move |current_task| {
let kernel = current_task.kernel().clone();
let inspector = fuchsia_inspect::Inspector::default();
let touch_device = crate::InputDevice::new_touch(
700,
1200,
crate::InputDeviceInfo::new(TOUCH_INPUT_ID, "starnix_touch".to_string()),
"touch_device",
inspector.root(),
);
let touch_file =
touch_device.open_test(&current_task).expect("Failed to create input file");
let keyboard_device = crate::InputDevice::new_keyboard(
crate::InputDeviceInfo::new(KEYBOARD_INPUT_ID, "starnix_keyboard".to_string()),
"keyboard_device",
inspector.root(),
);
let keyboard_file =
keyboard_device.open_test(&current_task).expect("Failed to create input file");
let (touch_source_client_end, mut touch_source_stream) =
fidl::endpoints::create_request_stream::<fuipointer::TouchSourceV2Marker>();
let (mouse_source_client_end, _mouse_source_stream) =
fidl::endpoints::create_request_stream::<fuipointer::MouseSourceV2Marker>();
let (keyboard_proxy, mut keyboard_stream) =
fidl::endpoints::create_sync_proxy_and_stream::<
fidl_fuchsia_ui_input3::KeyboardMarker,
>();
let view_ref_pair =
fuchsia_scenic::ViewRefPair::new().expect("Failed to create ViewRefPair");
let (device_registry_proxy, mut device_listener_stream) =
fidl::endpoints::create_sync_proxy_and_stream::<
fuipolicy::DeviceListenerRegistryMarker,
>();
let (mut relay, _relay_handle) = new_input_relay();
relay.add_touch_device(
DEFAULT_TOUCH_DEVICE_ID,
touch_device.open_files.clone(),
Some(touch_device.inspect_status.clone()),
);
relay.add_keyboard_device(
DEFAULT_KEYBOARD_DEVICE_ID,
keyboard_device.open_files.clone(),
Some(keyboard_device.inspect_status.clone()),
);
let direct_input = DirectInputManager::new(Arc::downgrade(&kernel), None, None);
// Initially direct input ownership is inactive
assert!(!direct_input.is_ownership_active());
let relay = relay.with_direct_input_manager(direct_input.clone());
relay.start_relays(
&current_task.kernel(),
StartRelaysArgs {
event_proxy_mode: EventProxyMode::None,
touch_source_client_end,
keyboard_proxy,
mouse_source_client_end,
view_ref: view_ref_pair.view_ref,
registry_proxy: device_registry_proxy,
device_listener_registry: None,
display_width: 700,
display_height: 1200,
},
);
let keyboard_listener = match keyboard_stream.next().await {
Some(Ok(fuiinput::KeyboardRequest::AddListener {
listener, responder, ..
})) => {
let _ = responder.send();
listener.into_proxy()
}
_ => panic!("Failed to get keyboard listener"),
};
let media_buttons_proxy = match device_listener_stream.next().await {
Some(Ok(fuipolicy::DeviceListenerRegistryRequest::RegisterListener {
listener,
responder,
..
})) => {
let _ = responder.send();
listener.into_proxy()
}
_ => panic!("Failed to get media buttons listener"),
};
let touch_buttons_proxy = match device_listener_stream.next().await {
Some(Ok(
fuipolicy::DeviceListenerRegistryRequest::RegisterTouchButtonsListener {
listener,
responder,
..
},
)) => {
let _ = responder.send();
listener.into_proxy()
}
_ => panic!("Failed to get touch buttons listener"),
};
const DEVICE_ID: u32 = DEFAULT_TOUCH_DEVICE_ID;
// Send touch Add event while Scenic owns input
let event1 = make_touch_event_with_phase_device_id(EventPhase::Add, 1, DEVICE_ID);
answer_next_touch_watch_request(&mut touch_source_stream, vec![event1]).await;
answer_next_touch_watch_request(
&mut touch_source_stream,
vec![make_empty_touch_event(DEVICE_ID)],
)
.await;
let touch_received = read_uapi_events(&touch_file, &current_task);
assert!(
!touch_received.is_empty(),
"Touch events should be received when direct input is inactive"
);
// Verify slot is active (BTN_TOUCH down)
assert!(touch_received.iter().any(|e| e.type_ == uapi::EV_KEY as u16
&& e.code == uapi::BTN_TOUCH as u16
&& e.value == 1));
// Press a keyboard key while Scenic owns input
let key_event1 = fuiinput::KeyEvent {
timestamp: Some(10),
type_: Some(fuiinput::KeyEventType::Pressed),
key: Some(fidl_fuchsia_input::Key::A),
device_id: Some(DEFAULT_KEYBOARD_DEVICE_ID),
..Default::default()
};
let status = keyboard_listener.on_key_event(&key_event1).await.unwrap();
assert_eq!(status, KeyEventStatus::Handled);
let key_received = read_uapi_events(&keyboard_file, &current_task);
assert!(
!key_received.is_empty(),
"Keyboard events should be received when direct input is inactive"
);
assert!(key_received.iter().any(|e| e.type_ == uapi::EV_KEY as u16
&& e.code == uapi::KEY_A as u16
&& e.value == 1));
// Now activate direct input ownership (Scenic -> Direct handoff)
direct_input.set_ownership_active(true);
assert!(direct_input.is_ownership_active());
// Next touch event arrives; handoff transition flushes releases for active touches and keys
let event2 = make_touch_event_with_phase_device_id(EventPhase::Change, 1, DEVICE_ID);
answer_next_touch_watch_request(&mut touch_source_stream, vec![event2]).await;
answer_next_touch_watch_request(
&mut touch_source_stream,
vec![make_empty_touch_event(DEVICE_ID)],
)
.await;
let touch_received_handoff = read_uapi_events(&touch_file, &current_task);
assert!(
!touch_received_handoff.is_empty(),
"Synthetic release events must be flushed on handoff"
);
// Verify lifted tracking ID (-1) and BTN_TOUCH up (0) were flushed
assert!(
touch_received_handoff.iter().any(|e| e.type_ == uapi::EV_ABS as u16
&& e.code == uapi::ABS_MT_TRACKING_ID as u16
&& e.value == -1),
"Expected ABS_MT_TRACKING_ID -1 on handoff"
);
assert!(
touch_received_handoff.iter().any(|e| e.type_ == uapi::EV_KEY as u16
&& e.code == uapi::BTN_TOUCH as u16
&& e.value == 0),
"Expected BTN_TOUCH 0 on handoff"
);
// Verify pressed keyboard key was flushed on handoff
let key_received_handoff = read_uapi_events(&keyboard_file, &current_task);
assert!(
!key_received_handoff.is_empty(),
"Synthetic keyboard release events must be flushed on handoff"
);
assert!(
key_received_handoff.iter().any(|e| e.type_ == uapi::EV_KEY as u16
&& e.code == uapi::KEY_A as u16
&& e.value == 0),
"Expected KEY_A release (0) on handoff"
);
// Verify button listener events during direct ownership receive responses without closing stream
let media_res = media_buttons_proxy
.on_event(MediaButtonsEvent { volume: Some(1), ..Default::default() })
.await;
assert!(
media_res.is_ok(),
"MediaButtons OnEvent must succeed when direct input is active"
);
let touch_btn_res = touch_buttons_proxy
.on_event(TouchButtonsEvent { pressed_buttons: Some(vec![]), ..Default::default() })
.await;
assert!(
touch_btn_res.is_ok(),
"TouchButtons OnEvent must succeed when direct input is active"
);
})
.await;
}
#[::fuchsia::test]
async fn test_relay_switches_between_direct_input_and_app_protocol_via_input_ownership() {
spawn_kernel_and_run(async move |current_task| {
let kernel = current_task.kernel().clone();
let inspector = fuchsia_inspect::Inspector::default();
let touch_device = crate::InputDevice::new_touch(
700,
1200,
crate::InputDeviceInfo::new(TOUCH_INPUT_ID, "starnix_touch".to_string()),
"touch_device",
inspector.root(),
);
let keyboard_device = crate::InputDevice::new_keyboard(
crate::InputDeviceInfo::new(KEYBOARD_INPUT_ID, "starnix_keyboard".to_string()),
"keyboard_device",
inspector.root(),
);
let mouse_device = crate::InputDevice::new_mouse(
crate::InputDeviceInfo::new(MOUSE_INPUT_ID, "starnix_mouse".to_string()),
"mouse_device",
inspector.root(),
);
let touch_file =
touch_device.open_test(&current_task).expect("Failed to create input file");
let keyboard_file =
keyboard_device.open_test(&current_task).expect("Failed to create input file");
let mouse_file =
mouse_device.open_test(&current_task).expect("Failed to create input file");
let (touch_source_client_end, mut touch_source_stream) =
fidl::endpoints::create_request_stream::<fuipointer::TouchSourceV2Marker>();
let (mouse_source_client_end, mut mouse_source_stream) =
fidl::endpoints::create_request_stream::<fuipointer::MouseSourceV2Marker>();
let (keyboard_proxy, mut keyboard_stream) =
fidl::endpoints::create_sync_proxy_and_stream::<
fidl_fuchsia_ui_input3::KeyboardMarker,
>();
let view_ref_pair =
fuchsia_scenic::ViewRefPair::new().expect("Failed to create ViewRefPair");
let (device_registry_proxy, mut device_listener_stream) =
fidl::endpoints::create_sync_proxy_and_stream::<
fuipolicy::DeviceListenerRegistryMarker,
>();
let (mut relay, _relay_handle) = new_input_relay();
relay.add_touch_device(
DEFAULT_TOUCH_DEVICE_ID,
touch_device.open_files.clone(),
Some(touch_device.inspect_status.clone()),
);
relay.add_keyboard_device(
DEFAULT_KEYBOARD_DEVICE_ID,
keyboard_device.open_files.clone(),
Some(keyboard_device.inspect_status.clone()),
);
relay.add_mouse_device(
DEFAULT_MOUSE_DEVICE_ID,
mouse_device.open_files.clone(),
Some(mouse_device.inspect_status.clone()),
);
let event = zx::Event::create();
// Initially, platform owns input
event
.signal(
zx::Signals::NONE,
DISPLAY_PLATFORM_OWNED_SIGNAL | INPUT_PLATFORM_OWNED_SIGNAL,
)
.unwrap();
let (ownership_proxy, get_event_rx, _server_task) = spawn_fake_input_ownership(&event);
let direct_input_view_ref =
fuchsia_scenic::duplicate_view_ref(&view_ref_pair.view_ref).ok();
let direct_input = DirectInputManager::new_with_ownership_proxy(
Arc::downgrade(&kernel),
None,
Some(ownership_proxy),
direct_input_view_ref,
);
let relay = relay.with_direct_input_manager(direct_input.clone());
relay.start_relays(
&current_task.kernel(),
StartRelaysArgs {
event_proxy_mode: EventProxyMode::None,
touch_source_client_end,
keyboard_proxy,
mouse_source_client_end,
view_ref: view_ref_pair.view_ref,
registry_proxy: device_registry_proxy,
device_listener_registry: None,
display_width: 700,
display_height: 1200,
},
);
let keyboard_listener = match keyboard_stream.next().await {
Some(Ok(fuiinput::KeyboardRequest::AddListener {
listener, responder, ..
})) => {
let _ = responder.send();
listener.into_proxy()
}
_ => panic!("Failed to get keyboard listener"),
};
if let Some(Ok(fuipolicy::DeviceListenerRegistryRequest::RegisterListener {
responder,
..
})) = device_listener_stream.next().await
{
let _ = responder.send();
}
if let Some(Ok(
fuipolicy::DeviceListenerRegistryRequest::RegisterTouchButtonsListener {
responder,
..
},
)) = device_listener_stream.next().await
{
let _ = responder.send();
}
// Wait for fake server to handle GetEvent
get_event_rx.await.expect("GetEvent handled by fake server");
// Initially, ownership is inactive (Platform owned)
assert!(!direct_input.is_ownership_active());
// Transition 1: Scenic grants direct input ownership to Starnix
event.signal(INPUT_PLATFORM_OWNED_SIGNAL, INPUT_CLIENT_OWNED_SIGNAL).unwrap();
wait_for_ownership(&direct_input, true).await;
assert!(direct_input.is_ownership_active());
const DEVICE_ID: u32 = DEFAULT_TOUCH_DEVICE_ID;
let event1 = make_touch_event_with_phase_device_id(EventPhase::Add, 1, DEVICE_ID);
// While direct_input ownership is active, Scenic touch, mouse, and keyboard events must be suppressed
answer_next_touch_watch_request(&mut touch_source_stream, vec![event1]).await;
answer_next_touch_watch_request(
&mut touch_source_stream,
vec![make_empty_touch_event(DEVICE_ID)],
)
.await;
let touch_received = read_uapi_events(&touch_file, &current_task);
assert!(
touch_received.is_empty(),
"Touch events must be suppressed while direct input ownership is active"
);
answer_next_mouse_watch_request(
&mut mouse_source_stream,
vec![make_mouse_wheel_event(1, DEFAULT_MOUSE_DEVICE_ID)],
)
.await;
answer_next_mouse_watch_request(
&mut mouse_source_stream,
vec![make_mouse_wheel_event(0, DEFAULT_MOUSE_DEVICE_ID)],
)
.await;
let mouse_received = read_uapi_events(&mouse_file, &current_task);
assert!(
mouse_received.is_empty(),
"Mouse events must be suppressed while direct input ownership is active"
);
let key_event1 = fuiinput::KeyEvent {
timestamp: Some(10),
type_: Some(fuiinput::KeyEventType::Pressed),
key: Some(fidl_fuchsia_input::Key::A),
device_id: Some(DEFAULT_KEYBOARD_DEVICE_ID),
..Default::default()
};
let status = keyboard_listener.on_key_event(&key_event1).await.unwrap();
assert_eq!(status, KeyEventStatus::NotHandled);
let key_received = read_uapi_events(&keyboard_file, &current_task);
assert!(
key_received.is_empty(),
"Keyboard events must be suppressed while direct input ownership is active"
);
// Transition 2: Scenic revokes direct input ownership back to platform
event.signal(INPUT_CLIENT_OWNED_SIGNAL, INPUT_PLATFORM_OWNED_SIGNAL).unwrap();
wait_for_ownership(&direct_input, false).await;
assert!(!direct_input.is_ownership_active());
// Now send Scenic touch, mouse, and keyboard events; they should NOT be suppressed
let event2 = make_touch_event_with_phase_device_id(EventPhase::Add, 2, DEVICE_ID);
answer_next_touch_watch_request(&mut touch_source_stream, vec![event2]).await;
answer_next_touch_watch_request(
&mut touch_source_stream,
vec![make_empty_touch_event(DEVICE_ID)],
)
.await;
let touch_received_after = read_uapi_events(&touch_file, &current_task);
assert!(
!touch_received_after.is_empty(),
"Touch events must be processed after direct input ownership is revoked"
);
answer_next_mouse_watch_request(
&mut mouse_source_stream,
vec![make_mouse_wheel_event(1, DEFAULT_MOUSE_DEVICE_ID)],
)
.await;
answer_next_mouse_watch_request(
&mut mouse_source_stream,
vec![make_mouse_wheel_event(0, DEFAULT_MOUSE_DEVICE_ID)],
)
.await;
let mouse_received_after = read_uapi_events(&mouse_file, &current_task);
assert!(
!mouse_received_after.is_empty(),
"Mouse events must be processed after direct input ownership is revoked"
);
let key_event2 = fuiinput::KeyEvent {
timestamp: Some(20),
type_: Some(fuiinput::KeyEventType::Pressed),
key: Some(fidl_fuchsia_input::Key::B),
device_id: Some(DEFAULT_KEYBOARD_DEVICE_ID),
..Default::default()
};
let status2 = keyboard_listener.on_key_event(&key_event2).await.unwrap();
assert_eq!(status2, KeyEventStatus::Handled);
let key_received_after = read_uapi_events(&keyboard_file, &current_task);
assert!(
!key_received_after.is_empty(),
"Keyboard events must be processed after direct input ownership is revoked"
);
// Bounce direct input ownership to active and immediately back to inactive
// with no Scenic events in between.
event.signal(INPUT_PLATFORM_OWNED_SIGNAL, INPUT_CLIENT_OWNED_SIGNAL).unwrap();
wait_for_ownership(&direct_input, true).await;
event.signal(INPUT_CLIENT_OWNED_SIGNAL, INPUT_PLATFORM_OWNED_SIGNAL).unwrap();
wait_for_ownership(&direct_input, false).await;
// Follow-up Scenic event triggers resume generation change check,
// which flushes synthetic releases for held contacts and keys.
answer_next_touch_watch_request(
&mut touch_source_stream,
vec![make_empty_touch_event(DEVICE_ID)],
)
.await;
let touch_releases = read_uapi_events(&touch_file, &current_task);
assert!(
!touch_releases.is_empty(),
"Synthetic touch releases must be flushed after ownership bounce"
);
assert!(
touch_releases.iter().any(|e| {
e.type_ == uapi::EV_ABS as u16
&& e.code == uapi::ABS_MT_TRACKING_ID as u16
&& e.value == -1
}),
"Expected ABS_MT_TRACKING_ID -1"
);
assert!(
touch_releases.iter().any(|e| {
e.type_ == uapi::EV_KEY as u16
&& e.code == uapi::BTN_TOUCH as u16
&& e.value == 0
}),
"Expected BTN_TOUCH 0"
);
let key_releases = read_uapi_events(&keyboard_file, &current_task);
assert!(
!key_releases.is_empty(),
"Synthetic keyboard releases must be flushed after ownership bounce"
);
assert!(
key_releases.iter().any(|e| {
e.type_ == uapi::EV_KEY as u16 && e.code == uapi::KEY_B as u16 && e.value == 0
}),
"Expected KEY_B 0"
);
})
.await;
}
}