gfx: asusd config option to not save compute/vfio mode switch

daemon-user/src/ctrl_anime.rs

@@ -15,7 +15,7 @@ use zbus::dbus_interface;
 use zvariant::ObjectPath;
 use zvariant_derive::Type;
 
-use crate::{error::Error, user_config::UserConfig};
+use crate::{error::Error, user_config::{UserAnimeConfig, UserConfig}};
 
 #[derive(Debug, Clone, Deserialize, Serialize, Type)]
 pub enum TimeType {
@@ -111,7 +111,7 @@ impl<'a> CtrlAnimeInner<'static> {
 }
 
 pub struct CtrlAnime<'a> {
-    config: Arc<Mutex<UserConfig>>,
+    config: Arc<Mutex<UserAnimeConfig>>,
     client: AuraDbusClient<'a>,
     inner: Arc<Mutex<CtrlAnimeInner<'a>>>,
     /// Must be the same Atomic as in CtrlAnimeInner
@@ -120,7 +120,7 @@ pub struct CtrlAnime<'a> {
 
 impl<'a> CtrlAnime<'static> {
     pub fn new(
-        config: Arc<Mutex<UserConfig>>,
+        config: Arc<Mutex<UserAnimeConfig>>,
         inner: Arc<Mutex<CtrlAnimeInner<'static>>>,
         client: AuraDbusClient<'static>,
         inner_early_return: &'static AtomicBool,

daemon-user/src/daemon.rs

@@ -24,9 +24,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let mut config = UserConfig::new();
     config.load_config()?;
-    let anime = config.create_anime()?;
 
-    let config = Arc::new(Mutex::new(config));
+    let anime_config = UserAnimeConfig::load_config(config.active_anime)?;
+    let anime = anime_config.create_anime()?;
+
+    let anime_config = Arc::new(Mutex::new(anime_config));
 
     // Create server
     let connection = Connection::new_session()?;
@@ -45,7 +47,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         // Need new client object for dbus control part
         let (client, _) = AuraDbusClient::new().unwrap();
         let anime_control =
-            CtrlAnime::new(config, inner.clone(), client, &ANIME_INNER_EARLY_RETURN)?;
+            CtrlAnime::new(anime_config, inner.clone(), client, &ANIME_INNER_EARLY_RETURN)?;
         anime_control.add_to_server(&mut server);
         // Thread using inner
         let _anime_thread = thread::Builder::new()

daemon-user/src/user_config.rs

@@ -1,22 +1,92 @@
-use std::{
-    fs::{create_dir, OpenOptions},
-    io::{Read, Write},
-    time::Duration,
-};
+use std::{fs::{create_dir, OpenOptions}, io::{Read, Write}, time::Duration};
 
 use rog_anime::{AnimTime, AnimeAction, Sequences, Vec2};
 use serde_derive::{Deserialize, Serialize};
 
 use crate::error::Error;
 
-#[derive(Debug, Default, Deserialize, Serialize)]
-pub struct UserConfig {
+#[derive(Debug, Deserialize, Serialize)]
+pub struct UserAnimeConfig {
+    pub name: String,
     pub anime: Vec<AnimeAction>,
 }
 
-impl UserConfig {
-    pub fn new() -> Self {
+impl UserAnimeConfig {
+    pub fn create_anime(&self) -> Result<Sequences, Error> {
+        let mut seq = Sequences::new();
+
+        for (idx, action) in self.anime.iter().enumerate() {
+            seq.insert(idx, action)?;
+        }
+
+        Ok(seq)
+    }
+
+    pub fn write(&self) -> Result<(), Error> {
+        let mut path = if let Some(dir) = dirs::config_dir() {
+            dir
+        } else {
+            return Err(Error::XdgVars);
+        };
+
+        path.push("rog");
+        if !path.exists() {
+            create_dir(path.clone())?;
+        }
+        let name = self.name.clone();
+        path.push(name + ".cfg");
+
+        let mut file = OpenOptions::new()
+            .write(true)
+            .create(true)
+            .truncate(true)
+            .open(&path)?;
+
+        let json = serde_json::to_string_pretty(&self).unwrap();
+        file.write_all(json.as_bytes())?;
+        Ok(())
+    }
+
+    pub fn load_config(name: String) -> Result<UserAnimeConfig, Error> {
+        let mut path = if let Some(dir) = dirs::config_dir() {
+            dir
+        } else {
+            return Err(Error::XdgVars);
+        };
+
+        path.push("rog");
+        if !path.exists() {
+            create_dir(path.clone())?;
+        }
+
+        path.push(name + ".cfg");
+
+        let mut file = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .open(&path)?;
+
+        let mut buf = String::new();
+
+        if let Ok(read_len) = file.read_to_string(&mut buf) {
+            if read_len == 0 {
+                let default = UserAnimeConfig::default();
+                let json = serde_json::to_string_pretty(&default).unwrap();
+                file.write_all(json.as_bytes())?;
+                return Ok(default);
+            } else if let Ok(data) = serde_json::from_str::<UserAnimeConfig>(&buf) {
+                return Ok(data);
+            }
+        }
+        Err(Error::ConfigLoadFail)
+    }
+}
+
+impl Default for UserAnimeConfig {
+    fn default() -> Self {
         let x = Self {
+            name: "default".to_string(),
             anime: vec![
                 AnimeAction::AsusAnimation {
                     file: "/usr/share/asusd/anime/asus/rog/Sunset.gif".into(),
@@ -52,6 +122,20 @@ impl UserConfig {
         println!("{}", serde_json::to_string_pretty(&x).unwrap());
         x
     }
+}
+
+#[derive(Debug, Default, Deserialize, Serialize)]
+pub struct UserConfig {
+    /// Name of active anime config file in the user config directory
+    pub active_anime: String,
+}
+
+impl UserConfig {
+    pub fn new() -> Self {
+        Self {
+            active_anime: "anime-default".to_string()
+        }
+    }
 
     pub fn load_config(&mut self) -> Result<(), Error> {
         let mut path = if let Some(dir) = dirs::config_dir() {
@@ -80,7 +164,7 @@ impl UserConfig {
                 let json = serde_json::to_string_pretty(&self).unwrap();
                 file.write_all(json.as_bytes())?;
             } else if let Ok(data) = serde_json::from_str::<UserConfig>(&buf) {
-                self.anime = data.anime;
+                self.active_anime = data.active_anime;
                 return Ok(());
             }
         }
@@ -108,18 +192,7 @@ impl UserConfig {
             .open(&path)?;
 
         let json = serde_json::to_string_pretty(&self).unwrap();
-        dbg!(&json);
         file.write_all(json.as_bytes())?;
         Ok(())
     }
-
-    pub fn create_anime(&self) -> Result<Sequences, Error> {
-        let mut seq = Sequences::new();
-
-        for (idx, action) in self.anime.iter().enumerate() {
-            seq.insert(idx, action)?;
-        }
-
-        Ok(seq)
-    }
 }