Refactor: Make all Aura type devices use "device_manager"

Open the door to adding many other types of "aura" devices later.

asusd/src/aura_slash/config.rs

@@ -0,0 +1,54 @@
+use config_traits::{StdConfig, StdConfigLoad};
+use rog_slash::{DeviceState, SlashMode, SlashType};
+use serde::{Deserialize, Serialize};
+
+const CONFIG_FILE: &str = "slash.ron";
+
+/// Config for base system actions for the anime display
+#[derive(Deserialize, Serialize, Debug)]
+pub struct SlashConfig {
+    #[serde(skip)]
+    pub slash_type: SlashType,
+    pub slash_enabled: bool,
+    pub slash_brightness: u8,
+    pub slash_interval: u8,
+    pub slash_mode: SlashMode,
+}
+
+impl Default for SlashConfig {
+    fn default() -> Self {
+        SlashConfig {
+            slash_enabled: true,
+            slash_brightness: 255,
+            slash_interval: 0,
+            slash_mode: SlashMode::Bounce,
+            slash_type: SlashType::Unsupported,
+        }
+    }
+}
+impl StdConfig for SlashConfig {
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+}
+
+impl StdConfigLoad for SlashConfig {}
+
+impl From<&SlashConfig> for DeviceState {
+    fn from(config: &SlashConfig) -> Self {
+        DeviceState {
+            slash_enabled: config.slash_enabled,
+            slash_brightness: config.slash_brightness,
+            slash_interval: config.slash_interval,
+            slash_mode: config.slash_mode,
+        }
+    }
+}

asusd/src/aura_slash/mod.rs

@@ -0,0 +1,70 @@
+use std::sync::Arc;
+
+use config::SlashConfig;
+use rog_platform::hid_raw::HidRaw;
+use rog_platform::usb_raw::USBRaw;
+use rog_slash::usb::{pkt_set_mode, pkt_set_options, pkts_for_init};
+use rog_slash::SlashType;
+use tokio::sync::{Mutex, MutexGuard};
+
+use crate::error::RogError;
+
+pub mod config;
+pub mod trait_impls;
+
+#[derive(Debug, Clone)]
+pub struct Slash {
+    hid: Option<Arc<Mutex<HidRaw>>>,
+    usb: Option<Arc<Mutex<USBRaw>>>,
+    config: Arc<Mutex<SlashConfig>>,
+}
+
+impl Slash {
+    pub fn new(
+        hid: Option<Arc<Mutex<HidRaw>>>,
+        usb: Option<Arc<Mutex<USBRaw>>>,
+        config: Arc<Mutex<SlashConfig>>,
+    ) -> Self {
+        Self { hid, usb, config }
+    }
+
+    pub async fn lock_config(&self) -> MutexGuard<SlashConfig> {
+        self.config.lock().await
+    }
+
+    pub async fn write_bytes(&self, message: &[u8]) -> Result<(), RogError> {
+        if let Some(hid) = &self.hid {
+            hid.lock().await.write_bytes(message)?;
+        } else if let Some(usb) = &self.usb {
+            usb.lock().await.write_bytes(message)?;
+        }
+        Ok(())
+    }
+
+    /// Initialise the device if required. Locks the internal config so be wary
+    /// of deadlocks.
+    pub async fn do_initialization(&self) -> Result<(), RogError> {
+        // Don't try to initialise these models as the asus drivers already did
+        let config = self.config.lock().await;
+        if !matches!(config.slash_type, SlashType::GA605 | SlashType::GU605) {
+            for pkt in &pkts_for_init(config.slash_type) {
+                self.write_bytes(pkt).await?;
+            }
+        }
+
+        // Apply config upon initialization
+        let option_packets = pkt_set_options(
+            config.slash_type,
+            config.slash_enabled,
+            config.slash_brightness,
+            config.slash_interval,
+        );
+        self.write_bytes(&option_packets).await?;
+
+        let mode_packets = pkt_set_mode(config.slash_type, config.slash_mode);
+        // self.node.write_bytes(&mode_packets[0])?;
+        self.write_bytes(&mode_packets[1]).await?;
+
+        Ok(())
+    }
+}

asusd/src/aura_slash/trait_impls.rs

