anime: add zbus methods

daemon-user/src/ctrl_anime.rs

@@ -0,0 +1,342 @@
+use rog_anime::{ActionData, AnimTime, AnimeAction, Sequences, Vec2};
+use rog_dbus::AuraDbusClient;
+//use crate::dbus::DbusEvents;
+use serde_derive::{Deserialize, Serialize};
+use std::time::Duration;
+use std::{
+    path::Path,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Mutex,
+    },
+};
+use std::{sync::Arc, thread::sleep, time::Instant};
+use zbus::dbus_interface;
+use zvariant::ObjectPath;
+use zvariant_derive::Type;
+
+use crate::{error::Error, user_config::UserConfig};
+
+#[derive(Debug, Clone, Deserialize, Serialize, Type)]
+pub enum TimeType {
+    Timer,
+    Count,
+    Infinite,
+}
+
+/// The inner object exists to allow the zbus proxy to share it with a runner thread
+/// and a zbus server behind `Arc<Mutex<T>>`
+pub struct CtrlAnimeInner<'a> {
+    sequences: Sequences,
+    client: AuraDbusClient<'a>,
+    do_early_return: &'a AtomicBool,
+}
+
+impl<'a> CtrlAnimeInner<'static> {
+    pub fn new(
+        sequences: Sequences,
+        client: AuraDbusClient<'static>,
+        do_early_return: &'static AtomicBool,
+    ) -> Result<Self, Error> {
+        Ok(Self {
+            sequences,
+            client,
+            do_early_return,
+        })
+    }
+    /// To be called on each main loop iteration to pump out commands to the anime
+    pub fn run(&self) -> Result<(), Error> {
+        if self.do_early_return.load(Ordering::SeqCst) {
+            return Ok(());
+        }
+
+        for action in self.sequences.iter() {
+            match action {
+                ActionData::Animation(frames) => {
+                    let mut count = 0;
+                    let start = Instant::now();
+                    'animation: loop {
+                        for frame in frames.frames() {
+                            if self.do_early_return.load(Ordering::SeqCst) {
+                                return Ok(());
+                            }
+                            self.client
+                                .proxies()
+                                .anime()
+                                .write(frame.frame().clone())
+                                .unwrap();
+                            if let AnimTime::Time(time) = frames.duration() {
+                                if Instant::now().duration_since(start) > time {
+                                    break 'animation;
+                                }
+                            }
+                            sleep(frame.delay());
+                        }
+                        if let AnimTime::Cycles(times) = frames.duration() {
+                            count += 1;
+                            if count >= times {
+                                break 'animation;
+                            }
+                        }
+                    }
+                }
+                ActionData::Image(image) => {
+                    self.client
+                        .proxies()
+                        .anime()
+                        .write(image.as_ref().clone())
+                        .unwrap();
+                }
+                ActionData::Pause(duration) => {
+                    let start = Instant::now();
+                    'pause: loop {
+                        if self.do_early_return.load(Ordering::SeqCst) {
+                            return Ok(());
+                        }
+                        if Instant::now().duration_since(start) > *duration {
+                            break 'pause;
+                        }
+                        sleep(Duration::from_millis(1));
+                    }
+                }
+                ActionData::AudioEq => {}
+                ActionData::SystemInfo => {}
+                ActionData::TimeDate => {}
+                ActionData::Matrix => {}
+            }
+        }
+
+        Ok(())
+    }
+}
+
+pub struct CtrlAnime<'a> {
+    config: Arc<Mutex<UserConfig>>,
+    client: AuraDbusClient<'a>,
+    inner: Arc<Mutex<CtrlAnimeInner<'a>>>,
+    /// Must be the same Atomic as in CtrlAnimeInner
+    inner_early_return: &'a AtomicBool,
+}
+
+impl<'a> CtrlAnime<'static> {
+    pub fn new(
+        config: Arc<Mutex<UserConfig>>,
+        inner: Arc<Mutex<CtrlAnimeInner<'static>>>,
+        client: AuraDbusClient<'static>,
+        inner_early_return: &'static AtomicBool,
+    ) -> Result<Self, Error> {
+        Ok(CtrlAnime {
+            config,
+            inner,
+            client,
+            inner_early_return,
+        })
+    }
+
+    pub fn add_to_server(self, server: &mut zbus::ObjectServer) {
+        server
+            .at(
+                &ObjectPath::from_str_unchecked("/org/asuslinux/Anime"),
+                self,
+            )
+            .map_err(|err| {
+                println!("CtrlAnime: add_to_server {}", err);
+                err
+            })
+            .ok();
+    }
+}
+
+
+// The pattern for a zbus method is:
+// - Get config lock if required
+// - Set inner_early_return to stop the inner run loop temporarily
+// - Do actions
+// - Write config if required
+// - Unset inner_early_return
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl CtrlAnime<'static> {
+    pub fn insert_asus_gif(
+        &mut self,
+        index: u32,
+        file: String,
+        time: TimeType,
+        count: u32,
+        brightness: f32,
+    ) -> zbus::fdo::Result<String> {
+        if let Ok(mut config) = self.config.try_lock() {
+            let time: AnimTime = match time {
+                TimeType::Timer => AnimTime::Time(Duration::from_millis(count as u64)),
+                TimeType::Count => AnimTime::Cycles(count),
+                TimeType::Infinite => AnimTime::Infinite,
+            };
+            let file = Path::new(&file);
+            let action = AnimeAction::AsusAnimation {
+                file: file.into(),
+                brightness,
+                time,
+            };
+
+            // Must make the inner run loop return early
+            self.inner_early_return.store(true, Ordering::SeqCst);
+
+            if let Ok(mut controller) = self.inner.lock() {
+                controller.sequences.insert(index as usize, &action)?;
+            }
+            config.anime.push(action);
+            config.write()?;
+
+            let json = serde_json::to_string_pretty(&*config).expect("Parse config to JSON failed");
+
+            // Release the inner run loop again
+            self.inner_early_return.store(false, Ordering::SeqCst);
+            return Ok(json);
+        }
+        Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn insert_image_gif(
+        &mut self,
+        index: u32,
+        file: String,
+        scale: f32,
+        angle: f32,
+        xy: (f32, f32),
+        time: TimeType,
+        count: u32,
+        brightness: f32,
+    ) -> zbus::fdo::Result<String> {
+        if let Ok(mut config) = self.config.try_lock() {
+            let time: AnimTime = match time {
+                TimeType::Timer => AnimTime::Time(Duration::from_millis(count as u64)),
+                TimeType::Count => AnimTime::Cycles(count),
+                TimeType::Infinite => AnimTime::Infinite,
+            };
+            let file = Path::new(&file);
+            let translation = Vec2::new(xy.0, xy.1);
+            let action = AnimeAction::ImageAnimation {
+                file: file.into(),
+                scale,
+                angle,
+                translation,
+                brightness,
+                time,
+            };
+
+            // Must make the inner run loop return early
+            self.inner_early_return.store(true, Ordering::SeqCst);
+
+            if let Ok(mut controller) = self.inner.lock() {
+                controller.sequences.insert(index as usize, &action)?;
+            }
+            config.anime.push(action);
+            config.write()?;
+
+            let json =
+                serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
+
+            // Release the inner run loop again
+            self.inner_early_return.store(false, Ordering::SeqCst);
+            return Ok(json);
+        }
+        Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
+    }
+
+    pub fn insert_image(
+        &mut self,
+        index: u32,
+        file: String,
+        scale: f32,
+        angle: f32,
+        xy: (f32, f32),
+        brightness: f32,
+    ) -> zbus::fdo::Result<String> {
+        if let Ok(mut config) = self.config.try_lock() {
+            let file = Path::new(&file);
+            let action = AnimeAction::Image {
+                file: file.into(),
+                scale,
+                angle,
+                translation: Vec2::new(xy.0, xy.1),
+                brightness,
+            };
+
+            // Must make the inner run loop return early
+            self.inner_early_return.store(true, Ordering::SeqCst);
+
+            if let Ok(mut controller) = self.inner.lock() {
+                controller.sequences.insert(index as usize, &action)?;
+            }
+            config.anime.push(action);
+            config.write()?;
+
+            let json =
+                serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
+
+            // Release the inner run loop again
+            self.inner_early_return.store(false, Ordering::SeqCst);
+            return Ok(json);
+        }
+        Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
+    }
+
+    pub fn insert_pause(&mut self, index: u32, millis: u64) -> zbus::fdo::Result<String> {
+        if let Ok(mut config) = self.config.try_lock() {
+            let action = AnimeAction::Pause(Duration::from_millis(millis));
+            // Must make the inner run loop return early
+            self.inner_early_return.store(true, Ordering::SeqCst);
+
+            if let Ok(mut controller) = self.inner.lock() {
+                controller.sequences.insert(index as usize, &action)?;
+            }
+            config.anime.push(action);
+            config.write()?;
+
+            let json =
+                serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
+
+            // Release the inner run loop again
+            self.inner_early_return.store(false, Ordering::SeqCst);
+            return Ok(json);
+        }
+        Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
+    }
+
+    pub fn remove_item(&mut self, index: u32) -> zbus::fdo::Result<String> {
+        if let Ok(mut config) = self.config.try_lock() {
+            // Must make the inner run loop return early
+            self.inner_early_return.store(true, Ordering::SeqCst);
+
+            if let Ok(mut controller) = self.inner.lock() {
+                controller.sequences.remove_item(index as usize);
+            }
+            if (index as usize) < config.anime.len() {
+                config.anime.remove(index as usize);
+            }
+            config.write()?;
+
+            let json =
+                serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
+
+            // Release the inner run loop again
+            self.inner_early_return.store(false, Ordering::SeqCst);
+            return Ok(json);
+        }
+        Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
+    }
+
+    pub fn set_state(&mut self, on: bool) -> zbus::fdo::Result<()> {
+        // Operations here need to be in specific order
+        if on {
+            self.client.proxies().anime().toggle_on(on)?;
+            // Let the inner loop run
+            self.inner_early_return.store(false, Ordering::SeqCst);
+        } else {
+            // Must make the inner run loop return early
+            self.inner_early_return.store(true, Ordering::SeqCst);
+            self.client.proxies().anime().toggle_on(on)?;
+        }
+        Ok(())
+    }
+}

