starnix_modules_input/

input_file.rs

// Copyright 2023 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::input_device::InputDeviceInfoHandle;
use crossbeam::queue::SegQueue;
use fuchsia_inspect::Inspector;
use futures::FutureExt;
use starnix_core::fileops_impl_nonseekable;
use starnix_core::mm::{MemoryAccessor, MemoryAccessorExt};
use starnix_core::task::{CurrentTask, EventHandler, WaitCanceler, WaitQueue, Waiter};
use starnix_core::vfs::buffers::{InputBuffer, OutputBuffer};
use starnix_core::vfs::{FileObject, FileOps, fileops_impl_noop_sync};
use starnix_logging::{log_info, track_stub};
use starnix_sync::{InputFileInputFileLock, LockDepMutex};
use starnix_syscalls::{SUCCESS, SyscallArg, SyscallResult};
use starnix_types::time::duration_from_timeval;
use starnix_uapi::errors::Errno;
use starnix_uapi::open_flags::OpenFlags;
use starnix_uapi::user_address::{ArchSpecific, MultiArchUserRef, UserAddress, UserRef};
use starnix_uapi::vfs::FdEvents;
use starnix_uapi::{
    ABS_CNT, ABS_MT_POSITION_X, ABS_MT_POSITION_Y, ABS_MT_PRESSURE, ABS_MT_SLOT,
    ABS_MT_TOUCH_MAJOR, ABS_MT_TOUCH_MINOR, ABS_MT_TRACKING_ID, BTN_EXTRA, BTN_LEFT, BTN_MIDDLE,
    BTN_MISC, BTN_RIGHT, BTN_SIDE, BTN_TOUCH, EV_CNT, FF_CNT, INPUT_PROP_CNT, INPUT_PROP_DIRECT,
    INPUT_PROP_POINTER, KEY_CNT, KEY_DOWN, KEY_LEFT, KEY_OK, KEY_POWER, KEY_RIGHT, KEY_SLEEP,
    KEY_UP, KEY_VOLUMEDOWN, KEY_VOLUMEUP, LED_CNT, MSC_CNT, REL_CNT, REL_HWHEEL, REL_WHEEL, REL_X,
    REL_Y, SW_CNT, errno, error, uapi,
};
use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU64, Ordering};
use std::sync::{Arc, Weak};
use zerocopy::IntoBytes as _; // for `as_bytes()`

uapi::check_arch_independent_layout! {
    input_id {}
    input_absinfo {}
}

type InputEventPtr = MultiArchUserRef<uapi::input_event, uapi::arch32::input_event>;

pub struct InputFileStatus {
    /// The number of FIDL events received by this file from Fuchsia input system.
    ///
    /// We expect:
    /// fidl_events_received_count = fidl_events_ignored_count +
    ///                              fidl_events_unexpected_count +
    ///                              fidl_events_converted_count
    /// otherwise starnix ignored events unexpectedly.
    ///
    /// fidl_events_unexpected_count should be 0, if not it hints issues from upstream of ui stack.
    pub fidl_events_received_count: AtomicU64,

    /// The number of FIDL events ignored to this module’s representation of TouchEvent.
    pub fidl_events_ignored_count: AtomicU64,

    /// The unexpected number of FIDL events reached to this module should be filtered out
    /// earlier in the UI stack.
    /// It maybe unexpected format or unexpected order.
    pub fidl_events_unexpected_count: AtomicU64,

    /// The number of FIDL events converted to this module’s representation of TouchEvent.
    pub fidl_events_converted_count: AtomicU64,

    /// The number of uapi::input_events generated from TouchEvents.
    pub uapi_events_generated_count: AtomicU64,

    /// The event time of the last generated uapi::input_event.
    pub last_generated_uapi_event_timestamp_ns: AtomicI64,

    /// The number of uapi::input_events read from this input file by external process.
    pub uapi_events_read_count: AtomicU64,

    /// The event time of the last uapi::input_event read by external process.
    pub last_read_uapi_event_timestamp_ns: AtomicI64,

    /// Number of read calls.
    pub fd_read_count: AtomicU64,

    /// Number of notify calls.
    pub fd_notify_count: AtomicU64,

    /// Whether the file was opened without the NONBLOCK flag.
    pub opened_without_nonblock: AtomicBool,

    /// The timestamp when the file was opened.
    pub open_timestamp_ns: AtomicI64,

    /// Whether the file was closed (dropped).
    pub closed: AtomicBool,

    /// The timestamp when the file was closed.
    pub close_timestamp_ns: AtomicI64,

    /// The weak pointer to the InputFile.
    pub input_file: LockDepMutex<Weak<InputFile>, InputFileInputFileLock>,
}

impl InputFileStatus {
    fn new(node: &fuchsia_inspect::Node) -> Arc<Self> {
        let status = Arc::new(Self {
            fidl_events_received_count: AtomicU64::new(0),
            fidl_events_ignored_count: AtomicU64::new(0),
            fidl_events_unexpected_count: AtomicU64::new(0),
            fidl_events_converted_count: AtomicU64::new(0),
            uapi_events_generated_count: AtomicU64::new(0),
            last_generated_uapi_event_timestamp_ns: AtomicI64::new(0),
            uapi_events_read_count: AtomicU64::new(0),
            last_read_uapi_event_timestamp_ns: AtomicI64::new(0),
            fd_read_count: AtomicU64::new(0),
            fd_notify_count: AtomicU64::new(0),
            opened_without_nonblock: AtomicBool::new(false),
            open_timestamp_ns: AtomicI64::new(0),
            closed: AtomicBool::new(false),
            close_timestamp_ns: AtomicI64::new(0),
            input_file: Default::default(),
        });

        let cloned_status = status.clone();
        node.record_lazy_values("status", move || {
            let cloned_cloned_status = cloned_status.clone();
            async move {
                let is_dropped = cloned_cloned_status.input_file.lock().upgrade().is_none();
                if is_dropped && !cloned_cloned_status.closed.load(Ordering::Relaxed) {
                    cloned_cloned_status.closed.store(true, Ordering::Relaxed);
                }

                let inspector = Inspector::default();
                let root = inspector.root();
                root.record_uint(
                    "fd_read_count",
                    cloned_cloned_status.fd_read_count.load(Ordering::Relaxed),
                );
                root.record_uint(
                    "fd_notify_count",
                    cloned_cloned_status.fd_notify_count.load(Ordering::Relaxed),
                );
                root.record_bool(
                    "opened_without_nonblock",
                    cloned_cloned_status.opened_without_nonblock.load(Ordering::Relaxed),
                );
                root.record_int(
                    "open_timestamp_ns",
                    cloned_cloned_status.open_timestamp_ns.load(Ordering::Relaxed),
                );
                root.record_bool("closed", cloned_cloned_status.closed.load(Ordering::Relaxed));
                root.record_int(
                    "close_timestamp_ns",
                    cloned_cloned_status.close_timestamp_ns.load(Ordering::Relaxed),
                );
                root.record_uint(
                    "fidl_events_received_count",
                    cloned_cloned_status.fidl_events_received_count.load(Ordering::Relaxed),
                );
                root.record_uint(
                    "fidl_events_ignored_count",
                    cloned_cloned_status.fidl_events_ignored_count.load(Ordering::Relaxed),
                );
                root.record_uint(
                    "fidl_events_unexpected_count",
                    cloned_cloned_status.fidl_events_unexpected_count.load(Ordering::Relaxed),
                );
                root.record_uint(
                    "fidl_events_converted_count",
                    cloned_cloned_status.fidl_events_converted_count.load(Ordering::Relaxed),
                );
                root.record_uint(
                    "uapi_events_generated_count",
                    cloned_cloned_status.uapi_events_generated_count.load(Ordering::Relaxed),
                );
                root.record_int(
                    "last_generated_uapi_event_timestamp_ns",
                    cloned_cloned_status
                        .last_generated_uapi_event_timestamp_ns
                        .load(Ordering::Relaxed),
                );
                root.record_uint(
                    "uapi_events_read_count",
                    cloned_cloned_status.uapi_events_read_count.load(Ordering::Relaxed),
                );
                root.record_int(
                    "last_read_uapi_event_timestamp_ns",
                    cloned_cloned_status.last_read_uapi_event_timestamp_ns.load(Ordering::Relaxed),
                );
                Ok(inspector)
            }
            .boxed()
        });

        status
    }

    pub fn count_received_events(&self, count: u64) {
        self.fidl_events_received_count.fetch_add(count, Ordering::Relaxed);
    }

    pub fn count_ignored_events(&self, count: u64) {
        self.fidl_events_ignored_count.fetch_add(count, Ordering::Relaxed);
    }

    pub fn count_unexpected_events(&self, count: u64) {
        self.fidl_events_unexpected_count.fetch_add(count, Ordering::Relaxed);
    }

    pub fn count_converted_events(&self, count: u64) {
        self.fidl_events_converted_count.fetch_add(count, Ordering::Relaxed);
    }

    pub fn count_generated_events(&self, count: u64, event_time_ns: i64) {
        self.uapi_events_generated_count.fetch_add(count, Ordering::Relaxed);
        self.last_generated_uapi_event_timestamp_ns.store(event_time_ns, Ordering::Relaxed);
    }

    pub fn count_read_events(&self, count: u64, event_time_ns: i64) {
        self.uapi_events_read_count.fetch_add(count, Ordering::Relaxed);
        self.last_read_uapi_event_timestamp_ns.store(event_time_ns, Ordering::Relaxed);
    }

    pub fn count_fd_read_calls(&self) {
        self.fd_read_count.fetch_add(1, Ordering::Relaxed);
    }

    pub fn count_fd_notify_calls(&self) {
        self.fd_notify_count.fetch_add(1, Ordering::Relaxed);
    }

    pub fn set_opened_without_nonblock(&self) {
        self.opened_without_nonblock.store(true, Ordering::Relaxed);
    }

    pub fn set_open_timestamp(&self, timestamp: i64) {
        self.open_timestamp_ns.store(timestamp, Ordering::Relaxed);
    }

    pub fn set_closed(&self) {
        self.closed.store(true, Ordering::Relaxed);
    }

    pub fn set_closed_timestamp(&self, timestamp: i64) {
        self.close_timestamp_ns.store(timestamp, Ordering::Relaxed);
    }
}

pub struct InputFile {
    driver_version: u32,
    info: InputDeviceInfoHandle,
    pub config: InputFileConfig,
    events: SegQueue<LinuxEventWithTraceId>,
    waiters: WaitQueue,
    // InputFile will be initialized with an InputFileStatus that holds Inspect data
    // `None` for Uinput InputFiles
    pub inspect_status: Option<Arc<InputFileStatus>>,
}

pub struct LinuxEventWithTraceId {
    pub event: uapi::input_event,
    pub trace_id: Option<fuchsia_trace::Id>,
}

impl LinuxEventWithTraceId {
    pub fn new(event: uapi::input_event) -> Self {
        match event.type_ as u32 {
            uapi::EV_SYN => {
                let trace_id = fuchsia_trace::Id::new();
                fuchsia_trace::duration!("input", "linux_event_create");
                fuchsia_trace::flow_begin!("input", "linux_event", trace_id);
                LinuxEventWithTraceId { event: event, trace_id: Some(trace_id) }
            }
            // EV_SYN marks the end of a complete input event. Other event types are its properties,
            // so they don't initiate a trace.
            _ => LinuxEventWithTraceId { event: event, trace_id: None },
        }
    }
}