@@ -0,0 +1,190 @@
+use config_traits::StdConfig;
+use log::{debug, error, warn};
+use rog_slash::usb::{pkt_save, pkt_set_mode, pkt_set_options};
+use rog_slash::{DeviceState, SlashMode};
+use zbus::zvariant::OwnedObjectPath;
+use zbus::{interface, Connection};
+
+use super::Slash;
+use crate::error::RogError;
+use crate::Reloadable;
+
+#[derive(Clone)]
+pub struct SlashZbus(Slash);
+
+impl SlashZbus {
+    pub fn new(slash: Slash) -> Self {
+        Self(slash)
+    }
+
+    pub async fn start_tasks(
+        mut self,
+        connection: &Connection,
+        path: OwnedObjectPath,
+    ) -> Result<(), RogError> {
+        // let task = zbus.clone();
+        self.reload()
+            .await
+            .unwrap_or_else(|err| warn!("Controller error: {}", err));
+        connection
+            .object_server()
+            .at(path.clone(), self)
+            .await
+            .map_err(|e| error!("Couldn't add server at path: {path}, {e:?}"))
+            .ok();
+        Ok(())
+    }
+}
+
+#[interface(name = "org.asuslinux.Slash")]
+impl SlashZbus {
+    /// Get enabled or not
+    #[zbus(property)]
+    async fn enabled(&self) -> bool {
+        let lock = self.0.lock_config().await;
+        lock.slash_enabled
+    }
+
+    /// Set enabled true or false
+    #[zbus(property)]
+    async fn set_enabled(&self, enabled: bool) {
+        let mut config = self.0.lock_config().await;
+        let brightness = if enabled && config.slash_brightness == 0 {
+            0x88
+        } else {
+            config.slash_brightness
+        };
+        self.0
+            .write_bytes(&pkt_set_options(
+                config.slash_type,
+                enabled,
+                brightness,
+                config.slash_interval,
+            ))
+            .await
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+
+        config.slash_enabled = enabled;
+        config.slash_brightness = brightness;
+        config.write();
+    }
+
+    /// Get brightness level
+    #[zbus(property)]
+    async fn brightness(&self) -> u8 {
+        let config = self.0.lock_config().await;
+        config.slash_brightness
+    }
+
+    /// Set brightness level
+    #[zbus(property)]
+    async fn set_brightness(&self, brightness: u8) {
+        let mut config = self.0.lock_config().await;
+        let enabled = brightness > 0;
+        self.0
+            .write_bytes(&pkt_set_options(
+                config.slash_type,
+                enabled,
+                brightness,
+                config.slash_interval,
+            ))
+            .await
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+
+        config.slash_enabled = enabled;
+        config.slash_brightness = brightness;
+        config.write();
+    }
+
+    #[zbus(property)]
+    async fn interval(&self) -> u8 {
+        let config = self.0.lock_config().await;
+        config.slash_interval
+    }
+
+    /// Set interval between slash animations (0-255)
+    #[zbus(property)]
+    async fn set_interval(&self, interval: u8) {
+        let mut config = self.0.lock_config().await;
+        self.0
+            .write_bytes(&pkt_set_options(
+                config.slash_type,
+                config.slash_enabled,
+                config.slash_brightness,
+                interval,
+            ))
+            .await
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+
+        config.slash_interval = interval;
+        config.write();
+    }
+
+    #[zbus(property)]
+    async fn slash_mode(&self) -> u8 {
+        let config = self.0.lock_config().await;
+        config.slash_interval
+    }
+
+    /// Set interval between slash animations (0-255)
+    #[zbus(property)]
+    async fn set_slash_mode(&self, slash_mode: SlashMode) {
+        let mut config = self.0.lock_config().await;
+
+        let command_packets = pkt_set_mode(config.slash_type, slash_mode);
+        // self.node.write_bytes(&command_packets[0])?;
+        self.0
+            .write_bytes(&command_packets[1])
+            .await
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+        self.0
+            .write_bytes(&pkt_save(config.slash_type))
+            .await
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+
+        config.slash_mode = slash_mode;
+        config.write();
+    }
+
+    /// Get the device state as stored by asusd
+    // #[zbus(property)]
+    async fn device_state(&self) -> DeviceState {
+        let config = self.0.lock_config().await;
+        DeviceState::from(&*config)
+    }
+}
+
+impl Reloadable for SlashZbus {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        debug!("reloading slash settings");
+        let config = self.0.lock_config().await;
+        self.0
+            .write_bytes(&pkt_set_options(
+                config.slash_type,
+                config.slash_enabled,
+                config.slash_brightness,
+                config.slash_interval,
+            ))
+            .await
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+        Ok(())
+    }
+}