kbd-evdev 0.1.0

evdev backend for kbd — Linux input device discovery, hotplug, grab, and event forwarding.
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

# kbd-evdev

[![crates.io](https://img.shields.io/crates/v/kbd-evdev.svg)](https://crates.io/crates/kbd-evdev)
[![docs.rs](https://docs.rs/kbd-evdev/badge.svg)](https://docs.rs/kbd-evdev)

Linux evdev backend for [`kbd`](https://crates.io/crates/kbd) — device discovery, hotplug, grab, and event forwarding.

## Features

- **Device discovery** — scans `/dev/input/` for keyboards (devices supporting A–Z + Enter)
- **Hotplug** — inotify watch for device add/remove at runtime
- **Exclusive grab** — `EVIOCGRAB` for intercepting events before other applications
- **Event forwarding** — uinput virtual device re-emits unmatched events in grab mode
- **Key conversion** — extension traits for `evdev::KeyCode` ↔ `kbd::Key`

## Prerequisites

- **Linux only** — uses `/dev/input/`, `inotify`, and `/dev/uinput`
- **Read access to `/dev/input/`** — run as root or add your user to the `input` group:

  ```sh
  sudo usermod -aG input $USER
  # log out and back in for the group change to take effect
  ```

- **Write access to `/dev/uinput`** (grab mode only) — needed for the virtual device that forwards unmatched events

## Usage

```toml
[dependencies]
kbd-evdev = "0.1"
```

### Key conversion

```rust
use evdev::KeyCode;
use kbd::prelude::*;
use kbd_evdev::{EvdevKeyCodeExt, KbdKeyExt};

// evdev → kbd
let key: Key = KeyCode::KEY_A.to_key();
assert_eq!(key, Key::A);

// kbd → evdev
let code: KeyCode = Key::A.to_key_code();
assert_eq!(code, KeyCode::KEY_A);
```

### Device polling

```rust,no_run
use std::path::Path;
use kbd_evdev::devices::{DeviceManager, DeviceGrabMode};

let mut manager = DeviceManager::new(
    Path::new("/dev/input"),
    DeviceGrabMode::Shared,
);

// Build pollfd array from manager's file descriptors
let mut pollfds: Vec<libc::pollfd> = manager
    .poll_fds()
    .iter()
    .map(|&fd| libc::pollfd { fd, events: libc::POLLIN, revents: 0 })
    .collect();

// Poll and process events
unsafe { libc::poll(pollfds.as_mut_ptr(), pollfds.len() as _, 100) };
let result = manager.process_polled_events(&pollfds);

for event in &result.key_events {
    println!("{:?} {:?}", event.key, event.transition);
}
```

## Architecture

```text
/dev/input/event*          DeviceManager
  ├─ event0  ──┐       ┌─ discover + poll ──→ DeviceKeyEvent
  ├─ event1  ──┼──────→│  hotplug (inotify)   │
  └─ event2  ──┘       └───────────────────────┘
                                               │
                                     EvdevKeyCodeExt::to_key()
                                               │
                                               ▼
                                          kbd::Key
```

## See also

- [`kbd`](https://crates.io/crates/kbd) — core key types, matching, and layers
- [`kbd-global`](https://crates.io/crates/kbd-global) — threaded runtime built on this crate

## License

kbd-evdev is licensed under the MIT license. See the [`LICENSE`](../../LICENSE) file for more information.