/// Returns the minimum number of bytes required to store `n_bits` bits.
pub const fn min_bytes(n_bits: u32) -> usize {
    ((n_bits as usize) + 7) / 8
}

/// Parses a Fuchsia `Axis` into Linux `uapi::input_absinfo`.
pub fn parse_axis_info(axis: &fidl_fuchsia_input_report::Axis) -> uapi::input_absinfo {
    let minimum = axis.range.min.clamp(i32::MIN as i64, i32::MAX as i64) as i32;
    let maximum = axis.range.max.clamp(i32::MIN as i64, i32::MAX as i64) as i32;
    let resolution = match axis.unit.type_ {
        fidl_fuchsia_input_report::UnitType::Meters => {
            // Linux evdev resolution is in units per mm (10^-3 m).
            // resolution = 10^(-3 - exponent).
            match (-3i32).checked_sub(axis.unit.exponent) {
                Some(p) if (0..=9).contains(&p) => 10i32.pow(p as u32),
                _ => 0,
            }
        }
        _ => 0,
    };
    uapi::input_absinfo { minimum, maximum, resolution, ..Default::default() }
}

/// Dynamic configuration of capabilities and axis ranges for an [`InputFile`].
#[derive(Clone, Debug)]
pub struct InputFileConfig {
    pub supported_event_types: BitSet<{ min_bytes(EV_CNT) }>,
    pub supported_keys: BitSet<{ min_bytes(KEY_CNT) }>,
    pub supported_position_attributes: BitSet<{ min_bytes(ABS_CNT) }>,
    pub supported_motion_attributes: BitSet<{ min_bytes(REL_CNT) }>,
    pub supported_switches: BitSet<{ min_bytes(SW_CNT) }>,
    pub supported_leds: BitSet<{ min_bytes(LED_CNT) }>,
    pub supported_haptics: BitSet<{ min_bytes(FF_CNT) }>,
    pub supported_misc_features: BitSet<{ min_bytes(MSC_CNT) }>,
    pub properties: BitSet<{ min_bytes(INPUT_PROP_CNT) }>,
    pub mt_slot_axis_info: uapi::input_absinfo,
    pub mt_tracking_id_axis_info: uapi::input_absinfo,
    pub mt_pressure_axis_info: uapi::input_absinfo,
    pub mt_touch_major_axis_info: uapi::input_absinfo,
    pub mt_touch_minor_axis_info: uapi::input_absinfo,
    pub x_axis_info: uapi::input_absinfo,
    pub y_axis_info: uapi::input_absinfo,
}

fn absinfo_eq(a: &uapi::input_absinfo, b: &uapi::input_absinfo) -> bool {
    a.value == b.value
        && a.minimum == b.minimum
        && a.maximum == b.maximum
        && a.fuzz == b.fuzz
        && a.flat == b.flat
        && a.resolution == b.resolution
}

impl PartialEq for InputFileConfig {
    fn eq(&self, other: &Self) -> bool {
        self.supported_event_types == other.supported_event_types
            && self.supported_keys == other.supported_keys
            && self.supported_position_attributes == other.supported_position_attributes
            && self.supported_motion_attributes == other.supported_motion_attributes
            && self.supported_switches == other.supported_switches
            && self.supported_leds == other.supported_leds
            && self.supported_haptics == other.supported_haptics
            && self.supported_misc_features == other.supported_misc_features
            && self.properties == other.properties
            && absinfo_eq(&self.mt_slot_axis_info, &other.mt_slot_axis_info)
            && absinfo_eq(&self.mt_tracking_id_axis_info, &other.mt_tracking_id_axis_info)
            && absinfo_eq(&self.mt_pressure_axis_info, &other.mt_pressure_axis_info)
            && absinfo_eq(&self.mt_touch_major_axis_info, &other.mt_touch_major_axis_info)
            && absinfo_eq(&self.mt_touch_minor_axis_info, &other.mt_touch_minor_axis_info)
            && absinfo_eq(&self.x_axis_info, &other.x_axis_info)
            && absinfo_eq(&self.y_axis_info, &other.y_axis_info)
    }
}

impl Default for InputFileConfig {
    fn default() -> Self {
        Self {
            supported_event_types: BitSet::new(),
            supported_keys: BitSet::new(),
            supported_position_attributes: BitSet::new(),
            supported_motion_attributes: BitSet::new(),
            supported_switches: BitSet::new(),
            supported_leds: BitSet::new(),
            supported_haptics: BitSet::new(),
            supported_misc_features: BitSet::new(),
            properties: BitSet::new(),
            mt_slot_axis_info: uapi::input_absinfo::default(),
            mt_tracking_id_axis_info: uapi::input_absinfo::default(),
            mt_pressure_axis_info: uapi::input_absinfo::default(),
            mt_touch_major_axis_info: uapi::input_absinfo::default(),
            mt_touch_minor_axis_info: uapi::input_absinfo::default(),
            x_axis_info: uapi::input_absinfo::default(),
            y_axis_info: uapi::input_absinfo::default(),
        }
    }
}

impl InputFileConfig {
    pub fn from_device_descriptor(
        descriptor: &fidl_fuchsia_input_report::DeviceDescriptor,
    ) -> Self {
        let mut config = Self::default();

        if let Some(touch) = &descriptor.touch {
            config.supported_event_types.set(uapi::EV_ABS);
            config.supported_event_types.set(uapi::EV_KEY);

            let touch_type = touch.input.as_ref().and_then(|i| i.touch_type);
            match touch_type {
                Some(fidl_fuchsia_input_report::TouchType::Touchpad) => {
                    config.properties.set(INPUT_PROP_POINTER);
                    config.supported_keys.set(uapi::BTN_TOOL_FINGER);
                }
                _ => {
                    config.properties.set(INPUT_PROP_DIRECT);
                }
            }

            // Standard touch keys: only BTN_TOUCH unconditionally.
            config.supported_keys.set(BTN_TOUCH);

            // Multitouch and absolute coordinates matching touch_position_attributes().
            config.supported_position_attributes = touch_position_attributes();

            let mut max_contacts = 10;
            if let Some(input) = &touch.input {
                if let Some(contacts) = &input.contacts {
                    if let Some(first) = contacts.first() {
                        if let Some(x) = &first.position_x {
                            config.x_axis_info = parse_axis_info(x);
                        }
                        if let Some(y) = &first.position_y {
                            config.y_axis_info = parse_axis_info(y);
                        }
                        if let Some(pressure) = &first.pressure {
                            config.supported_position_attributes.set(ABS_MT_PRESSURE);
                            config.mt_pressure_axis_info = parse_axis_info(pressure);
                        }
                        match (&first.contact_width, &first.contact_height) {
                            (Some(w), Some(h)) => {
                                config.supported_position_attributes.set(ABS_MT_TOUCH_MAJOR);
                                config.supported_position_attributes.set(ABS_MT_TOUCH_MINOR);
                                if w.range.max >= h.range.max {
                                    config.mt_touch_major_axis_info = parse_axis_info(w);
                                    config.mt_touch_minor_axis_info = parse_axis_info(h);
                                } else {
                                    config.mt_touch_major_axis_info = parse_axis_info(h);
                                    config.mt_touch_minor_axis_info = parse_axis_info(w);
                                }
                            }
                            (Some(w), None) => {
                                config.supported_position_attributes.set(ABS_MT_TOUCH_MAJOR);
                                config.mt_touch_major_axis_info = parse_axis_info(w);
                            }
                            (None, Some(h)) => {
                                config.supported_position_attributes.set(ABS_MT_TOUCH_MAJOR);
                                config.mt_touch_major_axis_info = parse_axis_info(h);
                            }
                            (None, None) => {}
                        }
                    }
                }
                if let Some(contacts_limit) = input.max_contacts {
                    if contacts_limit > 0 {
                        max_contacts = contacts_limit;
                    }
                }
                if let Some(buttons) = &input.buttons {
                    for &button in buttons {
                        if let Some(key) =
                            starnix_modules_input_report_event_conversion::touch_button_to_linux_key(
                                button,
                            )
                        {
                            config.supported_keys.set(key);
                        }
                    }
                }
            }

            config.mt_slot_axis_info = uapi::input_absinfo {
                minimum: 0,
                maximum: i32::try_from(
                    max_contacts
                        .min(fidl_fuchsia_input_report::TOUCH_MAX_CONTACTS)
                        .saturating_sub(1),
                )
                .unwrap_or(i32::MAX),
                ..Default::default()
            };
            config.mt_tracking_id_axis_info =
                uapi::input_absinfo { minimum: 0, maximum: i32::MAX, ..Default::default() };
        }

        if let Some(keyboard) = &descriptor.keyboard {
            config.supported_event_types.set(uapi::EV_KEY);

            let mut has_keys = false;
            if let Some(input) = &keyboard.input {
                if let Some(keys3) = &input.keys3 {
                    for key in keys3 {
                        let keycode = starnix_modules_input_app_event_conversion::keymap::KEY_MAP
                            .fuchsia_input_key_to_linux_keycode(*key);
                        if keycode >= BTN_MISC && keycode < KEY_OK {
                            continue;
                        }
                        if keycode != uapi::KEY_RESERVED && (keycode as usize) < KEY_CNT as usize {
                            config.supported_keys.set(keycode);
                            has_keys = true;
                        }
                    }
                }
            }
            if !has_keys {
                config.supported_keys |= keyboard_key_attributes();
            }

            if let Some(output) = &keyboard.output {
                if let Some(leds) = &output.leds {
                    for led in leds {
                        let led_code = match led {
                            fidl_fuchsia_input_report::LedType::NumLock => Some(uapi::LED_NUML),
                            fidl_fuchsia_input_report::LedType::CapsLock => Some(uapi::LED_CAPSL),
                            fidl_fuchsia_input_report::LedType::ScrollLock => {
                                Some(uapi::LED_SCROLLL)
                            }
                            fidl_fuchsia_input_report::LedType::Compose => Some(uapi::LED_COMPOSE),
                            fidl_fuchsia_input_report::LedType::Kana => Some(uapi::LED_KANA),
                            _ => None,
                        };
                        if let Some(c) = led_code {
                            config.supported_event_types.set(uapi::EV_LED);
                            config.supported_leds.set(c);
                        }
                    }
                }
            }
        }

        if let Some(mouse) = &descriptor.mouse {
            config.supported_event_types.set(uapi::EV_KEY);
            config.supported_event_types.set(uapi::EV_REL);
            if !config.properties.get(INPUT_PROP_DIRECT) {
                config.properties.set(INPUT_PROP_POINTER);
            }

            let mut has_buttons = false;
            let mut has_rel = false;
            if let Some(input) = &mouse.input {
                if let Some(buttons) = &input.buttons {
                    for &button in buttons {
                        if let Some(btn) =
                            starnix_modules_input_report_event_conversion::mouse_button_to_linux_button(
                                button,
                            )
                        {
                            config.supported_keys.set(btn);
                            has_buttons = true;
                        }
                    }
                }
                if input.movement_x.is_some() {
                    config.supported_motion_attributes.set(REL_X);
                    has_rel = true;
                }
                if input.movement_y.is_some() {
                    config.supported_motion_attributes.set(REL_Y);
                    has_rel = true;
                }
                if input.scroll_v.is_some() {
                    config.supported_motion_attributes.set(REL_WHEEL);
                    has_rel = true;
                }
                if input.scroll_h.is_some() {
                    config.supported_motion_attributes.set(REL_HWHEEL);
                    has_rel = true;
                }
                if input.scroll_v.is_some() || input.scroll_h.is_some() {
                    config.supported_motion_attributes.set(REL_X);
                    config.supported_motion_attributes.set(REL_Y);
                }
            }

            if !has_buttons {
                config.supported_keys |= mouse_key_attributes();
            }

            if !has_rel {
                config.supported_motion_attributes |= mouse_motion_attributes();
            }
        }

        if let Some(consumer_control) = &descriptor.consumer_control {
            config.supported_event_types.set(uapi::EV_KEY);
            let mut has_buttons = false;
            if let Some(input) = &consumer_control.input {
                if let Some(buttons) = &input.buttons {
                    for button in buttons {
                        if let Some(key) =
                            starnix_modules_input_report_event_conversion::consumer_control_button_to_linux_key(
                                *button,
                            )
                        {
                            config.supported_keys.set(key);
                            has_buttons = true;
                        }
                    }
                }
            }
            if !has_buttons {
                config.supported_keys.set(KEY_POWER);
                config.supported_keys.set(KEY_VOLUMEUP);
                config.supported_keys.set(KEY_VOLUMEDOWN);
            }
        }

        config
    }
}

