Whatever??

Author: Narsil

src/linux/wayland/simulate.rs

@@ -5,8 +5,9 @@ use input_linux::{
     EventKind, EventTime, InputEvent, InputId, Key as UKey, KeyEvent, KeyState, RelativeAxis,
     RelativeEvent, SynchronizeEvent, SynchronizeKind, UInputHandle,
 };
-use libc::input_event;
+use libc::{input_event, O_NONBLOCK};
 use std::fs::{File, OpenOptions};
+use std::os::unix::fs::OpenOptionsExt;
 use std::sync::{LazyLock, Mutex};
 
 static HANDLE: LazyLock<Mutex<Option<UInputHandle<File>>>> = LazyLock::new(|| Mutex::new(None));
@@ -17,8 +18,11 @@ impl Handle {
     pub fn new() -> Self {
         let mut handle = HANDLE.lock().unwrap();
         if handle.is_none() {
-            let file = OpenOptions::new().write(true).open("/dev/uinput").unwrap();
-            // let file = File::open("/dev/uinput").unwrap();
+            let file = OpenOptions::new()
+                .write(true)
+                .custom_flags(O_NONBLOCK)
+                .open("/dev/uinput")
+                .unwrap();
             let uinput = UInputHandle::new(file);
             uinput.set_evbit(EventKind::Key).unwrap();
             uinput.set_evbit(EventKind::Relative).unwrap();
@@ -44,29 +48,35 @@ impl Handle {
         Handle
     }
 
+    fn send_key_event(
+        &self,
+        handle: &UInputHandle<File>,
+        ukey: UKey,
+        state: KeyState,
+    ) -> Result<(), SimulateError> {
+        const ZERO: EventTime = EventTime::new(0, 0);
+        let event = KeyEvent::new(ZERO, ukey, state);
+        let event: input_event = InputEvent::from(event).into();
+        let sync = SynchronizeEvent::new(ZERO, SynchronizeKind::Report, 0);
+        let sync: input_event = InputEvent::from(sync).into();
+
+        handle.write(&[event, sync]).map_err(|_| SimulateError)?;
+        Ok(())
+    }
+
     pub fn send(&self, event: &EventType) -> Result<(), SimulateError> {
         let handle = HANDLE.lock().unwrap();
         if let Some(handle) = handle.as_ref() {
             const ZERO: EventTime = EventTime::new(0, 0);
             match event {
                 EventType::KeyPress(key) => {
                     if let Some(ukey) = ukey_from_key(*key) {
-                        let event = KeyEvent::new(ZERO, ukey, KeyState::PRESSED);
-                        let event: input_event = InputEvent::from(event).into();
-                        let sync = SynchronizeEvent::new(ZERO, SynchronizeKind::Report, 0);
-                        let sync: input_event = InputEvent::from(sync).into();
-                        eprintln!("Writing it");
-                        handle.write(&[event, sync]).map_err(|_| SimulateError)?;
-                        eprintln!("Could write it.");
+                        self.send_key_event(handle, ukey, KeyState::PRESSED)?;
                     }
                 }
                 EventType::KeyRelease(key) => {
                     if let Some(ukey) = ukey_from_key(*key) {
-                        let event = KeyEvent::new(ZERO, ukey, KeyState::RELEASED);
-                        let event: input_event = InputEvent::from(event).into();
-                        let sync = SynchronizeEvent::new(ZERO, SynchronizeKind::Report, 0);
-                        let sync: input_event = InputEvent::from(sync).into();
-                        handle.write(&[event, sync]).map_err(|_| SimulateError)?;
+                        self.send_key_event(handle, ukey, KeyState::RELEASED)?;
                     }
                 }
                 EventType::ButtonPress(button) => {