daemon-user/src/daemon.rs

@@ -0,0 +1,67 @@
+use rog_dbus::AuraDbusClient;
+use rog_types::supported::SupportedFunctions;
+use rog_user::{
+    ctrl_anime::{CtrlAnime, CtrlAnimeInner},
+    user_config::*,
+    DBUS_NAME,
+};
+use std::sync::Arc;
+use std::sync::Mutex;
+use std::thread;
+use zbus::{fdo, Connection};
+
+use std::sync::atomic::AtomicBool;
+
+/// The anime loop needs an atomic to make it exit early if required
+static ANIME_INNER_EARLY_RETURN: AtomicBool = AtomicBool::new(false);
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("   rog-dbus version {}", rog_dbus::VERSION);
+
+    let (client, _) = AuraDbusClient::new().unwrap();
+    let supported = client.proxies().supported().get_supported_functions()?;
+    let supported = serde_json::from_str::<SupportedFunctions>(&&supported).unwrap();
+
+    let mut config = UserConfig::new();
+    config.load_config()?;
+    let anime = config.create_anime()?;
+
+    let config = Arc::new(Mutex::new(config));
+
+    // Create server
+    let connection = Connection::new_session()?;
+    fdo::DBusProxy::new(&connection)?
+        .request_name(DBUS_NAME, fdo::RequestNameFlags::ReplaceExisting.into())?;
+    let mut server = zbus::ObjectServer::new(&connection);
+
+    // Set up the anime data and run loop/thread
+    if supported.anime_ctrl.0 {
+        // Inner behind mutex required for thread safety
+        let inner = Arc::new(Mutex::new(CtrlAnimeInner::new(
+            anime,
+            client,
+            &ANIME_INNER_EARLY_RETURN,
+        )?));
+        // 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)?;
+        anime_control.add_to_server(&mut server);
+        // Thread using inner
+        let _anime_thread = thread::Builder::new()
+            .name("Anime User".into())
+            .spawn(move || loop {
+                if let Ok(inner) = inner.try_lock() {
+                    inner.run().unwrap();
+                }
+            })?;
+    }
+
+    if supported.keyboard_led.per_key_led_mode {}
+
+    loop {
+        if let Err(err) = server.try_handle_next() {
+            println!("{}", err);
+        }
+    }
+}