/// Returns appropriate `INPUT_PROP`-erties for a keyboard device.
fn keyboard_properties() -> BitSet<{ min_bytes(INPUT_PROP_CNT) }> {
    let mut attrs = BitSet::new();
    attrs.set(INPUT_PROP_DIRECT);
    attrs
}

/// Returns appropriate `KEY`-board related flags for a touchscreen device.
fn touch_key_attributes() -> BitSet<{ min_bytes(KEY_CNT) }> {
    let mut attrs = BitSet::new();
    attrs.set(BTN_TOUCH);
    attrs.set(BTN_MISC); // Include BTN_MISC as a catchall key event.
    attrs.set(KEY_SLEEP);
    attrs.set(KEY_UP);
    attrs.set(KEY_LEFT);
    attrs.set(KEY_RIGHT);
    attrs.set(KEY_DOWN);

    attrs
}

/// Returns appropriate `ABS`-olute position related flags for a touchscreen device.
fn touch_position_attributes() -> BitSet<{ min_bytes(ABS_CNT) }> {
    let mut attrs = BitSet::new();
    attrs.set(ABS_MT_SLOT);
    attrs.set(ABS_MT_TRACKING_ID);
    attrs.set(ABS_MT_POSITION_X);
    attrs.set(ABS_MT_POSITION_Y);
    attrs
}

/// Returns appropriate `INPUT_PROP`-erties for a touchscreen device.
fn touch_properties() -> BitSet<{ min_bytes(INPUT_PROP_CNT) }> {
    let mut attrs = BitSet::new();
    attrs.set(INPUT_PROP_DIRECT);
    attrs
}

/// Returns appropriate `KEY`-board related flags for a keyboard device.
fn keyboard_key_attributes() -> BitSet<{ min_bytes(KEY_CNT) }> {
    let mut attrs = BitSet::new();
    for keycode in starnix_modules_input_app_event_conversion::keymap::KEY_MAP.all_linux_keycodes()
    {
        // `KEY_MAP` also carries a block of test-only keycodes (see b/311425670), 31 of which
        // fall in the `BTN_*` range. Advertising those would make evdev clients classify this
        // device as a gamepad in addition to a keyboard, which is the opposite of what this
        // capability list is for. No real `KEY_*` constant lives in `BTN_MISC..KEY_OK`.
        if keycode >= BTN_MISC && keycode < KEY_OK {
            continue;
        }
        if (keycode as usize) < KEY_CNT as usize {
            attrs.set(keycode);
        }
    }
    attrs.set(BTN_MISC);
    attrs.set(KEY_POWER);
    attrs.set(KEY_VOLUMEUP);
    attrs.set(KEY_VOLUMEDOWN);
    attrs
}

/// Returns appropriate `ABS`-olute position related flags for a keyboard device.
fn keyboard_position_attributes() -> BitSet<{ min_bytes(ABS_CNT) }> {
    BitSet::new()
}

/// Returns appropriate `KEY`-board/button related flags for a mouse device.
fn mouse_key_attributes() -> BitSet<{ min_bytes(KEY_CNT) }> {
    let mut attrs = BitSet::new();
    // In Linux UAPI, BTN_LEFT has the numeric value 0x110, which is also aliased to BTN_MOUSE.
    // Evdev and libevdev treat BTN_MOUSE as the primary indicator that a device is a mouse:
    // https://cs.opensource.google/fuchsia/fuchsia/+/main:third_party/android/platform/external/libevdev/libevdev/libevdev.c;l=1134-1140;drc=7007dd6442654da8be96df23cf632ae0e87d7b30
    attrs.set(BTN_LEFT);
    attrs.set(BTN_RIGHT);
    attrs.set(BTN_MIDDLE);
    attrs.set(BTN_SIDE);
    attrs.set(BTN_EXTRA);
    attrs
}

/// Returns appropriate `REL`-ative motion related flags for a mouse device.
fn mouse_motion_attributes() -> BitSet<{ min_bytes(REL_CNT) }> {
    let mut attrs = BitSet::new();
    attrs.set(REL_X);
    attrs.set(REL_Y);
    attrs.set(REL_WHEEL);
    attrs.set(REL_HWHEEL);
    attrs
}

/// Returns appropriate `INPUT_PROP`-erties for a mouse device.
fn mouse_properties() -> BitSet<{ min_bytes(INPUT_PROP_CNT) }> {
    let mut attrs = BitSet::new();
    // INPUT_PROP_POINTER indicates a mouse/pointer device.
    // INPUT_PROP_DIRECT is for direct touchscreens and must NOT be set for a mouse.
    attrs.set(INPUT_PROP_POINTER);
    attrs
}

impl InputFile {
    // Per https://www.linuxjournal.com/article/6429, the driver version is 32-bits wide,
    // and interpreted as:
    // * [31-16]: version
    // * [15-08]: minor
    // * [07-00]: patch level
    const DRIVER_VERSION: u32 = 0;

    /// Creates an `InputFile` instance suitable for emulating a touchscreen.
    ///
    /// # Parameters
    /// - `info`: input device information.
    /// - `width`: width of screen.
    /// - `height`: height of screen.
    /// - `node`: The inspect node for the parent device of "touch_input_file".
    pub fn new_touch(
        info: InputDeviceInfoHandle,
        width: i32,
        height: i32,
        node: &fuchsia_inspect::Node,
    ) -> Self {
        // Fuchsia scales the position reported by the touch sensor to fit view coordinates.
        // Hence, the range of touch positions is exactly the same as the range of view
        // coordinates.
        let config = InputFileConfig {
            supported_event_types: BitSet::list([uapi::EV_ABS]),
            supported_keys: touch_key_attributes(),
            supported_position_attributes: touch_position_attributes(),
            properties: touch_properties(),
            mt_slot_axis_info: uapi::input_absinfo {
                minimum: 0,
                maximum: 10,
                ..uapi::input_absinfo::default()
            },
            mt_tracking_id_axis_info: uapi::input_absinfo {
                minimum: 0,
                maximum: i32::MAX,
                ..uapi::input_absinfo::default()
            },
            x_axis_info: uapi::input_absinfo {
                minimum: 0,
                maximum: i32::from(width),
                // TODO(https://fxbug.dev/42075436): `value` field should contain the most recent
                // X position.
                ..uapi::input_absinfo::default()
            },
            y_axis_info: uapi::input_absinfo {
                minimum: 0,
                maximum: i32::from(height),
                // TODO(https://fxbug.dev/42075436): `value` field should contain the most recent
                // Y position.
                ..uapi::input_absinfo::default()
            },
            ..Default::default()
        };
        Self::new_from_config(info, config, node)
    }

    /// Creates an `InputFile` instance suitable for emulating a keyboard.
    ///
    /// # Parameters
    /// - `info`: input device information.
    /// - `node`: The inspect node for the parent device of "keyboard_input_file".
    pub fn new_keyboard(info: InputDeviceInfoHandle, node: &fuchsia_inspect::Node) -> Self {
        let config = InputFileConfig {
            supported_event_types: BitSet::list([uapi::EV_KEY]),
            supported_keys: keyboard_key_attributes(),
            supported_position_attributes: keyboard_position_attributes(),
            properties: keyboard_properties(),
            ..Default::default()
        };
        Self::new_from_config(info, config, node)
    }

    /// Creates an `InputFile` instance suitable for emulating a mouse.
    ///
    /// # Parameters
    /// - `info`: input device information.
    /// - `node`: The inspect node for the parent device of "mouse_input_file".
    pub fn new_mouse(info: InputDeviceInfoHandle, node: &fuchsia_inspect::Node) -> Self {
        let config = InputFileConfig {
            // Mice report relative motion via EV_REL and buttons via EV_KEY.
            // Absolute motion (EV_ABS) is not supported to avoid misclassification
            // as a touch digitizer by libinput/Android EventHub.
            supported_event_types: BitSet::list([uapi::EV_KEY, uapi::EV_REL]),
            supported_keys: mouse_key_attributes(),
            supported_motion_attributes: mouse_motion_attributes(),
            properties: mouse_properties(),
            ..Default::default()
        };
        Self::new_from_config(info, config, node)
    }

    /// Creates an `InputFile` instance from a pre-configured [`InputFileConfig`].
    pub fn new_from_config(
        info: InputDeviceInfoHandle,
        config: InputFileConfig,
        node: &fuchsia_inspect::Node,
    ) -> Self {
        Self {
            driver_version: Self::DRIVER_VERSION,
            info,
            config,
            events: SegQueue::new(),
            waiters: WaitQueue::default(),
            inspect_status: Some(InputFileStatus::new(node)),
        }
    }

    /// Creates an `InputFile` instance by parsing a Fuchsia [`fidl_fuchsia_input_report::DeviceDescriptor`].
    #[cfg(test)]
    pub fn from_device_descriptor(
        info: InputDeviceInfoHandle,
        descriptor: &fidl_fuchsia_input_report::DeviceDescriptor,
        node: &fuchsia_inspect::Node,
    ) -> Self {
        let config = InputFileConfig::from_device_descriptor(descriptor);
        Self::new_from_config(info, config, node)
    }

    pub fn init_inspect_status(self: &Arc<Self>) {
        if let Some(inspect) = &self.inspect_status {
            *inspect.input_file.lock() = Arc::downgrade(self);
        }
    }

    pub fn add_events(&self, events: Vec<uapi::input_event>) {
        if events.is_empty() {
            return;
        }
        if let Some(inspect) = &self.inspect_status {
            inspect.count_fd_notify_calls();
        }
        for event in events {
            self.events.push(LinuxEventWithTraceId::new(event));
        }
        self.waiters.notify_fd_events(FdEvents::POLLIN);
    }

    pub fn read_events(&self, limit: usize) -> Vec<LinuxEventWithTraceId> {
        if let Some(inspect) = &self.inspect_status {
            inspect.count_fd_read_calls();
        }
        let mut events = vec![];
        for _ in 0..limit {
            if let Some(event) = self.events.pop() {
                events.push(event);
            } else {
                break;
            }
        }
        // We do not notify if the buffer was not enough to read all events.
        // `query_events` will still return `FdEvents::POLLIN` if there are remaining events,
        // so the caller can continue reading or poll again.
        events
    }
}

