refactor(kbt): simplify key stream backend (#12)

* Reduce CPU usage by removing endless loops * Remove errors being spilled to stdout
bloznelis · Jul 28, 2023 · 55de704 · 55de704
1 parent 5144a72
commit 55de704
Show file tree

Hide file tree

Showing 3 changed files with 33 additions and 55 deletions.
diff --git a/src/backend.rs b/src/backend.rs
diff --git a/src/linux.rs → src/generic_backend.rs b/src/linux.rs → src/generic_backend.rs
@@ -1,58 +1,45 @@
-use std::{
-    sync::{mpsc::Sender, Arc, Mutex},
-    thread,
-};
+use std::sync::{mpsc::Sender, Arc, Mutex};
+
+use device_query_revamped::{CallbackGuard, DeviceEvents, DeviceState, Keycode};
 
 use crate::{
-    backend::KeyBackend,
     key::Key,
     model::{AppEvent, KeyEventType},
 };
-use device_query_revamped::{DeviceEvents, DeviceState, Keycode};
-
-pub struct X11;
 
-impl KeyBackend for X11 {
-    fn subscribe(&self, sender: Sender<AppEvent>) -> Result<(), crate::model::KbtError> {
-        let shared_sender = Arc::new(Mutex::new(sender.clone()));
+pub struct GenericKeyBackend;
 
-        thread::spawn(move || {
-            let device_state = DeviceState::new();
-            let _guard = device_state.on_key_down(move |keycode| {
-                shared_sender
-                    .lock()
-                    .unwrap()
-                    .send(AppEvent::KeyEvent(KeyEventType::KeyPressed(map_keycode(
-                        keycode,
-                    ))))
-                    .map_err(|err| log::error!("Key down channel died {}", err))
-                    .unwrap();
-                ()
-            });
+type KeycodeCallback = Box<dyn Fn(&Keycode) -> () + Send + Sync + 'static>;
+type KeyStreamGuard = CallbackGuard<KeycodeCallback>;
 
-            loop {}
-        });
+impl GenericKeyBackend {
+    pub fn subscribe(sender: &Sender<AppEvent>) -> (KeyStreamGuard, KeyStreamGuard) {
+        let device_state = DeviceState::new();
+        let shared_sender = Arc::new(Mutex::new(sender.clone()));
 
-        let shared_sender = Arc::new(Mutex::new(sender));
+        let key_up_guard: KeyStreamGuard = device_state.on_key_up(Box::new(move |keycode| {
+            let _ = shared_sender
+                .lock()
+                .unwrap()
+                .send(AppEvent::KeyEvent(KeyEventType::KeyReleased(map_keycode(
+                    keycode,
+                ))))
+                .map_err(|err| log::error!("Key down channel died {}", err));
+        }));
 
-        thread::spawn(move || {
-            let device_state = DeviceState::new();
-            let _guard = device_state.on_key_up(move |keycode| {
-                shared_sender
-                    .lock()
-                    .unwrap()
-                    .send(AppEvent::KeyEvent(KeyEventType::KeyReleased(map_keycode(
-                        keycode,
-                    ))))
-                    .map_err(|err| log::error!("Key up channel died {}", err))
-                    .unwrap();
-                ()
-            });
+        let shared_sender = Arc::new(Mutex::new(sender.clone()));
 
-            loop {}
-        });
+        let key_down_guard: KeyStreamGuard = device_state.on_key_down(Box::new(move |keycode| {
+            let _ = shared_sender
+                .lock()
+                .unwrap()
+                .send(AppEvent::KeyEvent(KeyEventType::KeyPressed(map_keycode(
+                    keycode,
+                ))))
+                .map_err(|err| log::error!("Key down channel died {}", err));
+        }));
 
-        Ok(())
+        (key_up_guard, key_down_guard)
     }
 }
 

diff --git a/src/main.rs b/src/main.rs
@@ -1,11 +1,10 @@
-mod backend;
 mod key;
 mod keyboard60;
 mod keyboard80;
-mod linux;
 mod menu;
 mod model;
 mod view;
+mod generic_backend;
 
 use std::{
     collections::HashMap,
@@ -14,13 +13,12 @@ use std::{
     thread,
 };
 
-use backend::KeyBackend;
 use crossterm::{
     event::{self, DisableMouseCapture, Event, KeyCode, KeyModifiers},
     execute,
     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
 };
-use linux::X11;
+use generic_backend::GenericKeyBackend;
 use model::*;
 use ratatui::{
     backend::{Backend, CrosstermBackend},
@@ -58,7 +56,7 @@ fn run() -> Result<(), KbtError> {
         MenuResult::Terminate => Ok(()),
         MenuResult::KeyboardSelected(selection) => {
             let (sender, receiver): (Sender<AppEvent>, Receiver<AppEvent>) = channel();
-            X11.subscribe(sender.clone()).unwrap();
+            let (_up_guard, _down_guard) = GenericKeyBackend::subscribe(&sender);
             thread::spawn(move || listen_for_control(sender).unwrap());
 
             let initial_app = App {