evdevil 0.4.1

Bindings to Linux' input device APIs: evdev and uinput
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

use std::{
    hash::{BuildHasher, Hasher, RandomState},
    io,
    iter::zip,
};

use crate::{
    Evdev,
    event::{EventType, InputEvent},
    hotplug::HotplugMonitor,
    uinput::{Builder, UinputDevice},
};

/// Creates a [`UinputDevice`] and [`Evdev`] that are connected to each other.
#[allow(dead_code)]
pub fn pair(b: impl FnOnce(Builder) -> io::Result<Builder>) -> io::Result<(UinputDevice, Evdev)> {
    fn hash() -> u64 {
        RandomState::new().build_hasher().finish()
    }

    let hash = hash();
    let name = format!("-@-rust-evdevil-device-{hash}-@-");

    let hotplug = HotplugMonitor::new()?;
    let uinput = b(UinputDevice::builder()?)?.build(&name)?;
    for res in hotplug {
        let res = res.and_then(|ev| ev.open());
        match res {
            Ok(evdev) => {
                if let Ok(devname) = evdev.name() {
                    if devname == name {
                        return Ok((uinput, evdev));
                    }
                }
            }
            Err(e) => {
                // This can happen when an unrelated device (likely created by another test) shows
                // up first, and disappears before we can check its name.
                log::warn!("got error while waiting for '{name}' to appear: {e}");
            }
        }
    }
    unreachable!("hotplug event stream should be infinite")
}

pub fn events_eq(recv: InputEvent, expected: InputEvent) -> bool {
    if recv.event_type() != expected.event_type() || recv.raw_code() != expected.raw_code() {
        return false;
    }

    // Value is ignored for SYN events
    if recv.event_type() != EventType::SYN && recv.raw_value() != expected.raw_value() {
        return false;
    }
    true
}

#[track_caller]
pub fn check_events(
    actual: impl IntoIterator<Item = InputEvent>,
    expected: impl IntoIterator<Item = InputEvent>,
) {
    let actual: Vec<_> = actual.into_iter().collect();
    let expected: Vec<_> = expected.into_iter().collect();
    assert_eq!(
        actual.len(),
        expected.len(),
        "expected {} events, got {actual:?}",
        expected.len()
    );
    if !zip(actual.iter().copied(), expected.iter().copied()).all(|(a, b)| events_eq(a, b)) {
        panic!("expected {expected:?}, got {actual:?}");
    }
}