// Remove the variable part of the request with params, so we can identify it.
// Lowest 14 bits of the top 16 bits encode the buffer length in bytes.
// See https://cs.opensource.google/fuchsia/fuchsia/+/main:third_party/android/platform/bionic/libc/kernel/uapi/linux/input.h;l=82;drc=0f0c18f695543b15b852f68f297744d03d642a26
pub(crate) const EVIOC_VAR_LEN_MASK: u32 = !(uapi::_IOC_SIZEMASK << uapi::_IOC_SIZESHIFT);

pub(crate) const EVIOCGNAME_BASE: u32 = uapi::EVIOCGNAME_0 & EVIOC_VAR_LEN_MASK;
pub(crate) const EVIOCGPHYS_BASE: u32 = uapi::EVIOCGPHYS_0 & EVIOC_VAR_LEN_MASK;
pub(crate) const EVIOCGUNIQ_BASE: u32 = uapi::EVIOCGUNIQ_0 & EVIOC_VAR_LEN_MASK;
pub(crate) const EVIOCGKEY_BASE: u32 = uapi::EVIOCGKEY_0 & EVIOC_VAR_LEN_MASK;
pub(crate) const EVIOCGLED_BASE: u32 = uapi::EVIOCGLED_0 & EVIOC_VAR_LEN_MASK;
pub(crate) const EVIOCGSND_BASE: u32 = uapi::EVIOCGSND_0 & EVIOC_VAR_LEN_MASK;
pub(crate) const EVIOCGSW_BASE: u32 = uapi::EVIOCGSW_0 & EVIOC_VAR_LEN_MASK;
pub(crate) const EVIOCGPROP_BASE: u32 = uapi::EVIOCGPROP & EVIOC_VAR_LEN_MASK;
pub(crate) const EVIOCGBIT_0_BASE: u32 = uapi::EVIOCGBIT_0 & EVIOC_VAR_LEN_MASK;
pub(crate) const EVIOCGBIT_EV_KEY_BASE: u32 = uapi::EVIOCGBIT_EV_KEY & EVIOC_VAR_LEN_MASK;
pub(crate) const EVIOCGBIT_EV_ABS_BASE: u32 = uapi::EVIOCGBIT_EV_ABS & EVIOC_VAR_LEN_MASK;
pub(crate) const EVIOCGBIT_EV_REL_BASE: u32 = uapi::EVIOCGBIT_EV_REL & EVIOC_VAR_LEN_MASK;
pub(crate) const EVIOCGBIT_EV_SW_BASE: u32 = uapi::EVIOCGBIT_EV_SW & EVIOC_VAR_LEN_MASK;
pub(crate) const EVIOCGBIT_EV_LED_BASE: u32 = uapi::EVIOCGBIT_EV_LED & EVIOC_VAR_LEN_MASK;
pub(crate) const EVIOCGBIT_EV_FF_BASE: u32 = uapi::EVIOCGBIT_EV_FF & EVIOC_VAR_LEN_MASK;
pub(crate) const EVIOCGBIT_EV_MSC_BASE: u32 = uapi::EVIOCGBIT_EV_MSC & EVIOC_VAR_LEN_MASK;
pub(crate) const EVIOCGBIT_EV_SND_BASE: u32 = uapi::EVIOCGBIT_EV_SND & EVIOC_VAR_LEN_MASK;

pub(crate) const fn eviocgabs(axis: u32) -> u32 {
    uapi::EVIOCGABS_X + axis
}
pub(crate) const EVIOCGABS_MT_PRESSURE: u32 = eviocgabs(uapi::ABS_MT_PRESSURE);
pub(crate) const EVIOCGABS_MT_TOUCH_MAJOR: u32 = eviocgabs(uapi::ABS_MT_TOUCH_MAJOR);
pub(crate) const EVIOCGABS_MT_TOUCH_MINOR: u32 = eviocgabs(uapi::ABS_MT_TOUCH_MINOR);

impl FileOps for InputFile {
    fileops_impl_nonseekable!();
    fileops_impl_noop_sync!();

    fn open(&self, file: &FileObject, _current_task: &CurrentTask) -> Result<(), Errno> {
        if let Some(inspect) = &self.inspect_status {
            inspect.set_open_timestamp(zx::MonotonicInstant::get().into_nanos());
            if (file.flags() & OpenFlags::NONBLOCK) != OpenFlags::NONBLOCK {
                inspect.set_opened_without_nonblock();
            }
        }
        Ok(())
    }

    fn close(
        self: Box<Self>,
        _file: &starnix_core::vfs::FileObjectState,
        _current_task: &CurrentTask,
    ) {
        if let Some(inspect) = &self.inspect_status {
            inspect.set_closed();
            inspect.set_closed_timestamp(zx::MonotonicInstant::get().into_nanos());
        }
    }

    fn ioctl(
        &self,
        _file: &FileObject,
        current_task: &CurrentTask,
        request: u32,
        arg: SyscallArg,
    ) -> Result<SyscallResult, Errno> {
        let user_addr = UserAddress::from(arg);
        match request {
            uapi::EVIOCGVERSION => {
                current_task.write_object(UserRef::new(user_addr), &self.driver_version)?;
                Ok(SUCCESS)
            }
            uapi::EVIOCGID => {
                let input_id = self.info.lock().input_id;
                current_task.write_object(UserRef::new(user_addr), &input_id)?;
                Ok(SUCCESS)
            }
            uapi::EVIOCGABS_MT_SLOT => {
                current_task
                    .write_object(UserRef::new(user_addr), &self.config.mt_slot_axis_info)?;
                Ok(SUCCESS)
            }
            uapi::EVIOCGABS_MT_TRACKING_ID => {
                current_task
                    .write_object(UserRef::new(user_addr), &self.config.mt_tracking_id_axis_info)?;
                Ok(SUCCESS)
            }
            uapi::EVIOCGABS_X | uapi::EVIOCGABS_MT_POSITION_X => {
                current_task.write_object(UserRef::new(user_addr), &self.config.x_axis_info)?;
                Ok(SUCCESS)
            }
            uapi::EVIOCGABS_Y | uapi::EVIOCGABS_MT_POSITION_Y => {
                current_task.write_object(UserRef::new(user_addr), &self.config.y_axis_info)?;
                Ok(SUCCESS)
            }
            EVIOCGABS_MT_PRESSURE => {
                current_task
                    .write_object(UserRef::new(user_addr), &self.config.mt_pressure_axis_info)?;
                Ok(SUCCESS)
            }
            EVIOCGABS_MT_TOUCH_MAJOR => {
                current_task
                    .write_object(UserRef::new(user_addr), &self.config.mt_touch_major_axis_info)?;
                Ok(SUCCESS)
            }
            EVIOCGABS_MT_TOUCH_MINOR => {
                current_task
                    .write_object(UserRef::new(user_addr), &self.config.mt_touch_minor_axis_info)?;
                Ok(SUCCESS)
            }
            uapi::EVIOCGRAB => {
                // Xorg and libevdev use EVIOCGRAB to obtain exclusive access to the device.
                track_stub!(TODO("https://fxbug.dev/322873200"), "EVIOCGRAB");
                Ok(SUCCESS)
            }

            request_with_params => {
                // The lowest 14 bits of the top 16 bits are the unsigned buffer length in bytes.
                let buffer_bytes_count =
                    ((request_with_params >> uapi::_IOC_SIZESHIFT) & uapi::_IOC_SIZEMASK) as usize;

                let dir = (request_with_params >> uapi::_IOC_DIRSHIFT) & uapi::_IOC_DIRMASK;
                let ioc_type = (request_with_params >> uapi::_IOC_TYPESHIFT) & uapi::_IOC_TYPEMASK;

                // Validate that this is an evdev read ioctl ('E').
                if dir != uapi::_IOC_READ || ioc_type != (b'E' as u32) {
                    track_stub!(
                        TODO("https://fxbug.dev/322873200"),
                        "input ioctl invalid type or dir",
                        request_with_params
                    );
                    return error!(EINVAL);
                }

                // Helper to copy a bitset slice to user memory.
                // Note: Linux evdev's bits_to_user returns the number of bytes copied, whereas
                // existing Starnix ioctl handlers and tests expect 0 (SUCCESS).
                let write_bits = |bits: &[u8]| -> Result<SyscallResult, Errno> {
                    if buffer_bytes_count == 0 {
                        return Ok(SUCCESS);
                    }
                    // Zero out the entire user buffer in case the user reads too much.
                    if current_task.zero(user_addr, buffer_bytes_count)? != buffer_bytes_count {
                        return error!(EFAULT);
                    }
                    let to_copy = std::cmp::min(bits.len(), buffer_bytes_count);
                    current_task.write_memory(user_addr, &bits[..to_copy])?;
                    Ok(SUCCESS)
                };

                // Helper to copy a NUL-terminated string to user memory and return bytes written
                // including the trailing NUL.
                let write_string = |bytes: &[u8]| -> Result<SyscallResult, Errno> {
                    if buffer_bytes_count == 0 {
                        return Ok(SUCCESS);
                    }
                    // Zero out the entire user buffer in case the user reads too much.
                    if current_task.zero(user_addr, buffer_bytes_count)? != buffer_bytes_count {
                        return error!(EFAULT);
                    }
                    let to_copy = std::cmp::min(bytes.len(), buffer_bytes_count.saturating_sub(1));
                    current_task.write_memory(user_addr, &bytes[..to_copy])?;
                    // String queries (EVIOCGNAME, EVIOCGPHYS) return the number of bytes written,
                    // including the trailing NUL.
                    Ok((to_copy + 1).into())
                };

                match request_with_params & EVIOC_VAR_LEN_MASK {
                    EVIOCGBIT_0_BASE => write_bits(&self.config.supported_event_types.bytes),
                    EVIOCGBIT_EV_KEY_BASE => write_bits(&self.config.supported_keys.bytes),
                    EVIOCGBIT_EV_ABS_BASE => {
                        write_bits(&self.config.supported_position_attributes.bytes)
                    }
                    EVIOCGBIT_EV_REL_BASE => {
                        write_bits(&self.config.supported_motion_attributes.bytes)
                    }
                    EVIOCGBIT_EV_SW_BASE => write_bits(&self.config.supported_switches.bytes),
                    EVIOCGBIT_EV_LED_BASE => write_bits(&self.config.supported_leds.bytes),
                    EVIOCGBIT_EV_FF_BASE => write_bits(&self.config.supported_haptics.bytes),
                    EVIOCGBIT_EV_MSC_BASE => write_bits(&self.config.supported_misc_features.bytes),
                    EVIOCGBIT_EV_SND_BASE => write_bits(&[]),
                    EVIOCGPROP_BASE => write_bits(&self.config.properties.bytes),
                    EVIOCGNAME_BASE => {
                        let name = self.info.lock().name.clone();
                        write_string(name.as_bytes())
                    }
                    EVIOCGPHYS_BASE => {
                        let phys = format!("starnix/{}", self.info.lock().name);
                        write_string(phys.as_bytes())
                    }
                    EVIOCGUNIQ_BASE => {
                        // Starnix synthetic devices do not have a unique identifier (serial/MAC).
                        // Linux returns -ENOENT when no uniq string is set.
                        error!(ENOENT)
                    }
                    EVIOCGKEY_BASE | EVIOCGLED_BASE | EVIOCGSND_BASE | EVIOCGSW_BASE => {
                        // Current-state queries: which keys are held down, which LEDs are
                        // lit, which sounds are playing, and which switches are toggled.
                        // These are distinct from the EVIOCGBIT capability queries above,
                        // which report what the device *can* do rather than what it is
                        // doing right now.
                        //
                        // Starnix does not track any of this per-device state, so report
                        // all-zeros: nothing held, lit, playing, or toggled. That is an
                        // honest answer for these devices rather than a fabrication, but
                        // it is still an approximation, hence the stub.
                        //
                        // These must not fall through to EINVAL. `xf86-input-evdev` issues
                        // all four unconditionally during PreInit and treats any failure as
                        // fatal, so returning an error here prevents X11 from bringing up
                        // the keyboard, mouse, and touchscreen entirely.
                        track_stub!(
                            TODO("https://fxbug.dev/322873200"),
                            "evdev current-state query",
                            request_with_params
                        );
                        write_bits(&[])
                    }
                    _ => {
                        track_stub!(
                            TODO("https://fxbug.dev/322873200"),
                            "input ioctl",
                            request_with_params
                        );
                        error!(EINVAL)
                    }
                }
            }
        }
    }

