ax-input 0.5.15

Input device management for ArceOS
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use alloc::{boxed::Box, string::String};

use crate::{AbsInfo, Event, EventType, InputDeviceId};

pub type InputResult<T = ()> = Result<T, InputError>;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum InputError {
    AlreadyExists,
    Again,
    BadState,
    InvalidInput,
    Io,
    NoMemory,
    ResourceBusy,
    Unsupported,
}

/// Domain boundary consumed by evdev and upper input services.
pub trait InputDevice: Send {
    fn name(&self) -> &str;

    fn device_id(&self) -> InputDeviceId;

    fn physical_location(&self) -> &str;

    fn unique_id(&self) -> &str;

    fn irq_num(&self) -> Option<usize> {
        None
    }

    fn get_event_bits(&mut self, ty: EventType, out: &mut [u8]) -> InputResult<bool>;

    fn read_event(&mut self) -> InputResult<Event>;

    fn get_prop_bits(&mut self, _out: &mut [u8]) -> InputResult<usize> {
        Ok(0)
    }

    fn get_abs_info(&mut self, _axis: u8) -> InputResult<AbsInfo> {
        Err(InputError::Unsupported)
    }
}

pub struct ErasedInputDevice {
    name: String,
    inner: Box<dyn InputDevice>,
}

impl ErasedInputDevice {
    pub fn new(device: impl InputDevice + 'static) -> Self {
        let name = device.name().into();
        Self {
            name,
            inner: Box::new(device),
        }
    }

    pub fn name(&self) -> &str {
        &self.name
    }
}

impl InputDevice for ErasedInputDevice {
    fn name(&self) -> &str {
        &self.name
    }

    fn device_id(&self) -> InputDeviceId {
        self.inner.device_id()
    }

    fn physical_location(&self) -> &str {
        self.inner.physical_location()
    }

    fn unique_id(&self) -> &str {
        self.inner.unique_id()
    }

    fn irq_num(&self) -> Option<usize> {
        self.inner.irq_num()
    }

    fn get_event_bits(&mut self, ty: EventType, out: &mut [u8]) -> InputResult<bool> {
        self.inner.get_event_bits(ty, out)
    }

    fn read_event(&mut self) -> InputResult<Event> {
        self.inner.read_event()
    }

    fn get_prop_bits(&mut self, out: &mut [u8]) -> InputResult<usize> {
        self.inner.get_prop_bits(out)
    }

    fn get_abs_info(&mut self, axis: u8) -> InputResult<AbsInfo> {
        self.inner.get_abs_info(axis)
    }
}