SCSI support: ROG Arion external drive LED control

asusd/src/aura_scsi/trait_impls.rs

@@ -0,0 +1,116 @@
+use std::collections::BTreeMap;
+
+use config_traits::StdConfig;
+use log::error;
+use rog_aura::AuraDeviceType;
+use rog_scsi::{AuraEffect, AuraMode};
+use zbus::fdo::Error as ZbErr;
+use zbus::zvariant::OwnedObjectPath;
+use zbus::{interface, Connection};
+
+use super::ScsiAura;
+use crate::error::RogError;
+
+#[derive(Clone)]
+pub struct ScsiZbus(ScsiAura);
+
+impl ScsiZbus {
+    pub fn new(scsi: ScsiAura) -> Self {
+        Self(scsi)
+    }
+
+    pub async fn start_tasks(
+        self,
+        connection: &Connection,
+        path: OwnedObjectPath,
+    ) -> Result<(), RogError> {
+        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.ScsiAura")]
+impl ScsiZbus {
+    /// Return the device type for this Aura keyboard
+    #[zbus(property)]
+    async fn device_type(&self) -> AuraDeviceType {
+        self.0.config.lock().await.dev_type
+    }
+
+    /// Get enabled or not
+    #[zbus(property)]
+    async fn enabled(&self) -> bool {
+        let lock = self.0.lock_config().await;
+        lock.enabled
+    }
+
+    /// Set enabled true or false
+    #[zbus(property)]
+    async fn set_enabled(&self, enabled: bool) {
+        let mut config = self.0.lock_config().await;
+        config.enabled = enabled;
+        config.write();
+    }
+
+    #[zbus(property)]
+    async fn led_mode(&self) -> u8 {
+        let config = self.0.lock_config().await;
+        config.current_mode as u8
+    }
+
+    #[zbus(property)]
+    async fn set_led_mode(&self, mode: AuraMode) -> Result<(), zbus::Error> {
+        let mut config = self.0.lock_config().await;
+        if let Some(effect) = config.get_effect(mode) {
+            self.0
+                .write_effect(effect)
+                .await
+                .map_err(|e| zbus::Error::Failure(format!("{e:?}")))?;
+        } else {
+            return Err(zbus::Error::Failure("Mode data does not exist".to_string()));
+        }
+        config.current_mode = mode;
+        config.write();
+        Ok(())
+    }
+
+    /// The current mode data
+    #[zbus(property)]
+    async fn led_mode_data(&self) -> Result<AuraEffect, ZbErr> {
+        // entirely possible to deadlock here, so use try instead of lock()
+        if let Ok(config) = self.0.config.try_lock() {
+            let mode = config.current_mode;
+            match config.modes.get(&mode) {
+                Some(effect) => Ok(effect.clone()),
+                None => Err(ZbErr::Failed("Could not get the current effect".into())),
+            }
+        } else {
+            Err(ZbErr::Failed("Aura control couldn't lock self".to_string()))
+        }
+    }
+
+    /// Set an Aura effect if the effect mode or zone is supported.
+    ///
+    /// On success the aura config file is read to refresh cached values, then
+    /// the effect is stored and config written to disk.
+    #[zbus(property)]
+    async fn set_led_mode_data(&mut self, effect: AuraEffect) -> Result<(), ZbErr> {
+        self.0.write_effect(&effect).await?;
+
+        let mut config = self.0.config.lock().await;
+        config.save_effect(effect);
+        config.write();
+        Ok(())
+    }
+
+    /// Get the data set for every mode available
+    async fn all_mode_data(&self) -> BTreeMap<AuraMode, AuraEffect> {
+        let config = self.0.config.lock().await;
+        config.modes.clone()
+    }
+}