Try to implement slash bar functionality - part 1

asusd/src/ctrl_slash/config.rs

@@ -0,0 +1,52 @@
+use serde_derive::{Deserialize, Serialize};
+use config_traits::{StdConfig, StdConfigLoad, StdConfigLoad2};
+use rog_slash::{DeviceState, SlashMode};
+use crate::ctrl_anime::config::{AnimeConfig, AnimeConfigV460, AnimeConfigV472};
+
+const CONFIG_FILE: &str = "slash.ron";
+
+/// Config for base system actions for the anime display
+#[derive(Deserialize, Serialize, Debug)]
+pub struct SlashConfig {
+    pub slash_enabled: bool,
+    pub slash_brightness: u8,
+    pub slash_interval: u8,
+    pub slash_mode: u8,
+}
+
+impl Default for SlashConfig {
+    fn default() -> Self {
+        SlashConfig {
+            slash_enabled: true,
+            slash_brightness: 255,
+            slash_interval: 0,
+            slash_mode: SlashMode::Bounce as u8,
+        }
+    }
+}
+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/ctrl_slash/mod.rs

@@ -0,0 +1,100 @@
+pub mod config;
+pub mod trait_impls;
+
+use rog_platform::hid_raw::HidRaw;
+use rog_platform::usb_raw::USBRaw;
+use rog_slash::{SlashMode};
+use rog_slash::usb::{pkt_set_mode, pkt_set_options, pkts_for_init};
+use crate::ctrl_slash::config::SlashConfig;
+use crate::error::RogError;
+
+enum Node {
+    Usb(USBRaw),
+    Hid(HidRaw),
+}
+
+impl Node {
+    pub fn write_bytes(&self, message: &[u8]) -> Result<(), RogError> {
+        // TODO: map and pass on errors
+        match self {
+            Node::Usb(u) => {
+                u.write_bytes(message).ok();
+            }
+            Node::Hid(h) => {
+                h.write_bytes(message).ok();
+            }
+        }
+        Ok(())
+    }
+
+    // pub fn set_builtins_enabled(&self, enabled: bool) -> Result<(), SlashCtlError> {
+        // self.write_bytes(&pkt_set_enable_powersave_anim(enabled))?;
+        // self.write_bytes(&pkt_set_enable_display(enabled))?;
+        // self.write_bytes(&pkt_set_brightness(bright))?;
+        // self.write_bytes(&pkt_set_enable_powersave_anim(enabled))
+        // Ok(())
+    // }
+}
+
+#[derive(Clone)]
+pub struct CtrlSlash {
+    // node: HidRaw,
+    node: Node,
+    config: SlashConfig,
+    // slash_type: SlashType,
+    // // set to force thread to exit
+    // thread_exit: Arc<AtomicBool>,
+    // // Set to false when the thread exits
+    // thread_running: Arc<AtomicBool>,
+}
+
+impl CtrlSlash {
+    #[inline]
+    pub fn new(config: SlashConfig) -> Result<CtrlSlash, RogError> {
+        let usb = USBRaw::new(rog_slash::usb::PROD_ID).ok();
+        let hid = HidRaw::new(rog_slash::usb::PROD_ID_STR).ok();
+        let node = if usb.is_some() {
+            unsafe { Node::Usb(usb.unwrap_unchecked()) }
+        } else if hid.is_some() {
+            unsafe { Node::Hid(hid.unwrap_unchecked().0) }
+        } else {
+            return Err(RogError::NotSupported);
+        };
+
+        // Maybe, detecting the slash-type may become necessary
+        // let slash_type = get_slash_type()?;
+
+        let ctrl = CtrlSlash {
+            node,
+            config,
+            // slash_type,
+            // thread_exit: Arc::new(AtomicBool::new(false)),
+            // thread_running: Arc::new(AtomicBool::new(false)),
+        };
+        ctrl.do_initialization()?;
+
+        Ok(ctrl)
+    }
+
+    fn do_initialization(&self) -> Result<(), RogError> {
+
+        let init_packets = pkts_for_init();
+        self.node.write_bytes(&init_packets[0])?;
+        self.node.write_bytes(&init_packets[1])?;
+
+        Ok(())
+    }
+
+    pub fn set_options(&self, enabled: bool, brightness: u8, interval: u8) -> Result<(), RogError> {
+        let command_packets = pkt_set_options(enabled, brightness, interval);
+        self.node.write_bytes(&command_packets)?;
+        Ok(())
+    }
+
+    pub fn set_slash_mode(&self, slash_mode: SlashMode) -> Result<(), RogError> {
+        let command_packets = pkt_set_mode(slash_mode as u8);
+        self.node.write_bytes(&command_packets[0])?;
+        self.node.write_bytes(&command_packets[1])?;
+        Ok(())
+    }
+}