daemon-user/src/error.rs

@@ -6,6 +6,7 @@ use rog_anime::error::AnimeError;
 pub enum Error {
     Io(std::io::Error),
     ConfigLoadFail,
+    ConfigLockFail,
     XdgVars,
     Anime(AnimeError),
 }
@@ -16,6 +17,7 @@ impl fmt::Display for Error {
         match self {
             Error::Io(err) => write!(f, "Failed to open: {}", err),
             Error::ConfigLoadFail => write!(f, "Failed to load user config"),
+            Error::ConfigLockFail => write!(f, "Failed to lock user config"),
             Error::XdgVars => write!(f, "XDG environment vars appear unset"),
             Error::Anime(err) => write!(f, "Anime error: {}", err),
         }
@@ -35,3 +37,9 @@ impl From<AnimeError> for Error {
         Error::Anime(err)
     }
 }
+
+impl From<Error> for zbus::fdo::Error {
+    fn from(err: Error) -> Self {
+        zbus::fdo::Error::Failed(format!("Anime zbus error: {}", err))
+    }
+}

daemon-user/src/lib.rs

@@ -1,3 +1,9 @@
 pub mod user_config;
 
 pub mod error;
+
+pub mod ctrl_anime;
+
+pub mod zbus_anime;
+
+pub static DBUS_NAME: &str = "org.asuslinux.Daemon";