    fn read(
        &self,
        _file: &FileObject,
        current_task: &CurrentTask,
        offset: usize,
        data: &mut dyn OutputBuffer,
    ) -> Result<usize, Errno> {
        fuchsia_trace::duration!("input", "InputFile::read");
        debug_assert!(offset == 0);
        let input_event_size = InputEventPtr::size_of_object_for(current_task);

        // The limit of the buffer is determined by taking the available bytes
        // and using integer division on the size of uapi::input_event in bytes.
        let limit = data.available() / input_event_size;
        let events = self.read_events(limit);
        if events.is_empty() {
            // Returns `EAGAIN` for file is opened with or without `O_NONBLOCK`.
            log_info!("read() returning EAGAIN");
            return error!(EAGAIN);
        }

        let last_event_timeval = events.last().expect("events is nonempty").event.time;
        let last_event_time_ns = duration_from_timeval::<zx::MonotonicTimeline>(last_event_timeval)
            .unwrap()
            .into_nanos();
        self.inspect_status
            .clone()
            .map(|status| status.count_read_events(events.len() as u64, last_event_time_ns));

        for event in &events {
            if let Some(trace_id) = event.trace_id {
                fuchsia_trace::duration!("input", "linux_event_read");
                fuchsia_trace::flow_end!("input", "linux_event", trace_id);
            }
        }

        if current_task.is_arch32() {
            let events: Result<Vec<uapi::arch32::input_event>, _> =
                events.iter().map(|e| uapi::arch32::input_event::try_from(e.event)).collect();
            let events = events.map_err(|_| errno!(EINVAL))?;
            data.write_all(events.as_bytes())
        } else {
            let events: Vec<uapi::input_event> = events.iter().map(|e| e.event).collect();
            data.write_all(events.as_bytes())
        }
    }

    fn write(
        &self,
        _file: &FileObject,
        _current_task: &CurrentTask,
        offset: usize,
        _data: &mut dyn InputBuffer,
    ) -> Result<usize, Errno> {
        debug_assert!(offset == 0);
        track_stub!(TODO("https://fxbug.dev/322874385"), "write() on input device");
        error!(EOPNOTSUPP)
    }

    fn wait_async(
        &self,
        _file: &FileObject,
        _current_task: &CurrentTask,
        waiter: &Waiter,
        events: FdEvents,
        handler: EventHandler,
    ) -> Option<WaitCanceler> {
        Some(self.waiters.wait_async_fd_events(waiter, events, handler))
    }

    fn query_events(
        &self,
        _file: &FileObject,
        _current_task: &CurrentTask,
    ) -> Result<FdEvents, Errno> {
        Ok(if self.events.is_empty() { FdEvents::empty() } else { FdEvents::POLLIN })
    }
}

pub struct ArcInputFile(pub Arc<InputFile>);

impl FileOps for ArcInputFile {
    fileops_impl_nonseekable!();
    fileops_impl_noop_sync!();

    fn open(&self, file: &FileObject, current_task: &CurrentTask) -> Result<(), Errno> {
        self.0.as_ref().open(file, current_task)
    }

    fn close(
        self: Box<Self>,
        _file: &starnix_core::vfs::FileObjectState,
        _current_task: &CurrentTask,
    ) {
        let arc_file = *self;
        if let Some(inspect) = &arc_file.0.inspect_status {
            inspect.set_closed();
            inspect.set_closed_timestamp(zx::MonotonicInstant::get().into_nanos());
        }
    }

    fn ioctl(
        &self,
        file: &FileObject,
        current_task: &CurrentTask,
        request: u32,
        arg: SyscallArg,
    ) -> Result<SyscallResult, Errno> {
        self.0.as_ref().ioctl(file, current_task, request, arg)
    }

    fn read(
        &self,
        file: &FileObject,
        current_task: &CurrentTask,
        offset: usize,
        data: &mut dyn OutputBuffer,
    ) -> Result<usize, Errno> {
        self.0.as_ref().read(file, current_task, offset, data)
    }

    fn write(
        &self,
        file: &FileObject,
        current_task: &CurrentTask,
        offset: usize,
        data: &mut dyn InputBuffer,
    ) -> Result<usize, Errno> {
        self.0.as_ref().write(file, current_task, offset, data)
    }

    fn wait_async(
        &self,
        file: &FileObject,
        current_task: &CurrentTask,
        waiter: &Waiter,
        events: FdEvents,
        handler: EventHandler,
    ) -> Option<WaitCanceler> {
        self.0.as_ref().wait_async(file, current_task, waiter, events, handler)
    }

