rog-aura: add basic per-key support

daemon-user/src/daemon.rs

@@ -1,4 +1,5 @@
 use rog_anime::usb::get_anime_type;
+use rog_aura::layouts::KeyLayout;
 use rog_dbus::RogDbusClientBlocking;
 use rog_user::{
     ctrl_anime::{CtrlAnime, CtrlAnimeInner},
@@ -6,12 +7,18 @@ use rog_user::{
     DBUS_NAME,
 };
 use smol::Executor;
-use std::sync::Arc;
 use std::sync::Mutex;
+use std::{fs::OpenOptions, io::Read, path::PathBuf, sync::Arc};
 use zbus::Connection;
 
 use std::sync::atomic::AtomicBool;
 
+#[cfg(not(feature = "local_data"))]
+const DATA_DIR: &str = "/usr/share/rog-gui/";
+#[cfg(feature = "local_data")]
+const DATA_DIR: &str = env!("CARGO_MANIFEST_DIR");
+const BOARD_NAME: &str = "/sys/class/dmi/id/board_name";
+
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("  user daemon v{}", rog_user::VERSION);
     println!("    rog-anime v{}", rog_anime::VERSION);
@@ -22,49 +29,83 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let supported = client.proxies().supported().supported_functions()?;
 
     let mut config = UserConfig::new();
-    config.load_config()?;
+    config.load()?;
 
     let executor = Executor::new();
 
     let early_return = Arc::new(AtomicBool::new(false));
     // Set up the anime data and run loop/thread
     if supported.anime_ctrl.0 {
-        let anime_type = get_anime_type()?;
-        let anime_config = UserAnimeConfig::load_config(config.active_anime)?;
-        let anime = anime_config.create_anime(anime_type)?;
-        let anime_config = Arc::new(Mutex::new(anime_config));
+        if let Some(cfg) = config.active_anime {
+            let anime_type = get_anime_type()?;
+            let anime_config = UserAnimeConfig::load(cfg)?;
+            let anime = anime_config.create(anime_type)?;
+            let anime_config = Arc::new(Mutex::new(anime_config));
 
-        executor
-            .spawn(async move {
-                // Create server
-                let mut connection = Connection::session().await.unwrap();
-                connection.request_name(DBUS_NAME).await.unwrap();
+            executor
+                .spawn(async move {
+                    // Create server
+                    let mut connection = Connection::session().await.unwrap();
+                    connection.request_name(DBUS_NAME).await.unwrap();
 
-                // Inner behind mutex required for thread safety
-                let inner = Arc::new(Mutex::new(
-                    CtrlAnimeInner::new(anime, client, early_return.clone()).unwrap(),
-                ));
-                // Need new client object for dbus control part
-                let (client, _) = RogDbusClientBlocking::new().unwrap();
-                let anime_control =
-                    CtrlAnime::new(anime_config, inner.clone(), client, early_return).unwrap();
-                anime_control.add_to_server(&mut connection).await;
-                loop {
-                    if let Ok(inner) = inner.clone().try_lock() {
-                        inner.run().ok();
+                    // Inner behind mutex required for thread safety
+                    let inner = Arc::new(Mutex::new(
+                        CtrlAnimeInner::new(anime, client, early_return.clone()).unwrap(),
+                    ));
+                    // Need new client object for dbus control part
+                    let (client, _) = RogDbusClientBlocking::new().unwrap();
+                    let anime_control =
+                        CtrlAnime::new(anime_config, inner.clone(), client, early_return).unwrap();
+                    anime_control.add_to_server(&mut connection).await;
+                    loop {
+                        if let Ok(inner) = inner.clone().try_lock() {
+                            inner.run().ok();
+                        }
                     }
-                }
-            })
-            .detach();
+                })
+                .detach();
+        }
     }
 
-    // if supported.keyboard_led.per_key_led_mode {
-    //     executor
-    //         .spawn(async move {
-    //            //
-    //         })
-    //         .detach();
-    // }
+    if supported.keyboard_led.per_key_led_mode {
+        if let Some(cfg) = config.active_aura {
+            let mut aura_config = UserAuraConfig::load(cfg)?;
+
+            // Find and load a matching layout for laptop
+            let mut file = OpenOptions::new()
+                .read(true)
+                .open(PathBuf::from(BOARD_NAME))
+                .map_err(|e| {
+                    println!("{BOARD_NAME}, {e}");
+                    e
+                })?;
+            let mut board_name = String::new();
+            file.read_to_string(&mut board_name)?;
+
+            let layout = KeyLayout::find_layout(board_name.as_str(), PathBuf::from(DATA_DIR))
+                .map_err(|e| {
+                    println!("{BOARD_NAME}, {e}");
+                })
+                .unwrap_or(KeyLayout::ga401_layout());
+
+            executor
+                .spawn(async move {
+                    // Create server
+                    let (client, _) = RogDbusClientBlocking::new().unwrap();
+                    // let connection = Connection::session().await.unwrap();
+                    // connection.request_name(DBUS_NAME).await.unwrap();
+
+                    loop {
+                        aura_config.aura.next_state(&layout);
+                        let packets = aura_config.aura.create_packets();
+
+                        client.proxies().led().per_key_raw(packets).unwrap();
+                        std::thread::sleep(std::time::Duration::from_millis(60));
+                    }
+                })
+                .detach();
+        }
+    }
 
     loop {
         smol::block_on(executor.tick());