small refactor

rog-core/src/daemon.rs

@@ -32,8 +32,8 @@ impl Daemon {
     pub fn start() -> Result<(), Box<dyn Error>> {
         let mut connection = Connection::new_system().map_or_else(
             |err| {
-                error!("{}", err);
+                error!("{:?}", err);
-                panic!("{}", err);
+                panic!("{:?}", err);
             },
             |dbus| {
                 info!("DBus connected");
@@ -69,7 +69,7 @@ impl Daemon {
                                             Ok(vec![mret])
                                         }
                                         Err(err) => {
-                                            warn!("{}", err);
+                                            warn!("{:?}", err);
                                             Err(MethodErr::failed(&err))
                                         }
                                     }
@@ -90,7 +90,7 @@ impl Daemon {
             connection
                 .process(Duration::from_millis(10))
                 .unwrap_or_else(|err| {
-                    error!("{}", err);
+                    error!("{:?}", err);
                     false
                 });
             // READ KEYBOARD
@@ -104,16 +104,14 @@ impl Daemon {
                     let laptop = borrowed_daemon.rogcore.laptop();
 
                     if let Some(_count) = read {
-                        if key_buf[0] == laptop.hotkey_group_byte() {
+                        laptop
-                            laptop
+                            .do_hotkey_action(&mut rogcore, key_buf[1])
-                                .do_hotkey_action(&mut rogcore, key_buf[1])
+                            .unwrap_or_else(|err| {
-                                .unwrap_or_else(|err| {
+                                warn!("{:?}", err);
-                                    warn!("{}", err);
+                            });
-                                });
-                        }
                     }
                 }
-                Err(err) => error!("{}", err),
+                Err(err) => error!("{:?}", err),
             }
         }
     }

rog-lib/src/core.rs

@@ -36,6 +36,7 @@ pub struct RogCore {
     initialised: bool,
     led_interface_num: u8,
     keys_interface_num: u8,
+    keys_endpoint: u8,
     config: Config,
     laptop: RefCell<Box<dyn Laptop>>,
 }
@@ -51,10 +52,11 @@ impl RogCore {
         // Interface with outputs
         let mut led_interface_num = 0;
         let mut keys_interface_num = 0;
+        let keys_endpoint = 0x83;
         for iface in dev_config.interfaces() {
             for desc in iface.descriptors() {
                 for endpoint in desc.endpoint_descriptors() {
-                    if endpoint.address() == 0x83 {
+                    if endpoint.address() == keys_endpoint {
                         keys_interface_num = desc.interface_number();
                     } else if endpoint.address() == laptop.led_iface_num() {
                         led_interface_num = desc.interface_number();
@@ -71,6 +73,7 @@ impl RogCore {
             initialised: false,
             led_interface_num,
             keys_interface_num,
+            keys_endpoint,
             config: Config::default().read(),
             laptop: RefCell::new(laptop),
         })
@@ -95,36 +98,43 @@ impl RogCore {
         for device in rusb::devices().unwrap().iter() {
             let device_desc = device.device_descriptor().unwrap();
             if device_desc.vendor_id() == vendor && device_desc.product_id() == product {
-                return device.open().map_err(|err| AuraError::from(err));
+                return device.open().map_err(|err| AuraError::UsbError(err));
             }
         }
-        Err(AuraError::from(rusb::Error::NoDevice))
+        Err(AuraError::UsbError(rusb::Error::NoDevice))
+    }
+
+    fn aura_write(&mut self, message: &[u8]) -> Result<(), AuraError> {
+        self.handle
+            .write_control(0x21, 0x09, 0x035D, 0, message, Duration::new(0, 5))
+            .map_err(|err| AuraError::UsbError(err))?;
+        Ok(())
     }
 
     fn aura_write_messages(&mut self, messages: &[&[u8]]) -> Result<(), AuraError> {
-        self.handle.claim_interface(self.led_interface_num)?;
+        self.handle
-        // Declared as a zoomy so that it is hidden
+            .claim_interface(self.led_interface_num)
-        let write = |message: &[u8]| {
+            .map_err(|err| AuraError::UsbError(err))?;
-            self.handle
-                .write_control(0x21, 0x09, 0x035D, 0, message, Duration::new(0, 5))
-        };
 
         if !self.initialised {
-            write(&LED_INIT1)?;
+            self.aura_write(&LED_INIT1)?;
-            write(LED_INIT2.as_bytes())?;
+            self.aura_write(LED_INIT2.as_bytes())?;
-            write(&LED_INIT3)?;
+            self.aura_write(&LED_INIT3)?;
-            write(LED_INIT4.as_bytes())?;
+            self.aura_write(LED_INIT4.as_bytes())?;
-            write(&LED_INIT5)?;
+            self.aura_write(&LED_INIT5)?;
+            self.initialised = true;
         }
 
         for message in messages {
-            write(*message)?;
+            self.aura_write(*message)?;
-            write(&LED_SET)?;
+            self.aura_write(&LED_SET)?;
         }
         // Changes won't persist unless apply is set
-        write(&LED_APPLY)?;
+        self.aura_write(&LED_APPLY)?;
 
-        self.handle.release_interface(self.led_interface_num)?;
+        self.handle
+            .release_interface(self.led_interface_num)
+            .map_err(|err| AuraError::UsbError(err))?;
         Ok(())
     }
 
@@ -154,24 +164,27 @@ impl RogCore {
     }
 
     pub fn poll_keyboard(&mut self, buf: &mut [u8; 32]) -> Result<Option<usize>, AuraError> {
-        self.handle.claim_interface(self.keys_interface_num)?;
+        self.handle
-        match self
+            .claim_interface(self.keys_interface_num)
-            .handle
+            .map_err(|err| AuraError::UsbError(err))?;
-            .read_interrupt(0x83, buf, Duration::from_micros(10))
+        let res =
-        {
+            match self
-            Ok(o) => {
+                .handle
-                if buf[0] == self.laptop.borrow().hotkey_group_byte() {
+                .read_interrupt(self.keys_endpoint, buf, Duration::from_micros(10))
-                    self.handle.release_interface(self.keys_interface_num)?;
+            {
-                    return Ok(Some(o));
+                Ok(o) => {
+                    if self.laptop.borrow().hotkey_group_bytes().contains(&buf[0]) {
+                        Ok(Some(o))
+                    } else {
+                        Ok(None)
+                    }
                 }
-            }
+                Err(err) => Err(AuraError::UsbError(err)),
-            Err(err) => {
+            };
-                self.handle.release_interface(self.keys_interface_num)?;
+        self.handle
-                return Err(AuraError::from(err));
+            .release_interface(self.keys_interface_num)
-            }
+            .map_err(|err| AuraError::UsbError(err))?;
-        }
+        res
-        self.handle.release_interface(self.keys_interface_num)?;
-        Ok(None)
     }
 
     pub fn suspend(&self) {

rog-lib/src/error.rs

@@ -16,7 +16,7 @@ pub enum AuraError {
     #[error("mode not supported")]
     NotSupported,
     #[error("USB error")]
-    UsbError(#[from] rusb::Error),
+    UsbError(rusb::Error),
     #[error("IO error")]
     IOError(#[from] std::io::Error),
     #[error("external command failed")]

rog-lib/src/laptops.rs

@@ -24,7 +24,7 @@ pub fn match_laptop() -> Result<Box<dyn Laptop>, AuraError> {
 /// map.
 pub trait Laptop {
     fn do_hotkey_action(&self, core: &mut RogCore, key_byte: u8) -> Result<(), AuraError>;
-    fn hotkey_group_byte(&self) -> u8;
+    fn hotkey_group_bytes(&self) -> &[u8];
     fn led_iface_num(&self) -> u8;
     fn supported_modes(&self) -> &[BuiltInModeByte];
     fn usb_vendor(&self) -> u16;
@@ -38,7 +38,7 @@ pub struct LaptopGX502GW {
     usb_product: u16,
     board_name: &'static str,
     prod_family: &'static str,
-    hotkey_group_byte: u8,
+    hotkey_group_bytes: [u8; 2],
     min_led_bright: u8,
     max_led_bright: u8,
     led_iface_num: u8,
@@ -54,7 +54,7 @@ impl LaptopGX502GW {
             usb_product: 0x1866,
             board_name: "GX502GW",
             prod_family: "Zephyrus S",
-            hotkey_group_byte: 0x5a,
+            hotkey_group_bytes: [0x5a, 0x02],
             min_led_bright: 0x00,
             max_led_bright: 0x03,
             led_iface_num: 0x81,
@@ -141,14 +141,14 @@ impl Laptop for LaptopGX502GW {
             }
             _ => {
                 if key_byte != 0 {
-                    info!("Unmapped key: {}", &key_byte);
+                    info!("Unmapped key: {:X?}", &key_byte);
                 }
             }
         }
         Ok(())
     }
-    fn hotkey_group_byte(&self) -> u8 {
+    fn hotkey_group_bytes(&self) -> &[u8] {
-        self.hotkey_group_byte
+        &self.hotkey_group_bytes
     }
     fn supported_modes(&self) -> &[BuiltInModeByte] {
         &self.supported_modes