    fn query_events(
        &self,
        file: &FileObject,
        current_task: &CurrentTask,
    ) -> Result<FdEvents, Errno> {
        self.0.as_ref().query_events(file, current_task)
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct BitSet<const NUM_BYTES: usize> {
    bytes: [u8; NUM_BYTES],
}

impl<const NUM_BYTES: usize> BitSet<{ NUM_BYTES }> {
    pub const fn new() -> Self {
        Self { bytes: [0; NUM_BYTES] }
    }

    pub const fn list<const N: usize>(bits: [u32; N]) -> Self {
        let mut bitset = Self::new();
        let mut i = 0;
        while i < bits.len() {
            bitset.set(bits[i]);
            i += 1;
        }
        bitset
    }

    pub const fn set(&mut self, bitnum: u32) {
        let bitnum = bitnum as usize;
        let byte = bitnum / 8;
        let bit = bitnum % 8;
        self.bytes[byte] |= 1 << bit;
    }

    pub fn get(&self, bitnum: u32) -> bool {
        let bitnum = bitnum as usize;
        let byte = bitnum / 8;
        let bit = bitnum % 8;
        (self.bytes[byte] & (1 << bit)) != 0
    }
}

impl<const NUM_BYTES: usize> std::ops::BitOrAssign for BitSet<{ NUM_BYTES }> {
    fn bitor_assign(&mut self, rhs: Self) {
        for i in 0..NUM_BYTES {
            self.bytes[i] |= rhs.bytes[i];
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::input_device::InputDeviceInfo;
    use std::sync::atomic::Ordering;

    #[test]
    fn test_keyboard_input_file_attributes() {
        let inspector = fuchsia_inspect::Inspector::default();
        let node = inspector.root();
        let keyboard_file = InputFile::new_keyboard(
            InputDeviceInfo::new(
                uapi::input_id { bustype: 0, vendor: 0, product: 0, version: 0 },
                "keyboard_test".to_string(),
            ),
            node,
        );

        // Event types: EV_KEY
        assert!(keyboard_file.config.supported_event_types.get(uapi::EV_KEY));
        assert!(!keyboard_file.config.supported_event_types.get(uapi::EV_REL));
        assert!(!keyboard_file.config.supported_event_types.get(uapi::EV_ABS));

        // Mapped Linux keys from KEY_MAP
        assert!(keyboard_file.config.supported_keys.get(uapi::KEY_A));
        assert!(keyboard_file.config.supported_keys.get(uapi::KEY_Z));
        assert!(keyboard_file.config.supported_keys.get(uapi::KEY_1));
        assert!(keyboard_file.config.supported_keys.get(uapi::KEY_ENTER));
        assert!(keyboard_file.config.supported_keys.get(uapi::KEY_SPACE));
        assert!(keyboard_file.config.supported_keys.get(uapi::KEY_ESC));
        assert!(keyboard_file.config.supported_keys.get(uapi::KEY_TAB));
        assert!(keyboard_file.config.supported_keys.get(uapi::KEY_BACKSPACE));
        assert!(keyboard_file.config.supported_keys.get(uapi::KEY_LEFTSHIFT));
        assert!(keyboard_file.config.supported_keys.get(uapi::KEY_LEFTCTRL));
        assert!(keyboard_file.config.supported_keys.get(uapi::KEY_LEFTALT));
        assert!(keyboard_file.config.supported_keys.get(uapi::KEY_POWER));
        assert!(keyboard_file.config.supported_keys.get(uapi::KEY_VOLUMEUP));
        assert!(keyboard_file.config.supported_keys.get(uapi::KEY_VOLUMEDOWN));
        assert!(keyboard_file.config.supported_keys.get(uapi::BTN_MISC));

        // Properties: INPUT_PROP_DIRECT
        assert!(keyboard_file.config.properties.get(uapi::INPUT_PROP_DIRECT));
        assert!(!keyboard_file.config.properties.get(uapi::INPUT_PROP_POINTER));
    }

    #[test]
    fn test_read_events_no_notify_when_buffer_full() {
        let inspector = fuchsia_inspect::Inspector::default();
        let node = inspector.root();
        let input_file = InputFile::new_touch(
            InputDeviceInfo::new(
                uapi::input_id { bustype: 0, vendor: 0, product: 0, version: 0 },
                "touch_test".to_string(),
            ),
            100,
            100,
            node,
        );

        // Add some events.
        let event1 = uapi::input_event {
            type_: uapi::EV_KEY as u16,
            code: 1,
            value: 1,
            ..Default::default()
        };
        let event2 = uapi::input_event {
            type_: uapi::EV_KEY as u16,
            code: 2,
            value: 1,
            ..Default::default()
        };
        input_file.add_events(vec![event1, event2]);

        // Verify that adding events triggered a notification.
        let notify_count =
            input_file.inspect_status.as_ref().unwrap().fd_notify_count.load(Ordering::Relaxed);
        assert_eq!(notify_count, 1);

        // Read with a limit of 1.
        let events = input_file.read_events(1);
        assert_eq!(events.len(), 1);

        // Verify that no additional notification was sent despite more events remaining.
        let notify_count =
            input_file.inspect_status.as_ref().unwrap().fd_notify_count.load(Ordering::Relaxed);
        assert_eq!(notify_count, 1);
    }

    #[test]
    fn test_bitset_set_and_get() {
        let mut bitset = BitSet::<4>::new();
        assert!(!bitset.get(0));
        assert!(!bitset.get(15));
        assert!(!bitset.get(31));

        bitset.set(0);
        bitset.set(15);
        bitset.set(31);

        assert!(bitset.get(0));
        assert!(bitset.get(15));
        assert!(bitset.get(31));
        assert!(!bitset.get(1));
        assert!(!bitset.get(14));
        assert!(!bitset.get(30));
    }

    #[test]
    fn test_mouse_capabilities() {
        let inspector = fuchsia_inspect::Inspector::default();
        let node = inspector.root();
        let mouse_file = InputFile::new_mouse(
            InputDeviceInfo::new(
                uapi::input_id { bustype: 0, vendor: 0, product: 0, version: 0 },
                "mouse_test".to_string(),
            ),
            node,
        );

        // EV_KEY and EV_REL supported, EV_ABS not supported.
        assert!(mouse_file.config.supported_event_types.get(uapi::EV_KEY));
        assert!(mouse_file.config.supported_event_types.get(uapi::EV_REL));
        assert!(!mouse_file.config.supported_event_types.get(uapi::EV_ABS));

        // Buttons supported: BTN_LEFT (BTN_MOUSE), BTN_RIGHT, BTN_MIDDLE, BTN_SIDE, BTN_EXTRA.
        assert!(mouse_file.config.supported_keys.get(BTN_LEFT));
        assert!(mouse_file.config.supported_keys.get(BTN_RIGHT));
        assert!(mouse_file.config.supported_keys.get(BTN_MIDDLE));
        assert!(mouse_file.config.supported_keys.get(BTN_SIDE));
        assert!(mouse_file.config.supported_keys.get(BTN_EXTRA));
        assert!(!mouse_file.config.supported_keys.get(BTN_TOUCH));

        // Relative motion: REL_X, REL_Y, REL_WHEEL, REL_HWHEEL.
        assert!(mouse_file.config.supported_motion_attributes.get(REL_X));
        assert!(mouse_file.config.supported_motion_attributes.get(REL_Y));
        assert!(mouse_file.config.supported_motion_attributes.get(REL_WHEEL));
        assert!(mouse_file.config.supported_motion_attributes.get(REL_HWHEEL));

        // Properties: INPUT_PROP_POINTER supported, INPUT_PROP_DIRECT not supported.
        assert!(mouse_file.config.properties.get(INPUT_PROP_POINTER));
        assert!(!mouse_file.config.properties.get(INPUT_PROP_DIRECT));
    }

    #[::fuchsia::test]
    fn test_parse_axis_info() {
        let axis_mm = fidl_fuchsia_input_report::Axis {
            range: fidl_fuchsia_input_report::Range { min: 0, max: 1080 },
            unit: fidl_fuchsia_input_report::Unit {
                type_: fidl_fuchsia_input_report::UnitType::Meters,
                exponent: -3,
            },
        };
        let absinfo = parse_axis_info(&axis_mm);
        assert_eq!(absinfo.minimum, 0);
        assert_eq!(absinfo.maximum, 1080);
        assert_eq!(absinfo.resolution, 1);

        let axis_um = fidl_fuchsia_input_report::Axis {
            range: fidl_fuchsia_input_report::Range { min: 0, max: 2400 },
            unit: fidl_fuchsia_input_report::Unit {
                type_: fidl_fuchsia_input_report::UnitType::Meters,
                exponent: -6,
            },
        };
        let absinfo_um = parse_axis_info(&axis_um);
        assert_eq!(absinfo_um.minimum, 0);
        assert_eq!(absinfo_um.maximum, 2400);
        assert_eq!(absinfo_um.resolution, 1000);

        let axis_none = fidl_fuchsia_input_report::Axis {
            range: fidl_fuchsia_input_report::Range { min: -100, max: 100 },
            unit: fidl_fuchsia_input_report::Unit {
                type_: fidl_fuchsia_input_report::UnitType::None,
                exponent: 0,
            },
        };
        let absinfo_none = parse_axis_info(&axis_none);
        assert_eq!(absinfo_none.minimum, -100);
        assert_eq!(absinfo_none.maximum, 100);
        assert_eq!(absinfo_none.resolution, 0);

        let axis_clamp = fidl_fuchsia_input_report::Axis {
            range: fidl_fuchsia_input_report::Range { min: i64::MIN, max: i64::MAX },
            unit: fidl_fuchsia_input_report::Unit {
                type_: fidl_fuchsia_input_report::UnitType::None,
                exponent: 0,
            },
        };
        let absinfo_clamp = parse_axis_info(&axis_clamp);
        assert_eq!(absinfo_clamp.minimum, i32::MIN);
        assert_eq!(absinfo_clamp.maximum, i32::MAX);

        let axis_extreme_max = fidl_fuchsia_input_report::Axis {
            range: fidl_fuchsia_input_report::Range { min: 0, max: 100 },
            unit: fidl_fuchsia_input_report::Unit {
                type_: fidl_fuchsia_input_report::UnitType::Meters,
                exponent: i32::MAX,
            },
        };
        let absinfo_extreme_max = parse_axis_info(&axis_extreme_max);
        assert_eq!(absinfo_extreme_max.resolution, 0);

        let axis_extreme_min = fidl_fuchsia_input_report::Axis {
            range: fidl_fuchsia_input_report::Range { min: 0, max: 100 },
            unit: fidl_fuchsia_input_report::Unit {
                type_: fidl_fuchsia_input_report::UnitType::Meters,
                exponent: i32::MIN,
            },
        };
        let absinfo_extreme_min = parse_axis_info(&axis_extreme_min);
        assert_eq!(absinfo_extreme_min.resolution, 0);
    }

    #[::fuchsia::test]
    fn test_input_file_from_touch_descriptor() {
        let inspector = fuchsia_inspect::Inspector::default();
        let descriptor = fidl_fuchsia_input_report::DeviceDescriptor {
            touch: Some(fidl_fuchsia_input_report::TouchDescriptor {
                input: Some(fidl_fuchsia_input_report::TouchInputDescriptor {
                    contacts: Some(vec![fidl_fuchsia_input_report::ContactInputDescriptor {
                        position_x: Some(fidl_fuchsia_input_report::Axis {
                            range: fidl_fuchsia_input_report::Range { min: 0, max: 1080 },
                            unit: fidl_fuchsia_input_report::Unit {
                                type_: fidl_fuchsia_input_report::UnitType::Meters,
                                exponent: -3,
                            },
                        }),
                        position_y: Some(fidl_fuchsia_input_report::Axis {
                            range: fidl_fuchsia_input_report::Range { min: 0, max: 2400 },
                            unit: fidl_fuchsia_input_report::Unit {
                                type_: fidl_fuchsia_input_report::UnitType::Meters,
                                exponent: -3,
                            },
                        }),
                        pressure: Some(fidl_fuchsia_input_report::Axis {
                            range: fidl_fuchsia_input_report::Range { min: 0, max: 255 },
                            unit: fidl_fuchsia_input_report::Unit {
                                type_: fidl_fuchsia_input_report::UnitType::None,
                                exponent: 0,
                            },
                        }),
                        contact_width: Some(fidl_fuchsia_input_report::Axis {
                            range: fidl_fuchsia_input_report::Range { min: 0, max: 100 },
                            unit: fidl_fuchsia_input_report::Unit {
                                type_: fidl_fuchsia_input_report::UnitType::None,
                                exponent: 0,
                            },
                        }),
                        contact_height: Some(fidl_fuchsia_input_report::Axis {
                            range: fidl_fuchsia_input_report::Range { min: 0, max: 100 },
                            unit: fidl_fuchsia_input_report::Unit {
                                type_: fidl_fuchsia_input_report::UnitType::None,
                                exponent: 0,
                            },
                        }),
                        ..Default::default()
                    }]),
                    max_contacts: Some(5),
                    touch_type: Some(fidl_fuchsia_input_report::TouchType::Touchscreen),
                    buttons: Some(vec![fidl_fuchsia_input_report::TouchButton::Palm]),
                    ..Default::default()
                }),
                ..Default::default()
            }),
            ..Default::default()
        };

        let info = InputDeviceInfo::new(
            uapi::input_id { bustype: 3, vendor: 0x18d1, product: 0x5678, version: 1 },
            "test_touch".to_string(),
        );
        let file = InputFile::from_device_descriptor(info, &descriptor, inspector.root());

        assert!(file.config.supported_event_types.get(uapi::EV_ABS));
        assert!(file.config.supported_event_types.get(uapi::EV_KEY));
        assert!(file.config.properties.get(uapi::INPUT_PROP_DIRECT));
        assert!(!file.config.properties.get(uapi::INPUT_PROP_POINTER));

        assert_eq!(file.config.x_axis_info.minimum, 0);
        assert_eq!(file.config.x_axis_info.maximum, 1080);
        assert_eq!(file.config.x_axis_info.resolution, 1);

        assert_eq!(file.config.y_axis_info.minimum, 0);
        assert_eq!(file.config.y_axis_info.maximum, 2400);
        assert_eq!(file.config.y_axis_info.resolution, 1);

        assert_eq!(file.config.mt_slot_axis_info.minimum, 0);
        assert_eq!(file.config.mt_slot_axis_info.maximum, 4);
        assert_eq!(file.config.mt_tracking_id_axis_info.maximum, i32::MAX);

        assert_eq!(file.config.mt_pressure_axis_info.maximum, 255);
        assert_eq!(file.config.mt_touch_major_axis_info.maximum, 100);
        assert_eq!(file.config.mt_touch_minor_axis_info.maximum, 100);

        assert!(file.config.supported_position_attributes.get(uapi::ABS_MT_SLOT));
        assert!(file.config.supported_position_attributes.get(uapi::ABS_MT_TRACKING_ID));
        assert!(file.config.supported_position_attributes.get(uapi::ABS_MT_POSITION_X));
        assert!(file.config.supported_position_attributes.get(uapi::ABS_MT_POSITION_Y));
        assert!(file.config.supported_position_attributes.get(uapi::ABS_MT_PRESSURE));
        assert!(file.config.supported_position_attributes.get(uapi::ABS_MT_TOUCH_MAJOR));
        assert!(file.config.supported_position_attributes.get(uapi::ABS_MT_TOUCH_MINOR));
        assert!(!file.config.supported_position_attributes.get(uapi::ABS_X));
        assert!(!file.config.supported_position_attributes.get(uapi::ABS_Y));

        assert!(file.config.supported_keys.get(uapi::BTN_TOUCH));
        assert!(file.config.supported_keys.get(uapi::KEY_SLEEP));
        assert!(!file.config.supported_keys.get(uapi::KEY_UP));
    }

    #[::fuchsia::test]
    fn test_input_file_from_touch_descriptor_no_buttons() {
        let inspector = fuchsia_inspect::Inspector::default();
        let descriptor = fidl_fuchsia_input_report::DeviceDescriptor {
            touch: Some(fidl_fuchsia_input_report::TouchDescriptor {
                input: Some(fidl_fuchsia_input_report::TouchInputDescriptor {
                    contacts: Some(vec![fidl_fuchsia_input_report::ContactInputDescriptor {
                        position_x: Some(fidl_fuchsia_input_report::Axis {
                            range: fidl_fuchsia_input_report::Range { min: 0, max: 1080 },
                            unit: fidl_fuchsia_input_report::Unit {
                                type_: fidl_fuchsia_input_report::UnitType::None,
                                exponent: 0,
                            },
                        }),
                        position_y: Some(fidl_fuchsia_input_report::Axis {
                            range: fidl_fuchsia_input_report::Range { min: 0, max: 2400 },
                            unit: fidl_fuchsia_input_report::Unit {
                                type_: fidl_fuchsia_input_report::UnitType::None,
                                exponent: 0,
                            },
                        }),
                        ..Default::default()
                    }]),
                    buttons: None,
                    ..Default::default()
                }),
                ..Default::default()
            }),
            ..Default::default()
        };

        let info = InputDeviceInfo::new(
            uapi::input_id { bustype: 3, vendor: 0x18d1, product: 0x5678, version: 1 },
            "test_touch_no_buttons".to_string(),
        );
        let file = InputFile::from_device_descriptor(info, &descriptor, inspector.root());

        assert!(file.config.supported_keys.get(uapi::BTN_TOUCH));
        assert!(!file.config.supported_keys.get(uapi::KEY_SLEEP));
        assert!(!file.config.supported_keys.get(uapi::KEY_UP));
    }

    #[::fuchsia::test]
    fn test_input_file_from_touchpad_descriptor() {
        let inspector = fuchsia_inspect::Inspector::default();
        let descriptor = fidl_fuchsia_input_report::DeviceDescriptor {
            touch: Some(fidl_fuchsia_input_report::TouchDescriptor {
                input: Some(fidl_fuchsia_input_report::TouchInputDescriptor {
                    contacts: Some(vec![fidl_fuchsia_input_report::ContactInputDescriptor {
                        position_x: Some(fidl_fuchsia_input_report::Axis {
                            range: fidl_fuchsia_input_report::Range { min: 0, max: 1920 },
                            unit: fidl_fuchsia_input_report::Unit {
                                type_: fidl_fuchsia_input_report::UnitType::Meters,
                                exponent: -3,
                            },
                        }),
                        position_y: Some(fidl_fuchsia_input_report::Axis {
                            range: fidl_fuchsia_input_report::Range { min: 0, max: 1080 },
                            unit: fidl_fuchsia_input_report::Unit {
                                type_: fidl_fuchsia_input_report::UnitType::Meters,
                                exponent: -3,
                            },
                        }),
                        ..Default::default()
                    }]),
                    max_contacts: Some(2),
                    touch_type: Some(fidl_fuchsia_input_report::TouchType::Touchpad),
                    ..Default::default()
                }),
                ..Default::default()
            }),
            ..Default::default()
        };

        let info = InputDeviceInfo::new(
            uapi::input_id { bustype: 3, vendor: 0x18d1, product: 0x1234, version: 1 },
            "test_touchpad".to_string(),
        );
        let file = InputFile::from_device_descriptor(info, &descriptor, inspector.root());

        assert!(file.config.supported_event_types.get(uapi::EV_ABS));
        assert!(file.config.properties.get(uapi::INPUT_PROP_POINTER));
        assert!(!file.config.properties.get(uapi::INPUT_PROP_DIRECT));
        assert!(file.config.supported_keys.get(uapi::BTN_TOOL_FINGER));
        assert_eq!(file.config.mt_slot_axis_info.maximum, 1);
    }

    #[::fuchsia::test]
    fn test_input_file_from_keyboard_descriptor() {
        let inspector = fuchsia_inspect::Inspector::default();
        let descriptor = fidl_fuchsia_input_report::DeviceDescriptor {
            keyboard: Some(fidl_fuchsia_input_report::KeyboardDescriptor {
                input: Some(fidl_fuchsia_input_report::KeyboardInputDescriptor {
                    keys3: Some(vec![
                        fidl_fuchsia_input::Key::A,
                        fidl_fuchsia_input::Key::B,
                        fidl_fuchsia_input::Key::Enter,
                    ]),
                    ..Default::default()
                }),
                output: Some(fidl_fuchsia_input_report::KeyboardOutputDescriptor {
                    leds: Some(vec![fidl_fuchsia_input_report::LedType::CapsLock]),
                    ..Default::default()
                }),
                ..Default::default()
            }),
            ..Default::default()
        };

        let info = InputDeviceInfo::new(
            uapi::input_id { bustype: 3, vendor: 1, product: 2, version: 3 },
            "test_keyboard".to_string(),
        );
        let file = InputFile::from_device_descriptor(info, &descriptor, inspector.root());

        assert!(file.config.supported_event_types.get(uapi::EV_KEY));
        assert!(file.config.supported_event_types.get(uapi::EV_LED));
        assert!(!file.config.properties.get(uapi::INPUT_PROP_DIRECT));

        assert!(file.config.supported_keys.get(uapi::KEY_A));
        assert!(file.config.supported_keys.get(uapi::KEY_B));
        assert!(file.config.supported_keys.get(uapi::KEY_ENTER));
        assert!(file.config.supported_leds.get(uapi::LED_CAPSL));
    }

    #[::fuchsia::test]
    fn test_input_file_from_keyboard_descriptor_fallback_keys() {
        let inspector = fuchsia_inspect::Inspector::default();
        let descriptor = fidl_fuchsia_input_report::DeviceDescriptor {
            keyboard: Some(fidl_fuchsia_input_report::KeyboardDescriptor {
                input: Some(fidl_fuchsia_input_report::KeyboardInputDescriptor {
                    keys3: None,
                    ..Default::default()
                }),
                ..Default::default()
            }),
            ..Default::default()
        };

        let info = InputDeviceInfo::new(
            uapi::input_id { bustype: 3, vendor: 1, product: 2, version: 3 },
            "test_keyboard".to_string(),
        );
        let file = InputFile::from_device_descriptor(info, &descriptor, inspector.root());

        assert!(file.config.supported_event_types.get(uapi::EV_KEY));
        assert!(!file.config.properties.get(uapi::INPUT_PROP_DIRECT));

        // When !has_keys, standard keycodes from KEY_MAP plus media keys should be set.
        assert!(file.config.supported_keys.get(uapi::KEY_A));
        assert!(file.config.supported_keys.get(uapi::KEY_Z));
        assert!(file.config.supported_keys.get(uapi::KEY_ENTER));
        assert!(file.config.supported_keys.get(uapi::KEY_POWER));
        assert!(file.config.supported_keys.get(uapi::KEY_VOLUMEUP));
        assert!(file.config.supported_keys.get(uapi::KEY_VOLUMEDOWN));
    }

    #[::fuchsia::test]
    fn test_input_file_from_keyboard_descriptor_unknown_led_does_not_set_ev_led() {
        let inspector = fuchsia_inspect::Inspector::default();
        let descriptor = fidl_fuchsia_input_report::DeviceDescriptor {
            keyboard: Some(fidl_fuchsia_input_report::KeyboardDescriptor {
                input: Some(fidl_fuchsia_input_report::KeyboardInputDescriptor {
                    keys3: Some(vec![fidl_fuchsia_input::Key::A]),
                    ..Default::default()
                }),
                output: Some(fidl_fuchsia_input_report::KeyboardOutputDescriptor {
                    leds: Some(vec![
                        fidl_fuchsia_input_report::LedType::from_primitive_allow_unknown(999),
                    ]),
                    ..Default::default()
                }),
                ..Default::default()
            }),
            ..Default::default()
        };

        let info = InputDeviceInfo::new(
            uapi::input_id { bustype: 3, vendor: 1, product: 2, version: 3 },
            "test_keyboard_unknown_led".to_string(),
        );
        let file = InputFile::from_device_descriptor(info, &descriptor, inspector.root());

        assert!(file.config.supported_event_types.get(uapi::EV_KEY));
        assert!(!file.config.supported_event_types.get(uapi::EV_LED));
        assert_eq!(file.config.supported_leds, BitSet::new());
    }

    #[::fuchsia::test]
    fn test_input_file_from_mouse_descriptor() {
        let inspector = fuchsia_inspect::Inspector::default();
        let descriptor = fidl_fuchsia_input_report::DeviceDescriptor {
            mouse: Some(fidl_fuchsia_input_report::MouseDescriptor {
                input: Some(fidl_fuchsia_input_report::MouseInputDescriptor {
                    movement_x: Some(fidl_fuchsia_input_report::Axis {
                        range: fidl_fuchsia_input_report::Range { min: -127, max: 127 },
                        unit: fidl_fuchsia_input_report::Unit {
                            type_: fidl_fuchsia_input_report::UnitType::None,
                            exponent: 0,
                        },
                    }),
                    movement_y: Some(fidl_fuchsia_input_report::Axis {
                        range: fidl_fuchsia_input_report::Range { min: -127, max: 127 },
                        unit: fidl_fuchsia_input_report::Unit {
                            type_: fidl_fuchsia_input_report::UnitType::None,
                            exponent: 0,
                        },
                    }),
                    scroll_v: Some(fidl_fuchsia_input_report::Axis {
                        range: fidl_fuchsia_input_report::Range { min: -1, max: 1 },
                        unit: fidl_fuchsia_input_report::Unit {
                            type_: fidl_fuchsia_input_report::UnitType::None,
                            exponent: 0,
                        },
                    }),
                    ..Default::default()
                }),
                ..Default::default()
            }),
            ..Default::default()
        };

        let info = InputDeviceInfo::new(
            uapi::input_id { bustype: 3, vendor: 1, product: 2, version: 3 },
            "test_mouse".to_string(),
        );
        let file = InputFile::from_device_descriptor(info, &descriptor, inspector.root());

        assert!(file.config.supported_event_types.get(uapi::EV_KEY));
        assert!(file.config.supported_event_types.get(uapi::EV_REL));
        assert!(file.config.properties.get(uapi::INPUT_PROP_POINTER));

        assert!(file.config.supported_keys.get(uapi::BTN_LEFT));
        assert!(file.config.supported_keys.get(uapi::BTN_RIGHT));
        assert!(file.config.supported_motion_attributes.get(uapi::REL_X));
        assert!(file.config.supported_motion_attributes.get(uapi::REL_Y));
        assert!(file.config.supported_motion_attributes.get(uapi::REL_WHEEL));
    }

    #[::fuchsia::test]
    fn test_input_file_from_mouse_descriptor_scroll_only() {
        let inspector = fuchsia_inspect::Inspector::default();
        let descriptor = fidl_fuchsia_input_report::DeviceDescriptor {
            mouse: Some(fidl_fuchsia_input_report::MouseDescriptor {
                input: Some(fidl_fuchsia_input_report::MouseInputDescriptor {
                    scroll_v: Some(fidl_fuchsia_input_report::Axis {
                        range: fidl_fuchsia_input_report::Range { min: -1, max: 1 },
                        unit: fidl_fuchsia_input_report::Unit {
                            type_: fidl_fuchsia_input_report::UnitType::None,
                            exponent: 0,
                        },
                    }),
                    ..Default::default()
                }),
                ..Default::default()
            }),
            ..Default::default()
        };

        let info = InputDeviceInfo::new(
            uapi::input_id { bustype: 3, vendor: 1, product: 2, version: 3 },
            "test_mouse_scroll".to_string(),
        );
        let file = InputFile::from_device_descriptor(info, &descriptor, inspector.root());

        assert!(file.config.supported_event_types.get(uapi::EV_REL));
        assert!(file.config.supported_motion_attributes.get(uapi::REL_X));
        assert!(file.config.supported_motion_attributes.get(uapi::REL_Y));
        assert!(file.config.supported_motion_attributes.get(uapi::REL_WHEEL));
    }

    #[::fuchsia::test]
    fn test_input_file_from_mouse_descriptor_with_buttons() {
        let inspector = fuchsia_inspect::Inspector::default();
        let descriptor = fidl_fuchsia_input_report::DeviceDescriptor {
            mouse: Some(fidl_fuchsia_input_report::MouseDescriptor {
                input: Some(fidl_fuchsia_input_report::MouseInputDescriptor {
                    buttons: Some(vec![1, 2]),
                    movement_x: Some(fidl_fuchsia_input_report::Axis {
                        range: fidl_fuchsia_input_report::Range { min: -10, max: 10 },
                        unit: fidl_fuchsia_input_report::Unit {
                            type_: fidl_fuchsia_input_report::UnitType::None,
                            exponent: 0,
                        },
                    }),
                    ..Default::default()
                }),
                ..Default::default()
            }),
            ..Default::default()
        };

        let info = InputDeviceInfo::new(
            uapi::input_id { bustype: 3, vendor: 1, product: 2, version: 3 },
            "test_mouse_buttons".to_string(),
        );
        let file = InputFile::from_device_descriptor(info, &descriptor, inspector.root());

        assert!(file.config.supported_keys.get(uapi::BTN_LEFT));
        assert!(file.config.supported_keys.get(uapi::BTN_RIGHT));
        assert!(!file.config.supported_keys.get(uapi::BTN_MIDDLE));
    }

    #[::fuchsia::test]
    fn test_input_file_from_mouse_descriptor_fallback_rel() {
        let inspector = fuchsia_inspect::Inspector::default();
        let descriptor = fidl_fuchsia_input_report::DeviceDescriptor {
            mouse: Some(fidl_fuchsia_input_report::MouseDescriptor {
                input: Some(fidl_fuchsia_input_report::MouseInputDescriptor {
                    movement_x: None,
                    movement_y: None,
                    scroll_v: None,
                    scroll_h: None,
                    ..Default::default()
                }),
                ..Default::default()
            }),
            ..Default::default()
        };

        let info = InputDeviceInfo::new(
            uapi::input_id { bustype: 3, vendor: 1, product: 2, version: 3 },
            "test_mouse".to_string(),
        );
        let file = InputFile::from_device_descriptor(info, &descriptor, inspector.root());

        // When !has_rel on a standalone mouse, it falls back to standard relative axes.
        assert!(file.config.supported_event_types.get(uapi::EV_REL));
        assert!(file.config.supported_motion_attributes.get(uapi::REL_X));
        assert!(file.config.supported_motion_attributes.get(uapi::REL_Y));
        assert!(file.config.supported_motion_attributes.get(uapi::REL_WHEEL));
        assert!(file.config.supported_motion_attributes.get(uapi::REL_HWHEEL));
    }

    #[::fuchsia::test]
    fn test_input_file_from_mouse_descriptor_absolute_coordinates() {
        let inspector = fuchsia_inspect::Inspector::default();
        let descriptor = fidl_fuchsia_input_report::DeviceDescriptor {
            mouse: Some(fidl_fuchsia_input_report::MouseDescriptor {
                input: Some(fidl_fuchsia_input_report::MouseInputDescriptor {
                    position_x: Some(fidl_fuchsia_input_report::Axis {
                        range: fidl_fuchsia_input_report::Range { min: 0, max: 1920 },
                        unit: fidl_fuchsia_input_report::Unit {
                            type_: fidl_fuchsia_input_report::UnitType::None,
                            exponent: 0,
                        },
                    }),
                    position_y: Some(fidl_fuchsia_input_report::Axis {
                        range: fidl_fuchsia_input_report::Range { min: 0, max: 1080 },
                        unit: fidl_fuchsia_input_report::Unit {
                            type_: fidl_fuchsia_input_report::UnitType::None,
                            exponent: 0,
                        },
                    }),
                    ..Default::default()
                }),
                ..Default::default()
            }),
            ..Default::default()
        };

        let info = InputDeviceInfo::new(
            uapi::input_id { bustype: 3, vendor: 1, product: 2, version: 3 },
            "test_abs_mouse".to_string(),
        );
        let file = InputFile::from_device_descriptor(info, &descriptor, inspector.root());

        // Mice never report EV_ABS or BTN_TOUCH; even when position axes are
        // present in the descriptor, mice fall back to relative motion (EV_REL).
        assert!(!file.config.supported_event_types.get(uapi::EV_ABS));
        assert!(file.config.supported_event_types.get(uapi::EV_REL));
        assert!(!file.config.supported_position_attributes.get(uapi::ABS_X));
        assert!(!file.config.supported_position_attributes.get(uapi::ABS_Y));
        assert!(!file.config.supported_keys.get(uapi::BTN_TOUCH));
        assert!(file.config.supported_motion_attributes.get(uapi::REL_X));
        assert!(file.config.supported_motion_attributes.get(uapi::REL_Y));
    }

    #[::fuchsia::test]
    fn test_input_file_from_composite_touch_and_mouse() {
        let inspector = fuchsia_inspect::Inspector::default();
        let descriptor = fidl_fuchsia_input_report::DeviceDescriptor {
            touch: Some(fidl_fuchsia_input_report::TouchDescriptor {
                input: Some(fidl_fuchsia_input_report::TouchInputDescriptor {
                    contacts: Some(vec![fidl_fuchsia_input_report::ContactInputDescriptor {
                        position_x: Some(fidl_fuchsia_input_report::Axis {
                            range: fidl_fuchsia_input_report::Range { min: 0, max: 1080 },
                            unit: fidl_fuchsia_input_report::Unit {
                                type_: fidl_fuchsia_input_report::UnitType::None,
                                exponent: 0,
                            },
                        }),
                        position_y: Some(fidl_fuchsia_input_report::Axis {
                            range: fidl_fuchsia_input_report::Range { min: 0, max: 2400 },
                            unit: fidl_fuchsia_input_report::Unit {
                                type_: fidl_fuchsia_input_report::UnitType::None,
                                exponent: 0,
                            },
                        }),
                        ..Default::default()
                    }]),
                    ..Default::default()
                }),
                ..Default::default()
            }),
            mouse: Some(fidl_fuchsia_input_report::MouseDescriptor {
                input: Some(fidl_fuchsia_input_report::MouseInputDescriptor {
                    position_x: Some(fidl_fuchsia_input_report::Axis {
                        range: fidl_fuchsia_input_report::Range { min: 0, max: 500 },
                        unit: fidl_fuchsia_input_report::Unit {
                            type_: fidl_fuchsia_input_report::UnitType::None,
                            exponent: 0,
                        },
                    }),
                    movement_x: Some(fidl_fuchsia_input_report::Axis {
                        range: fidl_fuchsia_input_report::Range { min: -10, max: 10 },
                        unit: fidl_fuchsia_input_report::Unit {
                            type_: fidl_fuchsia_input_report::UnitType::None,
                            exponent: 0,
                        },
                    }),
                    ..Default::default()
                }),
                ..Default::default()
            }),
            ..Default::default()
        };

        let info = InputDeviceInfo::new(
            uapi::input_id { bustype: 3, vendor: 1, product: 2, version: 3 },
            "composite".to_string(),
        );
        let file = InputFile::from_device_descriptor(info, &descriptor, inspector.root());

        // Touch sets INPUT_PROP_DIRECT; mouse must NOT overwrite or add INPUT_PROP_POINTER.
        assert!(file.config.properties.get(uapi::INPUT_PROP_DIRECT));
        assert!(!file.config.properties.get(uapi::INPUT_PROP_POINTER));

        // Touch axes (0..1080) must NOT be overwritten by mouse position_x (0..500).
        assert_eq!(file.config.x_axis_info.maximum, 1080);
        assert!(file.config.supported_event_types.get(uapi::EV_REL));
        assert!(file.config.supported_event_types.get(uapi::EV_ABS));
    }

    #[::fuchsia::test]
    fn test_input_file_from_composite_touch_keyboard_descriptor() {
        let inspector = fuchsia_inspect::Inspector::default();
        let descriptor = fidl_fuchsia_input_report::DeviceDescriptor {
            touch: Some(fidl_fuchsia_input_report::TouchDescriptor {
                input: Some(fidl_fuchsia_input_report::TouchInputDescriptor {
                    touch_type: Some(fidl_fuchsia_input_report::TouchType::Touchpad),
                    ..Default::default()
                }),
                ..Default::default()
            }),
            keyboard: Some(fidl_fuchsia_input_report::KeyboardDescriptor {
                input: Some(fidl_fuchsia_input_report::KeyboardInputDescriptor {
                    keys3: None,
                    ..Default::default()
                }),
                ..Default::default()
            }),
            ..Default::default()
        };

        let info = InputDeviceInfo::new(
            uapi::input_id { bustype: 3, vendor: 1, product: 2, version: 3 },
            "composite_touch_keyboard".to_string(),
        );
        let file = InputFile::from_device_descriptor(info, &descriptor, inspector.root());

        // Touch keys (BTN_TOUCH, BTN_TOOL_FINGER) must not be overwritten by keyboard fallback keys.
        assert!(file.config.supported_keys.get(uapi::BTN_TOUCH));
        assert!(file.config.supported_keys.get(uapi::BTN_TOOL_FINGER));

        // Keyboard fallback keys must also be present.
        assert!(file.config.supported_keys.get(uapi::KEY_A));
        assert!(file.config.supported_keys.get(uapi::KEY_Z));
        assert!(file.config.supported_keys.get(uapi::KEY_ENTER));
    }

    #[::fuchsia::test]
    fn test_input_file_from_consumer_control_descriptor() {
        let inspector = fuchsia_inspect::Inspector::default();
        let descriptor = fidl_fuchsia_input_report::DeviceDescriptor {
            consumer_control: Some(fidl_fuchsia_input_report::ConsumerControlDescriptor {
                input: Some(fidl_fuchsia_input_report::ConsumerControlInputDescriptor {
                    buttons: Some(vec![
                        fidl_fuchsia_input_report::ConsumerControlButton::VolumeUp,
                        fidl_fuchsia_input_report::ConsumerControlButton::VolumeDown,
                        fidl_fuchsia_input_report::ConsumerControlButton::Power,
                        fidl_fuchsia_input_report::ConsumerControlButton::Pause,
                        fidl_fuchsia_input_report::ConsumerControlButton::MicMute,
                    ]),
                    ..Default::default()
                }),
                ..Default::default()
            }),
            ..Default::default()
        };

        let info = InputDeviceInfo::new(
            uapi::input_id { bustype: 3, vendor: 1, product: 2, version: 3 },
            "test_buttons".to_string(),
        );
        let file = InputFile::from_device_descriptor(info, &descriptor, inspector.root());

        assert!(file.config.supported_event_types.get(uapi::EV_KEY));
        assert!(file.config.supported_keys.get(uapi::KEY_VOLUMEUP));
        assert!(file.config.supported_keys.get(uapi::KEY_VOLUMEDOWN));
        assert!(file.config.supported_keys.get(uapi::KEY_POWER));
        assert!(file.config.supported_keys.get(uapi::KEY_PAUSE));
        assert!(file.config.supported_keys.get(uapi::KEY_MICMUTE));
    }

    #[::fuchsia::test]
    fn test_input_file_from_consumer_control_descriptor_fallback() {
        let inspector = fuchsia_inspect::Inspector::default();
        let descriptor = fidl_fuchsia_input_report::DeviceDescriptor {
            consumer_control: Some(fidl_fuchsia_input_report::ConsumerControlDescriptor {
                input: Some(fidl_fuchsia_input_report::ConsumerControlInputDescriptor {
                    buttons: None,
                    ..Default::default()
                }),
                ..Default::default()
            }),
            ..Default::default()
        };

        let info = InputDeviceInfo::new(
            uapi::input_id { bustype: 3, vendor: 1, product: 2, version: 3 },
            "test_buttons_fallback".to_string(),
        );
        let file = InputFile::from_device_descriptor(info, &descriptor, inspector.root());

        assert!(file.config.supported_event_types.get(uapi::EV_KEY));
        assert!(file.config.supported_keys.get(uapi::KEY_POWER));
        assert!(file.config.supported_keys.get(uapi::KEY_VOLUMEUP));
        assert!(file.config.supported_keys.get(uapi::KEY_VOLUMEDOWN));
        assert!(!file.config.supported_keys.get(uapi::KEY_PAUSE));
    }
}