daemon-user/src/main.rs

@@ -1,66 +0,0 @@
-use rog_anime::{Action, AnimTime};
-use rog_dbus::AuraDbusClient;
-use rog_user::user_config::*;
-
-use std::{
-    thread::sleep,
-    time::{Duration, Instant},
-};
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    println!("   rog-dbus version {}", rog_dbus::VERSION);
-
-    let (client, _) = AuraDbusClient::new().unwrap();
-
-    let mut config = UserConfig::new();
-    config.load_config()?;
-    let anime = config.create_anime()?;
-
-    // TODO:
-    //  - find user config dir with xdg
-    //  - load user config
-    //  - start anime
-    // A way to reload when the config changes
-
-    loop {
-        for action in anime.iter() {
-            let start = Instant::now();
-
-            match action {
-                Action::Animation(frames) => {
-                    let mut count = 0;
-                    'animation: loop {
-                        for frame in frames.frames() {
-                            client.proxies().anime().write(frame.frame().clone())?;
-                            if let AnimTime::Time(time) = frames.duration() {
-                                if Instant::now().duration_since(start) > time {
-                                    break 'animation;
-                                }
-                            }
-                            sleep(frame.delay());
-                        }
-                        if let AnimTime::Cycles(times) = frames.duration() {
-                            count += 1;
-                            if count >= times {
-                                break 'animation;
-                            }
-                        }
-                    }
-                }
-                Action::Image(image) => {
-                    client.proxies().anime().write(image.as_ref().clone())?;
-                }
-                Action::Pause(duration) => 'pause: loop {
-                    if Instant::now().duration_since(start) > *duration {
-                        break 'pause;
-                    }
-                    sleep(Duration::from_millis(10));
-                },
-                Action::AudioEq => {}
-                Action::SystemInfo => {}
-                Action::TimeDate => {}
-                Action::Matrix => {}
-            }
-        }
-    }
-}

daemon-user/src/user_config.rs

@@ -1,46 +1,17 @@
 use std::{
     fs::{create_dir, OpenOptions},
     io::{Read, Write},
-    path::PathBuf,
     time::Duration,
 };
 
