Add idle inhibit on joystick input

Merge wljoywake branch adding functionality akin to the wljoywake branch
handling idle_inhibition on joystick input

https://github.com/nowrep/wljoywake

Cargo.toml

@@ -10,8 +10,11 @@ anyhow = "1.0.75"
 bytemuck = "1.18.0"
 clap = { version = "4.4.8", features = ["derive"] }
 env_logger = "0.10.1"
+evdev = { version = "0.12.2", features = ["tokio"] }
 futures = { version = "0.3.29", features = ["compat"] }
 inotify = "0.10.2"
+lazy_static = "1.5.0"
+libc = "0.2.161"
 log = "0.4.20"
 mlua = { version = "0.9.1", features = ["async", "luau", "send"] }
 nix = { version = "0.29.0", features = ["fs", "poll", "signal", "time"] }

src/config.rs

@@ -1,2 +1,4 @@
 pub const APP_NAME: &str = "sleepwatcher-rs";
 pub const CONFIG_FILE_NAME: &str = "idle_config.lua";
+pub const CONFIG_FILE: &str = include_str!("../lua_configs/idle_config.lua");
+pub const TIMEOUT_SEC: u64 = 30;

src/dbus.rs

@@ -16,7 +16,7 @@ pub async fn upower_watcher(tx: mpsc::Sender<Request>) -> anyhow::Result<()> {
         while let Some(on_battery_changed) = power_stream.next().await {
             match on_battery_changed.get().await {
                 Ok(on_battery) => {
-                    let _ = tx.send(Request::OnBattery(on_battery)).await.unwrap();
+                    tx.send(Request::OnBattery(on_battery)).await.unwrap();
                 }
                 Err(e) => {
                     error!("Error, getting on_battery property {}", e)

src/joystick_handler.rs

@@ -0,0 +1,54 @@
+use evdev::{Device, InputEventKind};
+use log::{debug, info};
+use std::path::Path;
+use tokio::sync::mpsc;
+
+use crate::types::Request;
+
+#[derive(Debug)]
+pub struct JoystickHandler {
+    syspath: String,
+    tx: mpsc::Sender<Request>,
+}
+
+impl JoystickHandler {
+    pub fn new(syspath: String, tx: mpsc::Sender<Request>) -> Self {
+        Self { syspath, tx }
+    }
+
+    pub async fn js_handler(&self) -> anyhow::Result<()> {
+        let device_path = Path::new("/dev/input").join(&self.syspath);
+        let device = Device::open(device_path)?;
+        //let absinfo = device.get_abs_state();
+        let mut event_stream = device.into_event_stream()?;
+
+        loop {
+            tokio::select! {
+                ev = event_stream.next_event() => {
+                    match ev {
+                        Ok(ev) => {
+                            match ev.kind() {
+                                InputEventKind::Key(key) => {
+                                    debug!("Key event: {:?}, value: {}", key, ev.value());
+                                    self.tx.send(Request::Inhibit).await.unwrap();
+                                }
+                                // Ignore axis and synchronization events for now. For Axis events
+                                // it's not currently clear how to get absinfo
+                                InputEventKind::AbsAxis(..) => {
+                                }
+                                InputEventKind::Synchronization(..) =>  {}
+                                _ => {
+                                    debug!("Other event: {:?}", ev);
+                                }
+                            }
+                        }
+                        Err(e) => {
+                            info!("Error reading event: {:?}", e);
+                            break Ok(());
+                        }
+                    }
+                }
+            }
+        }
+    }
+}