improv: Better abstract backend crate with a Backend object

Author: ids1024

backend/src/daemon/server.rs

@@ -61,18 +61,14 @@ impl<R: Read, W: Write> DaemonServer<R, W> {
             }
         };
 
-        let self_ = Self {
+        Ok(Self {
             hidapi: RefCell::new(hidapi),
             running: Cell::new(true),
             read: BufReader::new(read),
             write,
             boards: RefCell::new(boards),
             board_ids: RefCell::new(board_ids),
-        };
-
-        self_.refresh()?;
-
-        Ok(self_)
+        })
     }
 
     fn have_device(&self, info: &DeviceInfo) -> bool {

backend/src/lib.rs

@@ -1,6 +1,19 @@
 #[macro_use]
 extern crate log;
 
+use glib::{
+    prelude::*,
+    subclass::{prelude::*, Signal},
+};
+use once_cell::sync::Lazy;
+use std::{
+    cell::RefCell,
+    collections::{HashMap, HashSet},
+    iter::FromIterator,
+    process,
+    rc::Rc,
+};
+
 mod board;
 mod color;
 mod daemon;
@@ -13,6 +26,127 @@ mod mode;
 mod rect;
 
 pub use self::{
-    board::*, color::*, daemon::*, deref_cell::*, key::*, keymap::*, layer::*, layout::*, mode::*,
-    rect::*,
+    board::*, color::*, deref_cell::*, key::*, keymap::*, layer::*, layout::*, mode::*, rect::*,
 };
+use daemon::*;
+
+#[derive(Default)]
+pub struct BackendInner {
+    daemon: DerefCell<Rc<dyn Daemon>>,
+    ids: RefCell<HashSet<BoardId>>,
+    boards: RefCell<HashMap<BoardId, Board>>,
+}
+
+#[glib::object_subclass]
+impl ObjectSubclass for BackendInner {
+    const NAME: &'static str = "S76KeyboardBackend";
+    type ParentType = glib::Object;
+    type Type = Backend;
+}
+
+impl ObjectImpl for BackendInner {
+    fn signals() -> &'static [Signal] {
+        static SIGNALS: Lazy<Vec<Signal>> = Lazy::new(|| {
+            vec![
+                Signal::builder(
+                    "board-added",
+                    &[Board::static_type().into()],
+                    glib::Type::UNIT.into(),
+                )
+                .build(),
+                Signal::builder(
+                    "board-removed",
+                    &[Board::static_type().into()],
+                    glib::Type::UNIT.into(),
+                )
+                .build(),
+            ]
+        });
+        SIGNALS.as_ref()
+    }
+}
+
+glib::wrapper! {
+    pub struct Backend(ObjectSubclass<BackendInner>);
+}
+
+impl Backend {
+    fn new_internal<T: Daemon + 'static>(daemon: T) -> Result<Self, String> {
+        let self_ = glib::Object::new::<Self>(&[]).unwrap();
+        self_.inner().daemon.set(Rc::new(daemon));
+        Ok(self_)
+    }
+
+    pub fn new_dummy(board_names: Vec<String>) -> Result<Self, String> {
+        Self::new_internal(DaemonDummy::new(board_names))
+    }
+
+    pub fn new_s76power() -> Result<Self, String> {
+        Self::new_internal(DaemonS76Power::new()?)
+    }
+
+    pub fn new_pkexec() -> Result<Self, String> {
+        Self::new_internal(DaemonClient::new_pkexec())
+    }
+
+    pub fn new() -> Result<Self, String> {
+        Self::new_internal(DaemonServer::new_stdio()?)
+    }
+
+    fn inner(&self) -> &BackendInner {
+        BackendInner::from_instance(self)
+    }
+
+    pub fn refresh(&self) {
+        if let Err(err) = self.inner().daemon.refresh() {
+            error!("Failed to refresh boards: {}", err);
+        }
+
+        let mut ids = self.inner().ids.borrow_mut();
+        let new_ids = HashSet::from_iter(self.inner().daemon.boards().unwrap().into_iter());
+
+        let mut boards = self.inner().boards.borrow_mut();
+
+        // Removed boards
+        for i in ids.difference(&new_ids) {
+            self.emit_by_name("board-removed", &[&boards[i]]).unwrap();
+            boards.remove(i);
+        }
+
+        // Added boards
+        // TODO: emit in correct order
+        for i in new_ids.difference(&ids) {
+            match Board::new(self.inner().daemon.clone(), *i) {
+                Ok(board) => {
+                    boards.insert(*i, board.clone());
+                    self.emit_by_name("board-added", &[&board]).unwrap();
+                }
+                Err(err) => error!("Failed to add board: {}", err),
+            }
+        }
+
+        *ids = new_ids;
+    }
+
+    pub fn connect_board_added<F: Fn(Board) + 'static>(&self, cb: F) {
+        self.connect_local("board-added", false, move |values| {
+            cb(values[1].get::<Board>().unwrap().unwrap());
+            None
+        })
+        .unwrap();
+    }
+
+    pub fn connect_board_removed<F: Fn(Board) + 'static>(&self, cb: F) {
+        self.connect_local("board-removed", false, move |values| {
+            cb(values[1].get::<Board>().unwrap().unwrap());
+            None
+        })
+        .unwrap();
+    }
+}
+
+pub fn run_daemon() -> ! {
+    let server = DaemonServer::new_stdio().expect("Failed to create server");
+    server.run().expect("Failed to run server");
+    process::exit(0)
+}

