poller 0.2.0

File I/O events library for Rust.
Documentation 
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use libc::{input_event, timeval};
use poller::{EventContext, Events, Poller};
use std::fs::File;
use std::io::Read;
use std::os::unix::io::AsRawFd;
use std::sync::Arc;

#[derive(Clone, Copy)]
#[repr(C)]
pub struct InputEvent {
    inner: input_event,
}

impl std::fmt::Debug for InputEvent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("InputEvent")
            .field("time", &TimeVal::from(self.inner.time))
            .field("type", &self.inner.type_)
            .field("code", &self.inner.code)
            .field("value", &self.inner.value)
            .finish()
    }
}
impl std::fmt::Display for InputEvent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "InputEvent {{ time: {}, type: {}, code: {}, value: {} }}",
            TimeVal::from(self.inner.time),
            self.inner.type_,
            self.inner.code,
            self.inner.value
        )
    }
}

#[derive(Clone, Copy)]
#[repr(C)]
pub struct TimeVal {
    inner: timeval,
}

impl From<timeval> for TimeVal {
    fn from(val: timeval) -> Self {
        Self { inner: val }
    }
}

impl Into<timeval> for TimeVal {
    fn into(self) -> timeval {
        self.inner
    }
}

impl Into<(u32, u32)> for TimeVal {
    fn into(self) -> (u32, u32) {
        (self.inner.tv_sec as u32, self.inner.tv_usec as u32)
    }
}

impl Into<u64> for TimeVal {
    fn into(self) -> u64 {
        self.inner.tv_sec as u64 * 1_000_000u64 + self.inner.tv_usec as u64
    }
}

impl std::fmt::Debug for TimeVal {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("TimeVal")
            .field("sec", &self.inner.tv_sec)
            .field("usec", &self.inner.tv_usec)
            .finish()
    }
}

impl std::fmt::Display for TimeVal {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{}.{number:>0width$}",
            self.inner.tv_sec,
            number = self.inner.tv_usec,
            width = 6
        )
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Open the linux evdev.
    let evdev = Arc::new(File::open("/dev/input/event0")?);
    // Create the Poller.
    let mut poller = Poller::new()?;
    // Add stdin to the watching list of the Poller.
    poller.add(0, Events::new().read(), None)?;
    // Add evdev to the watching list of the Poller.
    poller.add(
        evdev.as_raw_fd(),
        Events::new().read(),
        Some(Arc::clone(&evdev) as EventContext),
    )?;
    // Buffer to read one InputEvent data from evdev.
    const N: usize = std::mem::size_of::<input_event>();
    let mut buf: [u8; N] = [0; N];

    println!("Press any key to exit ...");

    'outer: loop {
        // Pull all events with 1 seconds timeout.
        let events = poller.pull_events(1000)?;
        for (_fd, _events, _ctx) in events.iter() {
            // Exit loop if press any key.
            if _fd == &0 {
                break 'outer;
            }
            // Use EventContext to processing the event.
            if let Some(x) = _ctx {
                if let Some(mut f) = x.downcast_ref::<File>() {
                    f.read_exact(&mut buf)?;
                }
            }
            // Cast the buffer to &InputEvent.
            let a = unsafe { std::mem::transmute::<&[u8; N], &InputEvent>(&buf) };
            // Display the InputEvent.
            println!("{}", a);
        }
    }

    Ok(())
}