feat: referesh() as member of Daemon

Removes detached boards, adds new ones.

Currently unused/untested in frontend.

Author: ids1024

backend/src/daemon/dummy.rs

@@ -125,6 +125,10 @@ impl Daemon for DaemonDummy {
         Ok(())
     }
 
+    fn refresh(&self) -> Result<(), String> {
+        Ok(())
+    }
+
     fn exit(&self) -> Result<(), String> {
         Ok(())
     }

backend/src/daemon/mod.rs

@@ -105,6 +105,7 @@ macro_rules! commands {
 commands! {
     fn boards(&self) -> Result<Vec<BoardId>, String>;
     fn model(&self, board: BoardId) -> Result<String, String>;
+    fn refresh(&self) -> Result<(), String>;
     fn keymap_get(&self, board: BoardId, layer: u8, output: u8, input: u8) -> Result<u16, String>;
     fn keymap_set(&self, board: BoardId, layer: u8, output: u8, input: u8, value: u16) -> Result<(), String>;
     fn matrix_get(&self, board: BoardId) -> Result<Matrix, String>;

backend/src/daemon/s76power.rs

@@ -213,6 +213,10 @@ impl Daemon for DaemonS76Power {
         Err("Unimplemented".to_string())
     }
 
+    fn refresh(&self) -> Result<(), String> {
+        Ok(())
+    }
+
     fn exit(&self) -> Result<(), String> {
         Ok(())
     }

backend/src/daemon/server.rs

@@ -70,7 +70,7 @@ impl<R: Read, W: Write> DaemonServer<R, W> {
             board_ids: RefCell::new(board_ids),
         };
 
-        self_.refresh();
+        self_.refresh()?;
 
         Ok(self_)
     }
@@ -88,59 +88,6 @@ impl<R: Read, W: Write> DaemonServer<R, W> {
         false
     }
 
-    fn refresh(&self) {
-        if let Some(api) = &mut *self.hidapi.borrow_mut() {
-            if let Err(err) = api.refresh_devices() {
-                error!("Failed to refresh hidapi devices: {}", err);
-            }
-            for info in api.device_list() {
-                match (info.vendor_id(), info.product_id(), info.interface_number()) {
-                    // System76 launch_1
-                    //TODO: better way to determine this
-                    (0x3384, 0x0001, 1) => {
-                        // Skip if device already open
-                        if self.have_device(&info) {
-                            continue;
-                        }
-
-                        match info.open_device(&api) {
-                            Ok(device) => match AccessHid::new(device, 10, 100) {
-                                Ok(access) => match unsafe { Ec::new(access) } {
-                                    Ok(ec) => {
-                                        info!("Adding USB HID EC at {:?}", info.path());
-                                        let id = BoardId(Uuid::new_v4().as_u128());
-                                        self.boards
-                                            .borrow_mut()
-                                            .insert(id, (ec.into_dyn(), Some(info.clone())));
-                                        self.board_ids.borrow_mut().push(id);
-                                    }
-                                    Err(err) => {
-                                        error!(
-                                            "Failed to probe USB HID EC at {:?}: {:?}",
-                                            info.path(),
-                                            err
-                                        );
-                                    }
-                                },
-                                Err(err) => {
-                                    error!(
-                                        "Failed to access USB HID EC at {:?}: {:?}",
-                                        info.path(),
-                                        err
-                                    );
-                                }
-                            },
-                            Err(err) => {
-                                error!("Failed to open USB HID EC at {:?}: {:?}", info.path(), err);
-                            }
-                        }
-                    }
-                    _ => (),
-                }
-            }
-        }
-    }
-
     pub fn run(mut self) -> io::Result<()> {
         println!("Daemon started");
 
@@ -265,6 +212,69 @@ impl<R: Read, W: Write> Daemon for DaemonServer<R, W> {
         unsafe { ec.led_save().map_err(err_str) }
     }
 
+    fn refresh(&self) -> Result<(), String> {
+        if let Some(api) = &mut *self.hidapi.borrow_mut() {
+            // Remove USB boards that are no longer attached
+            {
+                let mut boards = self.boards.borrow_mut();
+                let mut board_ids = self.board_ids.borrow_mut();
+
+                boards.retain(|_, (ec, _)| unsafe {
+                    !(ec.access().is::<AccessHid>() && ec.probe().is_err())
+                });
+                board_ids.retain(|i| boards.contains_key(i));
+            }
+
+            if let Err(err) = api.refresh_devices() {
+                error!("Failed to refresh hidapi devices: {}", err);
+            }
+
+            for info in api.device_list() {
+                match (info.vendor_id(), info.product_id(), info.interface_number()) {
+                    // System76 launch_1
+                    //TODO: better way to determine this
+                    (0x3384, 0x0001, 1) => {
+                        // Skip if device already open
+                        if self.have_device(&info) {
+                            continue;
+                        }
+
+                        match info.open_device(&api) {
+                            Ok(device) => match AccessHid::new(device, 10, 100) {
+                                Ok(access) => match unsafe { Ec::new(access) } {
+                                    Ok(ec) => {
+                                        info!("Adding USB HID EC at {:?}", info.path());
+                                        let id = BoardId(Uuid::new_v4().as_u128());
+                                        self.boards
+                                            .borrow_mut()
+                                            .insert(id, (ec.into_dyn(), Some(info.clone())));
+                                        self.board_ids.borrow_mut().push(id);
+                                    }
+                                    Err(err) => error!(
+                                        "Failed to probe USB HID EC at {:?}: {:?}",
+                                        info.path(),
+                                        err
+                                    ),
+                                },
+                                Err(err) => error!(
+                                    "Failed to access USB HID EC at {:?}: {:?}",
+                                    info.path(),
+                                    err
+                                ),
+                            },
+                            Err(err) => {
+                                error!("Failed to open USB HID EC at {:?}: {:?}", info.path(), err)
+                            }
+                        }
+                    }
+                    _ => (),
+                }
+            }
+        }
+
+        Ok(())
+    }
+
     fn exit(&self) -> Result<(), String> {
         self.running.set(false);
         Ok(())