GFX control, no-tokio, no-async, dbus client refactor

- Working gfx modes <iGPU only, dGPU only, or hybrid>
- Add signal for gfx vendor change and make CLI wait for signal
- Add polling for led brightness to save to config
- Move daemon to zbus crate
- dbus client refactor
- Further dbus methods and updates
- Add basic notification user daemon and systemd service

asus-nb/src/anime_dbus.rs

@@ -1,5 +1,5 @@
 use crate::anime_matrix::AniMePacketType;
-use crate::{DBUS_IFACE, DBUS_NAME, DBUS_PATH};
+use crate::{DBUS_IFACE, DBUS_NAME};
 use dbus::channel::Sender;
 use dbus::{blocking::Connection, Message};
 use std::error::Error;
@@ -65,8 +65,9 @@ impl AniMeDbusWriter {
             image[1][..7].copy_from_slice(&ANIME_PANE2_PREFIX);
         }
 
-        let mut msg = Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "AnimatrixWrite")?
-            .append2(image[0].to_vec(), image[1].to_vec());
+        let mut msg =
+            Message::new_method_call(DBUS_NAME, "/org/asuslinux/Anime", DBUS_IFACE, "SetAnime")?
+                .append2(image[0].to_vec(), image[1].to_vec());
         msg.set_no_reply(true);
         self.connection.send(msg).unwrap();
         thread::sleep(Duration::from_millis(self.block_time));

asus-nb/src/aura_modes.rs

@@ -17,7 +17,7 @@ pub const FLASH: u8 = 0x0c;
 pub const MULTISTATIC: u8 = 0x0d;
 pub const PER_KEY: u8 = 0xff;
 