asusd/src/ctrl_slash/trait_impls.rs

@@ -0,0 +1,94 @@
+use std::sync::Arc;
+use log::warn;
+use zbus::{Connection, interface};
+use zbus::export::futures_util::lock::Mutex;
+use config_traits::StdConfig;
+use rog_slash::DeviceState;
+use rog_slash::usb::pkt_set_options;
+use crate::ctrl_slash::CtrlSlash;
+
+
+pub const SLASH_ZBUS_NAME: &str = "Slash";
+pub const SLASH_ZBUS_PATH: &str = "/org/asuslinux";
+
+#[derive(Clone)]
+pub struct CtrlSlashZbus(pub Arc<Mutex<CtrlSlash>>);
+
+
+/// The struct with the main dbus methods requires this trait
+impl crate::ZbusRun for CtrlSlashZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, SLASH_ZBUS_NAME, server).await;
+    }
+}
+
+
+// None of these calls can be guarnateed to succeed unless we loop until okay
+// If the try_lock *does* succeed then any other thread trying to lock will not
+// grab it until we finish.
+#[interface(name = "org.asuslinux.Slash")]
+impl CtrlSlashZbus {
+    // /// Writes a data stream of length. Will force system thread to exit until
+    // /// it is restarted
+    // async fn write(&self, input: AnimeDataBuffer) -> zbus::fdo::Result<()> {
+    //     let lock = self.0.lock().await;
+    //     lock.thread_exit.store(true, Ordering::SeqCst);
+    //     lock.write_data_buffer(input).map_err(|err| {
+    //         warn!("ctrl_anime::run_animation:callback {}", err);
+    //         err
+    //     })?;
+    //     Ok(())
+    // }
+
+    /// Set base brightness level
+    #[zbus(property)]
+    async fn brightness(&self) -> u8 {
+        let lock = self.0.lock().await;
+        lock.config.slash_brightness
+    }
+
+    /// Set base brightness level
+    #[zbus(property)]
+    async fn set_brightness(&self, brightness: u8) {
+        let mut lock = self.0.lock().await;
+        let enabled = brightness > 0;
+        lock.node
+            .write_bytes(&pkt_set_options(enabled, brightness, lock.config.slash_interval))
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+
+        lock.config.slash_enabled = enabled;
+        lock.config.slash_brightness = brightness;
+        lock.config.write();
+    }
+
+    #[zbus(property)]
+    async fn enable_display(&self) -> bool {
+        let lock = self.0.lock().await;
+        lock.config.slash_enabled
+    }
+
+    /// Set whether the AniMe is enabled at all
+    #[zbus(property)]
+    async fn set_enable_display(&self, enabled: bool) {
+        let mut lock = self.0.lock().await;
+        lock.node
+            .write_bytes(&pkt_set_options(enabled, lock.config.slash_brightness, lock.config.slash_interval))
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+
+        lock.config.slash_enabled = enabled;
+        lock.config.write();
+    }
+
+    /// Get the device state as stored by asusd
+    // #[zbus(property)]
+    async fn device_state(&self) -> DeviceState {
+        let lock = self.0.lock().await;
+        DeviceState::from(&lock.config)
+    }
+}