src/application/main_window.rs

@@ -4,18 +4,16 @@ use gtk::prelude::*;
 use gtk::subclass::prelude::*;
 use std::{
     cell::RefCell,
-    collections::HashSet,
-    rc::Rc,
     sync::atomic::{AtomicUsize, Ordering},
 };
 
 use super::{shortcuts_window, ConfiguratorApp, Keyboard, KeyboardLayer, Page, Picker};
 use crate::DerefCell;
-use backend::{Board, Daemon, DaemonClient, DaemonDummy, DaemonServer};
+use backend::{Backend, Board};
 
 #[derive(Default)]
 pub struct MainWindowInner {
-    daemon: DerefCell<Rc<dyn Daemon>>,
+    backend: DerefCell<Backend>,
     back_button: DerefCell<gtk::Button>,
     count: AtomicUsize,
     header_bar: DerefCell<gtk::HeaderBar>,
@@ -167,65 +165,34 @@ impl MainWindow {
         let window: Self = glib::Object::new(&[]).unwrap();
         app.add_window(&window);
 
-        let daemon = daemon();
-
-        for i in daemon.boards().expect("Failed to load boards") {
-            match Board::new(daemon.clone(), i) {
-                Ok(board) => window.add_keyboard(board),
-                Err(err) => error!("{}", err),
-            }
-        }
+        let backend = cascade! {
+            daemon();
+            ..connect_board_added(clone!(@weak window => move |board| window.add_keyboard(board)));
+            ..connect_board_removed(clone!(@weak window => move |board| {
+                let mut boards = window.inner().keyboards.borrow_mut();
+                if let Some(idx) = boards.iter().position(|(kb, _)| kb.board() == &board) {
+                    let (keyboard, row) = boards.remove(idx);
+                    window.inner().stack.remove(&keyboard);
+                    window.inner().keyboard_list_box.remove(&row);
+                }
+            }));
+            ..refresh();
+        };
 
         let phony_board_names = app.phony_board_names().to_vec();
         if !phony_board_names.is_empty() {
-            let daemon = Rc::new(DaemonDummy::new(phony_board_names));
-
-            for i in daemon.boards().unwrap() {
-                match Board::new(daemon.clone(), i) {
-                    Ok(board) => window.add_keyboard(board),
-                    Err(err) => error!("{}", err),
-                }
-            }
+            let backend = Backend::new_dummy(phony_board_names).unwrap();
+            backend.connect_board_added(
+                clone!(@weak window => move |board| window.add_keyboard(board)),
+            );
+            backend.refresh();
         }
 
-        window.inner().daemon.set(daemon);
+        window.inner().backend.set(backend);
         glib::timeout_add_seconds_local(
             1,
             clone!(@weak window => move || {
-                let daemon = &*window.inner().daemon;
-
-                if let Err(err) = daemon.refresh() {
-                    error!("Failed to refresh boards: {}", err);
-                }
-
-                let boards = match daemon.boards() {
-                    Ok(boards) => boards,
-                    Err(_) => return glib::Continue(true),
-                };
-
-                // Remove boards that aren't detected now
-                let mut ids = HashSet::new();
-                window.inner().keyboards.borrow_mut().retain(|(keyboard, row)| {
-                    let board = keyboard.board().board();
-                    ids.insert(board);
-                    if boards.iter().find(|i| **i == board).is_none() {
-                        window.inner().stack.remove(keyboard);
-                        window.inner().keyboard_list_box.remove(row);
-                        return false;
-                    }
-                    true
-                });
-
-                // Add new boards
-                for i in boards {
-                    if !ids.contains(&i) {
-                        match Board::new(daemon.clone(), i) {
-                            Ok(board) => window.add_keyboard(board),
-                            Err(err) => error!("{}", err),
-                        }
-                    }
-                }
-
+                window.inner().backend.refresh();
                 glib::Continue(true)
             }),
         );
@@ -319,14 +286,15 @@ impl MainWindow {
 }
 
 #[cfg(target_os = "linux")]
-fn daemon() -> Rc<dyn Daemon> {
+fn daemon() -> Backend {
     if unsafe { libc::geteuid() == 0 } {
         info!("Already running as root");
-        Rc::new(DaemonServer::new_stdio().expect("Failed to create server"))
+        Backend::new()
     } else {
         info!("Not running as root, spawning daemon with pkexec");
-        Rc::new(DaemonClient::new_pkexec())
+        Backend::new_pkexec()
     }
+    .expect("Failed to create server")
 }
 
 #[cfg(not(target_os = "linux"))]

src/keyboard_backlight_widget.rs

@@ -3,10 +3,9 @@
 use cascade::cascade;
 use glib::clone;
 use gtk::prelude::*;
-use std::rc::Rc;
 
 use crate::{KeyboardColor, KeyboardColorIndex};
-use backend::{Board, Daemon, DaemonS76Power};
+use backend::{Backend, Board};
 
 pub fn keyboard_backlight_widget() -> gtk::Widget {
     let stack = cascade! {
@@ -34,17 +33,11 @@ pub fn keyboard_backlight_widget() -> gtk::Widget {
 }
 
 fn add_boards(stack: &gtk::Stack) -> Result<(), String> {
-    let daemon = Rc::new(DaemonS76Power::new()?);
-
-    for i in daemon.boards()? {
-        match Board::new(daemon.clone(), i) {
-            Ok(board) => {
-                let name = board.model().to_owned();
-                stack.add_titled(&page(board), &name, &name);
-            }
-            Err(err) => error!("{}", err),
-        }
-    }
+    let backend = Backend::new_s76power()?;
+    backend.connect_board_added(clone!(@weak stack => move |board| {
+        let name = board.model().to_owned();
+        stack.add_titled(&page(board), &name, &name);
+    }));
 
     Ok(())
 }

src/main.rs

@@ -2,7 +2,7 @@
 
 use std::env;
 use std::process;
-use system76_keyboard_configurator::{application, backend::DaemonServer};
+use system76_keyboard_configurator::application;
 
 fn main() {
     env_logger::Builder::from_env(
@@ -15,9 +15,7 @@ fn main() {
     let args = env::args().collect::<Vec<_>>();
     for arg in args.iter().skip(1) {
         if arg.as_str() == "--daemon" {
-            let server = DaemonServer::new_stdio().expect("Failed to create server");
-            server.run().expect("Failed to run server");
-            return;
+            backend::run_daemon();
         }
     }