-use rog_anime::{AnimTime, Sequences, Vec2};
+use rog_anime::{AnimTime, AnimeAction, Sequences, Vec2};
 use serde_derive::{Deserialize, Serialize};
 
 use crate::error::Error;
 
 #[derive(Debug, Default, Deserialize, Serialize)]
 pub struct UserConfig {
-    anime: Vec<AnimeAction>,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub enum AnimeAction {
-    /// Full gif sequence. Immutable.
-    AsusAnimation {
-        file: PathBuf,
-        time: AnimTime,
-        brightness: f32,
-    },
-    /// Basic image, can have properties changed
-    ImageAnimation {
-        file: PathBuf,
-        scale: f32,
-        angle: f32,
-        translation: Vec2,
-        time: AnimTime,
-        brightness: f32,
-    },
-    Image {
-        file: PathBuf,
-        scale: f32,
-        angle: f32,
-        translation: Vec2,
-        brightness: f32,
-    },
-    /// A pause to be used between sequences
-    Pause(Duration),
+    pub anime: Vec<AnimeAction>,
 }
 
 impl UserConfig {
@@ -114,38 +85,35 @@ impl UserConfig {
             }
         }
         Ok(())
-        //Err(Error::ConfigLoadFail)
+    }
+
+    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())?;
+        }
+
+        path.push("rog-user.cfg");
+
+        let mut file = OpenOptions::new().write(true).create(true).truncate(true).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 anime in self.anime.iter() {
-            match anime {
-                AnimeAction::AsusAnimation {
-                    file,
-                    time: duration,
-                    brightness,
-                } => seq.add_asus_gif(&file, *duration, *brightness)?,
-                AnimeAction::ImageAnimation {
-                    file,
-                    scale,
-                    angle,
-                    translation,
-                    time: duration,
-                    brightness,
-                } => {
-                    seq.add_image_gif(&file, *scale, *angle, *translation, *duration, *brightness)?
-                }
-                AnimeAction::Image {
-                    file,
-                    scale,
-                    angle,
-                    translation,
-                    brightness,
-                } => seq.add_png(&file, *scale, *angle, *translation, *brightness)?,
-                AnimeAction::Pause(duration) => seq.add_pause(*duration)?,
-            }
+        for (idx, action) in self.anime.iter().enumerate() {
+            seq.insert(idx, action)?;
         }
 
         Ok(seq)

daemon-user/src/zbus_anime.rs

@@ -0,0 +1,68 @@
+//! # DBus interface proxy for: `org.asuslinux.Daemon`
+//!
+//! This code was generated by `zbus-xmlgen` `1.0.0` from DBus introspection data.
+//! Source: `Interface '/org/asuslinux/Anime' from service 'org.asuslinux.Daemon' on session bus`.
+//!
+//! You may prefer to adapt it, instead of using it verbatim.
+//!
+//! More information can be found in the
+//! [Writing a client proxy](https://dbus.pages.freedesktop.org/zbus/client.html)
+//! section of the zbus documentation.
+//!
+//! This DBus object implements
+//! [standard DBus interfaces](https://dbus.freedesktop.org/doc/dbus-specification.html),
+//! (`org.freedesktop.DBus.*`) for which the following zbus proxies can be used:
+//!
+//! * [`zbus::fdo::PeerProxy`]
+//! * [`zbus::fdo::IntrospectableProxy`]
+//! * [`zbus::fdo::PropertiesProxy`]
+//!
+//! …consequently `zbus-xmlgen` did not generate code for the above interfaces.
+
+use zbus::dbus_proxy;
+
+#[dbus_proxy(interface = "org.asuslinux.Daemon")]
+trait Daemon {
+    /// InsertAsusGif method
+    fn insert_asus_gif(
+        &self,
+        index: u32,
+        file: &str,
+        time: u32,
+        count: u32,
+        brightness: f64,
+    ) -> zbus::Result<String>;
+
+    /// InsertImage method
+    fn insert_image(
+        &self,
+        index: u32,
+        file: &str,
+        scale: f64,
+        angle: f64,
+        xy: &(f64, f64),
+        brightness: f64,
+    ) -> zbus::Result<String>;
+
+    /// InsertImageGif method
+    fn insert_image_gif(
+        &self,
+        index: u32,
+        file: &str,
+        scale: f64,
+        angle: f64,
+        xy: &(f64, f64),
+        time: u32,
+        count: u32,
+        brightness: f64,
+    ) -> zbus::Result<String>;
+
+    /// InsertPause method
+    fn insert_pause(&self, index: u32, millis: u64) -> zbus::Result<String>;
+
+    /// RemoveItem method
+    fn remove_item(&self, index: u32) -> zbus::Result<String>;
+
+    /// SetState method
+    fn set_state(&self, on: bool) -> zbus::Result<()>;
+}