-#[derive(Clone, Deserialize, Serialize)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct Colour(pub u8, pub u8, pub u8);
 impl From<cli_options::Colour> for Colour {
     fn from(c: cli_options::Colour) -> Self {
@@ -30,7 +30,7 @@ impl Default for Colour {
     }
 }
 
-#[derive(Copy, Clone, Deserialize, Serialize)]
+#[derive(Debug, Copy, Clone, Deserialize, Serialize)]
 pub enum Speed {
     Low = 0xe1,
     Med = 0xeb,
@@ -54,7 +54,7 @@ impl Default for Speed {
 /// Used for Rainbow mode.
 ///
 /// Enum corresponds to the required integer value
-#[derive(Copy, Clone, Deserialize, Serialize)]
+#[derive(Debug, Copy, Clone, Deserialize, Serialize)]
 pub enum Direction {
     Right,
     Left,
@@ -77,7 +77,7 @@ impl Default for Direction {
     }
 }
 
-#[derive(Clone, Default, Deserialize, Serialize)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize)]
 pub struct TwoColourSpeed {
     pub colour: Colour,
     pub colour2: Colour,
@@ -93,7 +93,7 @@ impl From<cli_options::TwoColourSpeed> for TwoColourSpeed {
     }
 }
 
-#[derive(Clone, Default, Deserialize, Serialize)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize)]
 pub struct SingleSpeed {
     pub speed: Speed,
 }
@@ -105,7 +105,7 @@ impl From<cli_options::SingleSpeed> for SingleSpeed {
     }
 }
 
-#[derive(Clone, Default, Deserialize, Serialize)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize)]
 pub struct SingleColour {
     pub colour: Colour,
 }
@@ -117,7 +117,7 @@ impl From<cli_options::SingleColour> for SingleColour {
     }
 }
 
-#[derive(Clone, Default, Deserialize, Serialize)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize)]
 pub struct MultiColour {
     pub colour1: Colour,
     pub colour2: Colour,
@@ -135,7 +135,7 @@ impl From<cli_options::MultiColour> for MultiColour {
     }
 }
 
-#[derive(Clone, Default, Deserialize, Serialize)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize)]
 pub struct SingleSpeedDirection {
     pub direction: Direction,
     pub speed: Speed,
@@ -149,7 +149,7 @@ impl From<cli_options::SingleSpeedDirection> for SingleSpeedDirection {
     }
 }
 
-#[derive(Clone, Default, Deserialize, Serialize)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize)]
 pub struct SingleColourSpeed {
     pub colour: Colour,
     pub speed: Speed,
@@ -163,7 +163,7 @@ impl From<cli_options::SingleColourSpeed> for SingleColourSpeed {
     }
 }
 
-#[derive(Clone, Deserialize, Serialize)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
 pub enum AuraModes {
     Static(SingleColour),
     Breathe(TwoColourSpeed),

asus-nb/src/core_dbus.rs

@@ -1,53 +1,169 @@
 use super::*;
 use crate::fancy::KeyColourArray;
 use crate::profile::ProfileEvent;
+use ctrl_gfx::vendors::GfxVendors;
 use dbus::channel::Sender;
-use dbus::{blocking::Connection, channel::Token, Message};
+use dbus::{blocking::Connection, Message};
 use std::error::Error;
 use std::sync::{
     atomic::{AtomicBool, Ordering},
-    Arc,
+    Arc, Mutex,
 };
 use std::{thread, time::Duration};
 
+use crate::dbus_gfx::OrgAsuslinuxDaemonNotifyGfx;
+use crate::dbus_ledmode::OrgAsuslinuxDaemonNotifyLed;
+use crate::dbus_profile::OrgAsuslinuxDaemonNotifyProfile;
+use crate::dbus_charge::OrgAsuslinuxDaemonNotifyCharge;
+
+// Signals separated out
+pub struct CtrlSignals {
+    pub gfx_signal: Arc<Mutex<Option<String>>>,
+    pub profile_signal: Arc<Mutex<Option<String>>>,
+    pub ledmode_signal: Arc<Mutex<Option<AuraModes>>>,
+    pub charge_signal: Arc<Mutex<Option<u8>>>,
+}
+
+impl CtrlSignals {
+    #[inline]
+    pub fn new(connection: &Connection) -> Result<Self, Box<dyn Error>> {
+        let proxy = connection.with_proxy(
+            "org.asuslinux.Daemon",
+            "/org/asuslinux/Gfx",
+            Duration::from_millis(5000),
+        );
+
+        let gfx_signal = Arc::new(Mutex::new(None));
+        let gfx_res1 = gfx_signal.clone();
+
+        let _x = proxy.match_signal(
+            move |sig: OrgAsuslinuxDaemonNotifyGfx, _: &Connection, _: &Message| {
+                if let Ok(mut lock) = gfx_res1.lock() {
+                    *lock = Some(sig.vendor);
+                }
+                true
+            },
+        )?;
+
+        //
+        let proxy = connection.with_proxy(
+            "org.asuslinux.Daemon",
+            "/org/asuslinux/Profile",
+            Duration::from_millis(5000),
+        );
+
+        let profile_signal = Arc::new(Mutex::new(None));
+        let prof_res1 = profile_signal.clone();
+
+        let _x = proxy.match_signal(
+            move |sig: OrgAsuslinuxDaemonNotifyProfile, _: &Connection, _: &Message| {
+                if let Ok(mut lock) = prof_res1.lock() {
+                    *lock = Some(sig.profile);
+                }
+                true
+            },
+        )?;
+
+        //
+        let proxy = connection.with_proxy(
+            "org.asuslinux.Daemon",
+            "/org/asuslinux/Led",
+            Duration::from_millis(5000),
+        );
+
+        let ledmode_signal = Arc::new(Mutex::new(None));
+        let led_res1 = ledmode_signal.clone();
+
+        let _x = proxy.match_signal(
+            move |sig: OrgAsuslinuxDaemonNotifyLed, _: &Connection, _: &Message| {
+                if let Ok(mut lock) = led_res1.lock() {
+                    if let Ok(dat) = serde_json::from_str(&sig.data) {
+                        *lock = Some(dat);
+                    }
+                }
+                true
+            },
+        )?;
+
+        //
+        let proxy = connection.with_proxy(
+            "org.asuslinux.Daemon",
+            "/org/asuslinux/Charge",
+            Duration::from_millis(5000),
+        );
+
+        let charge_signal = Arc::new(Mutex::new(None));
+        let charge_res1 = charge_signal.clone();
+
+        let _x = proxy.match_signal(
+            move |sig: OrgAsuslinuxDaemonNotifyCharge, _: &Connection, _: &Message| {
+                if let Ok(mut lock) = charge_res1.lock() {
+                        *lock = Some(sig.limit);
+                }
+                true
+            },
+        )?;
+
+        Ok(CtrlSignals {
+            gfx_signal,
+            profile_signal,
+            ledmode_signal,
+            charge_signal,
+        })
+    }
+}
+
 /// Simplified way to write a effect block
 pub struct AuraDbusClient {
     connection: Box<Connection>,
     block_time: u64,
     stop: Arc<AtomicBool>,
-    stop_token: Token,
+    signals: CtrlSignals,
 }
 
 impl AuraDbusClient {
     #[inline]
     pub fn new() -> Result<Self, Box<dyn Error>> {
         let connection = Connection::new_system()?;
-        let stop = Arc::new(AtomicBool::new(false));
 
-        let stopper2 = stop.clone();
-        let match_rule = dbus::message::MatchRule::new_signal(DBUS_IFACE, "KeyBacklightChanged");
-        let stop_token = connection.add_match(match_rule, move |_: (), _, msg| {
+        let stop = Arc::new(AtomicBool::new(false));
+        let match_rule = dbus::message::MatchRule::new_signal(DBUS_IFACE, "NotifyLed");
+        let stop1 = stop.clone();
+        connection.add_match(match_rule, move |_: (), _, msg| {
             if msg.read1::<&str>().is_ok() {
-                stopper2.store(true, Ordering::Relaxed);
+                stop1.clone().store(true, Ordering::Relaxed);
             }
             true
         })?;
 
+        let signals = CtrlSignals::new(&connection)?;
+
         Ok(AuraDbusClient {
             connection: Box::new(connection),
             block_time: 33333,
             stop,
-            stop_token,
+            signals,
         })
     }
 
+    pub fn wait_gfx_changed(&self) -> Result<String, Box<dyn Error>> {
+        loop {
+            self.connection.process(Duration::from_micros(500))?;
+            if let Ok(lock) = self.signals.gfx_signal.lock() {
+                if let Some(stuff) = lock.as_ref() {
+                    return Ok(stuff.to_string());
+                }
+            }
+        }
+    }
+
     /// This method must always be called before the very first write to initialise
     /// the keyboard LED EC in the correct mode
     #[inline]
     pub fn init_effect(&self) -> Result<(), Box<dyn std::error::Error>> {
         let mode = AuraModes::PerKey(vec![vec![]]);
         let mut msg =
-            Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "SetKeyBacklight")?
+            Message::new_method_call(DBUS_NAME, "/org/asuslinux/Led", DBUS_IFACE, "SetLedMode")?
                 .append1(serde_json::to_string(&mode)?);
         msg.set_no_reply(true);
         self.connection.send(msg).unwrap();
@@ -70,14 +186,13 @@ impl AuraDbusClient {
         }
         let mode = AuraModes::PerKey(vecs);
         let mut msg =
-            Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "SetKeyBacklight")?
+            Message::new_method_call(DBUS_NAME, "/org/asuslinux/Led", DBUS_IFACE, "SetLedMode")?
                 .append1(serde_json::to_string(&mode)?);
         msg.set_no_reply(true);
         self.connection.send(msg).unwrap();
         thread::sleep(Duration::from_micros(self.block_time));
         self.connection.process(Duration::from_micros(500))?;
         if self.stop.load(Ordering::Relaxed) {
-            self.connection.remove_match(self.stop_token)?;
             println!("Keyboard backlight was changed, exiting");
             std::process::exit(1)
         }
@@ -87,7 +202,7 @@ impl AuraDbusClient {
     #[inline]
     pub fn write_keyboard_leds(&self, mode: &AuraModes) -> Result<(), Box<dyn std::error::Error>> {
         let mut msg =
-            Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "SetKeyBacklight")?
+            Message::new_method_call(DBUS_NAME, "/org/asuslinux/Led", DBUS_IFACE, "SetLedMode")?
                 .append1(serde_json::to_string(mode)?);
         msg.set_no_reply(true);
         self.connection.send(msg).unwrap();
@@ -96,8 +211,23 @@ impl AuraDbusClient {
 
     #[inline]
     pub fn write_fan_mode(&self, level: u8) -> Result<(), Box<dyn std::error::Error>> {
-        let mut msg = Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "ProfileCommand")?
-            .append1(serde_json::to_string(&ProfileEvent::ChangeMode(level))?);
+        let mut msg = Message::new_method_call(
+            DBUS_NAME,
+            "/org/asuslinux/Profile",
+            DBUS_IFACE,
+            "SetProfile",
+        )?
+        .append1(serde_json::to_string(&ProfileEvent::ChangeMode(level))?);
+        msg.set_no_reply(true);
+        self.connection.send(msg).unwrap();
+        Ok(())
+    }
+
+    #[inline]
+    pub fn write_gfx_mode(&self, vendor: GfxVendors) -> Result<(), Box<dyn std::error::Error>> {
+        let mut msg =
+            Message::new_method_call(DBUS_NAME, "/org/asuslinux/Gfx", DBUS_IFACE, "SetVendor")?
+                .append1(<&str>::from(&vendor));
         msg.set_no_reply(true);
         self.connection.send(msg).unwrap();
         Ok(())
@@ -108,8 +238,13 @@ impl AuraDbusClient {
         &self,
         cmd: &ProfileEvent,
     ) -> Result<(), Box<dyn std::error::Error>> {
-        let mut msg = Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "ProfileCommand")?
-            .append1(serde_json::to_string(cmd)?);
+        let mut msg = Message::new_method_call(
+            DBUS_NAME,
+            "/org/asuslinux/Profile",
+            DBUS_IFACE,
+            "SetProfile",
+        )?
+        .append1(serde_json::to_string(cmd)?);
         msg.set_no_reply(true);
         self.connection.send(msg).unwrap();
         Ok(())
@@ -117,8 +252,9 @@ impl AuraDbusClient {
 
     #[inline]
     pub fn write_charge_limit(&self, level: u8) -> Result<(), Box<dyn std::error::Error>> {
-        let mut msg = Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "SetChargeLimit")?
-            .append1(level);
+        let mut msg =
+            Message::new_method_call(DBUS_NAME, "/org/asuslinux/Charge", DBUS_IFACE, "SetLimit")?
+                .append1(level);
         msg.set_no_reply(true);
         self.connection.send(msg).unwrap();
         Ok(())

asus-nb/src/dbus_charge.rs

@@ -0,0 +1,46 @@
+// This code was autogenerated with `dbus-codegen-rust -s -d org.asuslinux.Daemon -f org.asuslinux.Daemon -c blocking -p /org/asuslinux/Charge -m None`, see https://github.com/diwic/dbus-rs
+use dbus as dbus;
+#[allow(unused_imports)]
+use dbus::arg;
+use dbus::blocking;
+
+pub trait OrgAsuslinuxDaemon {
+    fn set_limit(&self, limit: u8) -> Result<(), dbus::Error>;
+    fn limit(&self) -> Result<i16, dbus::Error>;
+}
+
+impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target=T>> OrgAsuslinuxDaemon for blocking::Proxy<'a, C> {
+
+    fn set_limit(&self, limit: u8) -> Result<(), dbus::Error> {
+        self.method_call("org.asuslinux.Daemon", "SetLimit", (limit, ))
+    }
+
+    fn limit(&self) -> Result<i16, dbus::Error> {
+        self.method_call("org.asuslinux.Daemon", "Limit", ())
+            .and_then(|r: (i16, )| Ok(r.0, ))
+    }
+}
+
+#[derive(Debug)]
+pub struct OrgAsuslinuxDaemonNotifyCharge {
+    pub limit: u8,
+}
+
+impl arg::AppendAll for OrgAsuslinuxDaemonNotifyCharge {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.limit, i);
+    }
+}
+
+impl arg::ReadAll for OrgAsuslinuxDaemonNotifyCharge {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(OrgAsuslinuxDaemonNotifyCharge {
+            limit: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for OrgAsuslinuxDaemonNotifyCharge {
+    const NAME: &'static str = "NotifyCharge";
+    const INTERFACE: &'static str = "org.asuslinux.Daemon";
+}

asus-nb/src/dbus_gfx.rs

@@ -0,0 +1,39 @@
+// This code was autogenerated with `dbus-codegen-rust -s -d org.asuslinux.Daemon -p /org/asuslinux/Gfx -m None -f org.asuslinux.Daemon -c blocking`, see https://github.com/diwic/dbus-rs
+use dbus;
+#[allow(unused_imports)]
+use dbus::arg;
+use dbus::blocking;
+
+pub trait OrgAsuslinuxDaemon {
+    fn set_vendor(&self, vendor: &str) -> Result<(), dbus::Error>;
+}
+
+impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target = T>> OrgAsuslinuxDaemon
+    for blocking::Proxy<'a, C>
+{
+    fn set_vendor(&self, vendor: &str) -> Result<(), dbus::Error> {
+        self.method_call("org.asuslinux.Daemon", "SetVendor", (vendor,))
+    }
+}
+
+#[derive(Debug)]
+pub struct OrgAsuslinuxDaemonNotifyGfx {
+    pub vendor: String,
+}
+
+impl arg::AppendAll for OrgAsuslinuxDaemonNotifyGfx {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.vendor, i);
+    }
+}
+
+impl arg::ReadAll for OrgAsuslinuxDaemonNotifyGfx {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(OrgAsuslinuxDaemonNotifyGfx { vendor: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for OrgAsuslinuxDaemonNotifyGfx {
+    const NAME: &'static str = "NotifyGfx";
+    const INTERFACE: &'static str = "org.asuslinux.Daemon";
+}

asus-nb/src/dbus_ledmode.rs

@@ -0,0 +1,52 @@
+// This code was autogenerated with `dbus-codegen-rust -s -d org.asuslinux.Daemon -f org.asuslinux.Daemon -c blocking -p /org/asuslinux/Led -m None`, see https://github.com/diwic/dbus-rs
+use dbus as dbus;
+#[allow(unused_imports)]
+use dbus::arg;
+use dbus::blocking;
+
+pub trait OrgAsuslinuxDaemon {
+    fn set_led_mode(&self, data: &str) -> Result<(), dbus::Error>;
+    fn led_mode(&self) -> Result<String, dbus::Error>;
+    fn led_modes(&self) -> Result<String, dbus::Error>;
+}
+
+impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target=T>> OrgAsuslinuxDaemon for blocking::Proxy<'a, C> {
+
+    fn set_led_mode(&self, data: &str) -> Result<(), dbus::Error> {
+        self.method_call("org.asuslinux.Daemon", "SetLedMode", (data, ))
+    }
+
+    fn led_mode(&self) -> Result<String, dbus::Error> {
+        self.method_call("org.asuslinux.Daemon", "LedMode", ())
+            .and_then(|r: (String, )| Ok(r.0, ))
+    }
+
+    fn led_modes(&self) -> Result<String, dbus::Error> {
+        self.method_call("org.asuslinux.Daemon", "LedModes", ())
+            .and_then(|r: (String, )| Ok(r.0, ))
+    }
+}
+
+#[derive(Debug)]
+pub struct OrgAsuslinuxDaemonNotifyLed {
+    pub data: String,
+}
+
+impl arg::AppendAll for OrgAsuslinuxDaemonNotifyLed {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.data, i);
+    }
+}
+
+impl arg::ReadAll for OrgAsuslinuxDaemonNotifyLed {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(OrgAsuslinuxDaemonNotifyLed {
+            data: i.read()?,
+        })
+    }
+}
+
+impl dbus::message::SignalArgs for OrgAsuslinuxDaemonNotifyLed {
+    const NAME: &'static str = "NotifyLed";
+    const INTERFACE: &'static str = "org.asuslinux.Daemon";
+}

asus-nb/src/dbus_profile.rs

@@ -0,0 +1,51 @@
+// This code was autogenerated with `dbus-codegen-rust -s -d org.asuslinux.Daemon -f org.asuslinux.Daemon -c blocking -p /org/asuslinux/Profile -m None`, see https://github.com/diwic/dbus-rs
+use dbus;
+#[allow(unused_imports)]
+use dbus::arg;
+use dbus::blocking;
+
+pub trait OrgAsuslinuxDaemon {
+    fn set_profile(&self, profile: &str) -> Result<(), dbus::Error>;
+    fn profile(&self) -> Result<String, dbus::Error>;
+    fn profiles(&self) -> Result<String, dbus::Error>;
+}
+
+impl<'a, T: blocking::BlockingSender, C: ::std::ops::Deref<Target = T>> OrgAsuslinuxDaemon
+    for blocking::Proxy<'a, C>
+{
+    fn set_profile(&self, profile: &str) -> Result<(), dbus::Error> {
+        self.method_call("org.asuslinux.Daemon", "SetProfile", (profile,))
+    }
+
+    fn profile(&self) -> Result<String, dbus::Error> {
+        self.method_call("org.asuslinux.Daemon", "Profile", ())
+            .and_then(|r: (String,)| Ok(r.0))
+    }
+
+    fn profiles(&self) -> Result<String, dbus::Error> {
+        self.method_call("org.asuslinux.Daemon", "Profiles", ())
+            .and_then(|r: (String,)| Ok(r.0))
+    }
+}
+
+#[derive(Debug)]
+pub struct OrgAsuslinuxDaemonNotifyProfile {
+    pub profile: String,
+}
+
+impl arg::AppendAll for OrgAsuslinuxDaemonNotifyProfile {
+    fn append(&self, i: &mut arg::IterAppend) {
+        arg::RefArg::append(&self.profile, i);
+    }
+}
+
+impl arg::ReadAll for OrgAsuslinuxDaemonNotifyProfile {
+    fn read(i: &mut arg::Iter) -> Result<Self, arg::TypeMismatchError> {
+        Ok(OrgAsuslinuxDaemonNotifyProfile { profile: i.read()? })
+    }
+}
+
+impl dbus::message::SignalArgs for OrgAsuslinuxDaemonNotifyProfile {
+    const NAME: &'static str = "NotifyProfile";
+    const INTERFACE: &'static str = "org.asuslinux.Daemon";
+}

asus-nb/src/error.rs

@@ -1,5 +1,7 @@
+use std::error::Error;
 use std::fmt;
 
+#[derive(Debug)]
 pub enum AuraError {
     ParseColour,
     ParseSpeed,
@@ -18,3 +20,21 @@ impl fmt::Display for AuraError {
         }
     }
 }
+
+impl Error for AuraError {}
+
+#[derive(Debug)]
+pub enum GraphicsError {
+    ParseVendor,
+}
+
+impl fmt::Display for GraphicsError {
+    // This trait requires `fmt` with this exact signature.
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            GraphicsError::ParseVendor => write!(f, "Could not parse vendor name"),
+        }
+    }
+}
+
+impl Error for GraphicsError {}

asus-nb/src/lib.rs

@@ -23,6 +23,11 @@ pub mod anime_dbus;
 /// Helper functions for the AniMe display
 pub mod anime_matrix;
 
+pub mod dbus_gfx;
+pub mod dbus_ledmode;
+pub mod dbus_profile;
+pub mod dbus_charge;
+
 pub mod error;
 
 // static LED_INIT1: [u8; 2] = [0x5d, 0xb9];

asus-nb/src/profile.rs

@@ -7,6 +7,7 @@ use std::str::FromStr;
 pub enum ProfileEvent {
     Cli(ProfileCommand),
     ChangeMode(u8),
+    Toggle,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]