[wip] udev support via tokio-udev to add/remove devices dynamically

Support for listening asynchronously to udev DeviceRemoved/DeviceAdded events
with the `tokio-udev` crate.

For now, this only works with the latest commits on the tokio-udev repo.

CHANGELOG.md

@@ -15,6 +15,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `DESTDIR` variable for the `install` target in the `Makefile` to help
   packaging and installation. To install in a subdirectory, just call `make
   DESTDIR=subdir install`.
+- Detection of added/removed devices (e.g., when plugging or unplugging a
+  keyboard). The devices are grabbed by `swhkd` if they match the `--device`
+  parameters if present or if they are recognized as keyboard devices otherwise.
 
 ### Changed
 

swhkd/Cargo.toml

@@ -24,6 +24,7 @@ signal-hook-tokio = { version = "0.3.1", features = ["futures-v0_3"] }
 sysinfo = "0.23.5"
 tokio = { version = "1.17.0", features = ["full"] }
 tokio-stream = "0.1.8"
+tokio-udev = { git = "https://github.com/jeandudey/tokio-udev.git" }
 
 [[bin]]
 name = "swhkd"

swhkd/src/daemon.rs

@@ -23,6 +23,7 @@ use tokio::select;
 use tokio::time::Duration;
 use tokio::time::{sleep, Instant};
 use tokio_stream::{StreamExt, StreamMap};
+use tokio_udev::{AsyncMonitorSocket, EventType, MonitorBuilder};
 
 mod config;
 mod perms;
@@ -183,6 +184,9 @@ async fn main() -> Result<(), Box<dyn Error>> {
         }
     };
 
+    let mut udev =
+        AsyncMonitorSocket::new(MonitorBuilder::new()?.match_subsystem("input")?.listen()?)?;
+
     let modifiers_map: HashMap<Key, config::Modifier> = HashMap::from([
         (Key::KEY_LEFTMETA, config::Modifier::Super),
         (Key::KEY_RIGHTMETA, config::Modifier::Super),
@@ -275,6 +279,54 @@ async fn main() -> Result<(), Box<dyn Error>> {
                 }
             }
 
+            Some(Ok(event)) = udev.next() => {
+                if !event.is_initialized() {
+                    log::warn!("Received udev event with uninitialized device.");
+                }
+                match event.event_type() {
+                    EventType::Add => {
+                        if let Some(devnode) = event.devnode() {
+                            let mut device = match Device::open(devnode) {
+                                Err(e) => {
+                                    log::error!("Could not open evdev device at {}: {}", devnode.to_string_lossy(), e);
+                                    continue;
+                                },
+                                Ok(device) => device
+                            };
+                            if arg_devices.contains(&device.name().unwrap_or("")) || check_device_is_keyboard(&device) {
+                                log::info!("Device '{}' at '{}' added.", &device.name().unwrap_or(""), devnode.to_string_lossy());
+                                let _ = device.grab();
+                                keyboard_states.push(KeyboardState::new());
+                                keyboard_stream_map.insert(keyboard_states.len() - 1, device.into_event_stream()?);
+                            }
+                        }
+                    }
+                    EventType::Remove => {
+                        let udev_physical_path = event.property_value("PHYS")
+                            .and_then(|os_str| os_str.to_str())
+                            .map(|s| s.replace('\"', ""));
+                        keyboard_stream_map
+                            .iter()
+                            .filter(|(_, stream)| stream.device().physical_path() == udev_physical_path.as_deref())
+                            .map(|(key, _)| *key)
+                            // Collect all to not remove values while iterating
+                            .collect::<Vec<_>>()
+                            .into_iter()
+                            // Reverse to avoid dealing with changing indices for the keyboard_states vector
+                            .rev()
+                            .for_each(|key| {
+                                keyboard_states.remove(key);
+                                if let Some(stream) = keyboard_stream_map.remove(&key) {
+                                    log::info!("Device '{}' removed", stream.device().name().unwrap_or(""));
+                                }
+                            });
+                    }
+                    _ => {
+                        log::trace!("Ignored udev event of type: {:?}", event.event_type());
+                    }
+                }
+            }
+
             Some((i, Ok(event))) = keyboard_stream_map.next() => {
                 let keyboard_state = &mut keyboard_states[i];