ROGCC: Make zbus notifications fully manage pagestates

Add led_data for 2022 ASUS TUF Gaming A15 FA506IE

See merge request asus-linux/asusctl!137

.gitlab-ci.yml

@@ -1,7 +1,7 @@
-image: rustdocker/rust:stable
+image: rust:latest
 
 before_script:
-  - apt-get update -qq && apt-get install -y -qq libdbus-1-dev libclang-dev libudev-dev
+  - apt-get update -qq && apt-get install -y -qq libdbus-1-dev libclang-dev libudev-dev libfontconfig1-dev
 
 stages:
     - test
@@ -9,7 +9,9 @@ stages:
 
 test:
   script:
-    - cargo check #+nightly check --features "clippy"
+    - rustup component add clippy
+    - cargo check
+    - cargo clippy
     - cargo test
 
 build:

CHANGELOG.md

@@ -4,7 +4,56 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased ]
+## [Unreleased]
+## [v4.5.1- RC2]
+- Share pagestates with tray process in ROGCC
+
+## [v4.5.1- RC1]
+### Added
+- Support for FA506IE LED modes (Author: Herohtar)
+### Changed
+- Add a basic system tray with dGPU status and gpu mode switch actions
+- Fixup some notifications in ROGCC
+- Add config options for notifications for ROGCC
+- Share pagestates with tray process in ROGCC
+
+## [v4.5.0]
+### Added
+- intofy watches on:
+  - `charge_control_end_threshold`
+  - `panel_od`
+  - `gpu_mux_mode`
+  - `platform_profile`
+  - keyboard brightness
+  - These allow for updating any associated config and sending dbus notifications.
+- New dbus methods
+  - `DgpuDisable`
+  - `SetDgpuDisable`
+  - `NotifyDgpuDisable`
+  - `EgpuEnable`
+  - `SetEgpuEnable`
+  - `NotifyEgpuEnable`
+  - `MainsOnline` (This is AC, check if plugged in or not)
+  - `NotifyMainsOnline`
+- `nvidia-powerd.service` will now enable or disable depending on the AC power state
+  and on resume/boot (hybrid boot). It has been proven that this nvidia daemon can be
+  problematic when on battery, not allowing the dgpu to suspend within decent time and
+  sometimes blocking it completely.
+- Notification to rog-control-center of dGPU state change
+### Changed
+- Use loops to ensure that mutex is gained for LED changes.
+- asusctl now uses tokio for async runtime. This helps simplify some code.
+- Properly fix notifs used in rog-control-center
+### Breaking
+- DBUS: all charge control methods renamed to:
+  - `ChargeControlEndThreshold`
+  - `SetChargeControlEndThreshold`
+  - `NotifyChargeControlEndThreshold`
+- DBUS: all panel overdrive methods renamed to:
+  - `PanelOd` (from PanelOverdrive)
+  - `SetPanelOd`
+  - `NotifyPanelOd`
+  - Path `/org/asuslinux/Charge` changed to `/org/asuslinux/Power`
 
 ## [v4.4.0] - 2022-08-29
 ### Added

Cargo.toml

@@ -1,5 +1,43 @@
 [workspace]
-members = ["asusctl", "asus-notify", "daemon", "daemon-user", "rog-platform", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles", "rog-control-center"]
+members = ["asusctl", "daemon", "daemon-user", "rog-platform", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles", "rog-control-center"]
+
+[workspace.package]
+version = "4.5.1-RC2"
+
+[workspace.dependencies]
+async-trait = "^0.1"
+tokio = { version = "^1.21.2", features = ["macros", "rt-multi-thread", "time", "sync"]}
+concat-idents = "^1.1"
+dirs = "^4.0"
+smol = "^1.2"
+
+zbus = "^3.4"
+zbus_macros = "^3.4"
+zvariant = "^3.7"
+zvariant_derive = "^3.7"
+logind-zbus = { version = "^3.0" } #, default-features = false, features = ["non_blocking"] }
+
+serde = "^1.0"
+serde_derive = "^1.0"
+serde_json = "^1.0"
+toml = "^0.5.9"
+
+log = "^0.4"
+env_logger = "^0.9.3"
+
+glam = { version = "^0.22", features = ["serde"] }
+gumdrop = "^0.8"
+udev = "^0.6"
+rusb = "^0.9"
+sysfs-class = "^0.1.2"
+inotify = "^0.10.0"
+
+png_pong = "^0.8"
+pix = "^0.13"
+tinybmp = "^0.3"
+gif = "^0.11"
+
+notify-rust = { git = "https://github.com/flukejones/notify-rust.git", default-features = false, features = ["z"] }
 
 [profile.release]
 # thin = 57s, asusd = 9.0M
@@ -10,7 +48,7 @@ opt-level = 3
 panic = "abort"
 
 [profile.dev]
-debug = false
+debug = true
 opt-level = 1
 
 [profile.bench]

Makefile

@@ -15,7 +15,6 @@ BIN_ROG := rog-control-center
 BIN_C := asusctl
 BIN_D := asusd
 BIN_U := asusd-user
-BIN_N := asus-notify
 LEDCFG := asusd-ledmodes.toml
 
 SRC := Cargo.toml Cargo.lock Makefile $(shell find -type f -wholename '**/src/*.rs')
@@ -48,19 +47,20 @@ install:
 	$(INSTALL_PROGRAM) "./target/release/$(BIN_C)" "$(DESTDIR)$(bindir)/$(BIN_C)"
 	$(INSTALL_PROGRAM) "./target/release/$(BIN_D)" "$(DESTDIR)$(bindir)/$(BIN_D)"
 	$(INSTALL_PROGRAM) "./target/release/$(BIN_U)" "$(DESTDIR)$(bindir)/$(BIN_U)"
-	$(INSTALL_PROGRAM) "./target/release/$(BIN_N)" "$(DESTDIR)$(bindir)/$(BIN_N)"
 
 	$(INSTALL_DATA) "./data/$(BIN_D).rules" "$(DESTDIR)$(libdir)/udev/rules.d/99-$(BIN_D).rules"
 	$(INSTALL_DATA) "./data/$(LEDCFG)" "$(DESTDIR)/etc/asusd/$(LEDCFG)"
 	$(INSTALL_DATA) "./data/$(BIN_D).conf" "$(DESTDIR)$(datarootdir)/dbus-1/system.d/$(BIN_D).conf"
 
 	$(INSTALL_DATA) "./data/$(BIN_D).service" "$(DESTDIR)$(libdir)/systemd/system/$(BIN_D).service"
-	$(INSTALL_DATA) "./data/$(BIN_N).service" "$(DESTDIR)$(libdir)/systemd/user/$(BIN_N).service"
 	$(INSTALL_DATA) "./data/$(BIN_U).service" "$(DESTDIR)$(libdir)/systemd/user/$(BIN_U).service"
 
 	$(INSTALL_DATA) "./data/icons/asus_notif_yellow.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_yellow.png"
 	$(INSTALL_DATA) "./data/icons/asus_notif_green.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_green.png"
+	$(INSTALL_DATA) "./data/icons/asus_notif_blue.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_blue.png"
 	$(INSTALL_DATA) "./data/icons/asus_notif_red.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_red.png"
+	$(INSTALL_DATA) "./data/icons/asus_notif_orange.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_orange.png"
+	$(INSTALL_DATA) "./data/icons/asus_notif_white.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_white.png"
 
 	$(INSTALL_DATA) "./data/icons/scalable/gpu-compute.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-compute.svg"
 	$(INSTALL_DATA) "./data/icons/scalable/gpu-hybrid.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-hybrid.svg"
@@ -78,12 +78,10 @@ uninstall:
 
 	rm -f "$(DESTDIR)$(bindir)/$(BIN_C)"
 	rm -f "$(DESTDIR)$(bindir)/$(BIN_D)"
-	rm -f "$(DESTDIR)$(bindir)/$(BIN_N)"
 	rm -f "$(DESTDIR)$(libdir)/udev/rules.d/99-$(BIN_D).rules"
 	rm -f "$(DESTDIR)/etc/asusd/$(LEDCFG)"
 	rm -f "$(DESTDIR)$(datarootdir)/dbus-1/system.d/$(BIN_D).conf"
 	rm -f "$(DESTDIR)$(libdir)/systemd/system/$(BIN_D).service"
-	rm -r "$(DESTDIR)$(libdir)/systemd/user/$(BIN_N).service"
 	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_yellow.png"
 	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_green.png"
 	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_red.png"
@@ -114,5 +112,9 @@ ifeq ($(VENDORED),1)
 	tar pxf vendor_asusctl_$(VERSION).tar.xz
 endif
 	cargo build $(ARGS)
+	strip -s ./target/release/$(BIN_C)
+	strip -s ./target/release/$(BIN_D)
+	strip -s ./target/release/$(BIN_U)
+	strip -s ./target/release/$(BIN_ROG)
 
 .PHONY: all clean distclean install uninstall update build

README.md

@@ -81,7 +81,16 @@ Requirements are rust >= 1.57 installed from rustup.io if the distro provided ve
 
 **fedora:**
 
-    dnf install clang-devel systemd-devel cargo
+    dnf install cmake clang-devel systemd-devel gtk3-devel
+    make
+    sudo make install
+
+**openSUSE:**
+
+Works with KDE Plasma (without GTK packages)
+
+    zypper in -t pattern devel_basis
+    zypper in rustup cmake clang-devel systemd-devel glib2-devel cairo-devel atkmm-devel pangomm-devel gdk-pixbuf-devel gtk3-devel
     make
     sudo make install
 

asus-notify/Cargo.toml

@@ -1,22 +0,0 @@
-[package]
-name = "asus-notify"
-version = "3.1.0"
-authors = ["Luke D Jones <luke@ljones.dev>"]
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-zbus = "^2.2"
-# serialisation
-serde_json = "^1.0"
-rog_dbus = { path = "../rog-dbus" }
-rog_aura = { path = "../rog-aura" }
-rog_platform = { path = "../rog-platform" }
-rog_profiles = { path = "../rog-profiles" }
-smol = "^1.2"
-
-[dependencies.notify-rust]
-version = "^4.3"
-default-features = false
-features = ["z"]

asus-notify/src/main.rs

@@ -1,166 +0,0 @@
-use notify_rust::{Hint, Notification, NotificationHandle};
-use rog_aura::AuraEffect;
-use rog_dbus::{
-    zbus_charge::ChargeProxy, zbus_led::LedProxy, zbus_platform::RogBiosProxy,
-    zbus_profile::ProfileProxy,
-};
-use rog_profiles::Profile;
-use smol::{future, Executor};
-use std::{
-    error::Error,
-    sync::{Arc, Mutex},
-};
-use zbus::export::futures_util::StreamExt;
-
-const NOTIF_HEADER: &str = "ROG Control";
-
-macro_rules! notify {
-    ($notifier:ident, $last_notif:ident, $data:expr) => {
-        if let Some(notif) = $last_notif.take() {
-            notif.close();
-        }
-        if let Ok(x) = $notifier($data) {
-            $last_notif.replace(x);
-        }
-    };
-}
-
-macro_rules! base_notification {
-    ($body:expr) => {
-        Notification::new()
-            .summary(NOTIF_HEADER)
-            .body($body)
-            .timeout(2000)
-            .show()
-    };
-}
-
-type SharedHandle = Arc<Mutex<Option<NotificationHandle>>>;
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    println!("asus-notify version {}", env!("CARGO_PKG_VERSION"));
-    println!("   rog-dbus version {}", rog_dbus::VERSION);
-
-    let last_notification: SharedHandle = Arc::new(Mutex::new(None));
-
-    let executor = Executor::new();
-    // BIOS notif
-    let x = last_notification.clone();
-    executor
-        .spawn(async move {
-            let conn = zbus::Connection::system().await.unwrap();
-            let proxy = RogBiosProxy::new(&conn).await.unwrap();
-            if let Ok(p) = proxy.receive_notify_post_boot_sound().await {
-                p.for_each(|e| {
-                    if let Ok(out) = e.args() {
-                        if let Ok(ref mut lock) = x.try_lock() {
-                            notify!(do_post_sound_notif, lock, &out.sound());
-                        }
-                    }
-                    future::ready(())
-                })
-                .await;
-            };
-        })
-        .detach();
-
-    // Charge notif
-    let x = last_notification.clone();
-    executor
-        .spawn(async move {
-            let conn = zbus::Connection::system().await.unwrap();
-            let proxy = ChargeProxy::new(&conn).await.unwrap();
-            if let Ok(p) = proxy.receive_notify_charge().await {
-                p.for_each(|e| {
-                    if let Ok(out) = e.args() {
-                        if let Ok(ref mut lock) = x.try_lock() {
-                            notify!(do_charge_notif, lock, &out.limit);
-                        }
-                    }
-                    future::ready(())
-                })
-                .await;
-            };
-        })
-        .detach();
-
-    // Profile notif
-    let x = last_notification.clone();
-    executor
-        .spawn(async move {
-            let conn = zbus::Connection::system().await.unwrap();
-            let proxy = ProfileProxy::new(&conn).await.unwrap();
-            if let Ok(p) = proxy.receive_notify_profile().await {
-                p.for_each(|e| {
-                    if let Ok(out) = e.args() {
-                        if let Ok(ref mut lock) = x.try_lock() {
-                            notify!(do_thermal_notif, lock, &out.profile);
-                        }
-                    }
-                    future::ready(())
-                })
-                .await;
-            };
-        })
-        .detach();
-
-    // LED notif
-    executor
-        .spawn(async move {
-            let conn = zbus::Connection::system().await.unwrap();
-            let proxy = LedProxy::new(&conn).await.unwrap();
-            if let Ok(p) = proxy.receive_notify_led().await {
-                p.for_each(|e| {
-                    if let Ok(out) = e.args() {
-                        if let Ok(ref mut lock) = last_notification.try_lock() {
-                            notify!(do_led_notif, lock, &out.data);
-                        }
-                    }
-                    future::ready(())
-                })
-                .await;
-            };
-        })
-        .detach();
-
-    loop {
-        smol::block_on(executor.tick());
-    }
-}
-
-fn do_thermal_notif(profile: &Profile) -> Result<NotificationHandle, Box<dyn Error>> {
-    let icon = match profile {
-        Profile::Balanced => "asus_notif_yellow",
-        Profile::Performance => "asus_notif_red",
-        Profile::Quiet => "asus_notif_green",
-    };
-    let profile: &str = (*profile).into();
-    let x = Notification::new()
-        .summary("ASUS ROG")
-        .body(&format!(
-            "Thermal profile changed to {}",
-            profile.to_uppercase(),
-        ))
-        .hint(Hint::Resident(true))
-        .timeout(2000)
-        .hint(Hint::Category("device".into()))
-        //.hint(Hint::Transient(true))
-        .icon(icon)
-        .show()?;
-    Ok(x)
-}
-
-fn do_led_notif(ledmode: &AuraEffect) -> Result<NotificationHandle, notify_rust::error::Error> {
-    base_notification!(&format!(
-        "Keyboard LED mode changed to {}",
-        ledmode.mode_name()
-    ))
-}
-
-fn do_charge_notif(limit: &u8) -> Result<NotificationHandle, notify_rust::error::Error> {
-    base_notification!(&format!("Battery charge limit changed to {}", limit))
-}
-
-fn do_post_sound_notif(on: &bool) -> Result<NotificationHandle, notify_rust::error::Error> {
-    base_notification!(&format!("BIOS Post sound {}", on))
-}

asusctl/Cargo.toml

@@ -1,26 +1,23 @@
 [package]
 name = "asusctl"
-version = "4.3.3"
 authors = ["Luke D Jones <luke@ljones.dev>"]
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+edition = "2021"
+version.workspace = true
 
 [dependencies]
-zbus = "^2.2"
 rog_anime = { path = "../rog-anime" }
 rog_aura = { path = "../rog-aura" }
 rog_dbus = { path = "../rog-dbus" }
 rog_profiles = { path = "../rog-profiles" }
 rog_platform = { path = "../rog-platform" }
 daemon = { path = "../daemon" }
-gumdrop = "^0.8"
-toml = "^0.5.8"
 
-sysfs-class = "^0.1.2"
+gumdrop.workspace = true
+toml.workspace = true
+sysfs-class.workspace = true
 
 [dev-dependencies]
-tinybmp = "^0.3.3"
-glam = "^0.21.2"
+gif.workspace = true
+tinybmp.workspace = true
+glam.workspace = true
 rog_dbus = { path = "../rog-dbus" }
-gif = "^0.11.2"

asusctl/src/main.rs

@@ -29,23 +29,18 @@ mod profiles_cli;
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let args: Vec<String> = args().skip(1).collect();
 
-    let parsed: CliStart;
     let missing_argument_k = gumdrop::Error::missing_argument(Opt::Short('k'));
-    match CliStart::parse_args_default(&args) {
-        Ok(p) => {
-            parsed = p;
-        }
-        Err(err) if err.to_string() == missing_argument_k.to_string() => {
-            parsed = CliStart {
-                kbd_bright: Some(LedBrightness::new(None)),
-                ..Default::default()
-            };
-        }
+    let parsed = match CliStart::parse_args_default(&args) {
+        Ok(p) => p,
+        Err(err) if err.to_string() == missing_argument_k.to_string() => CliStart {
+            kbd_bright: Some(LedBrightness::new(None)),
+            ..Default::default()
+        },
         Err(err) => {
             eprintln!("source {}", err);
             std::process::exit(2);
         }
-    }
+    };
 
     let (dbus, _) = RogDbusClientBlocking::new()
         .map_err(|e| {
@@ -211,7 +206,9 @@ fn do_parsed(
     }
 
     if let Some(chg_limit) = parsed.chg_limit {
-        dbus.proxies().charge().set_limit(chg_limit)?;
+        dbus.proxies()
+            .charge()
+            .set_charge_control_end_threshold(chg_limit)?;
     }
 
     Ok(())
@@ -374,7 +371,7 @@ fn handle_anime(
 }
 
 fn verify_brightness(brightness: f32) {
-    if brightness < 0.0 || brightness > 1.0 {
+    if !(0.0..=1.0).contains(&brightness) {
         println!(
             "Image and global brightness must be between 0.0 and 1.0 (inclusive), was {}",
             brightness
@@ -472,7 +469,7 @@ fn handle_led_power1(
     }
 
     println!("These options are for keyboards of product ID 0x1866 or TUF only");
-    return Ok(());
+    Ok(())
 }
 
 fn handle_led_power_1_do_1866(
@@ -542,7 +539,6 @@ fn handle_led_power_1_do_tuf(
         x19b6: vec![],
         tuf: enabled,
     };
-    dbg!(&data);
     dbus.proxies().led().set_leds_power(data, true)?;
 
     let data = AuraPowerDev {
@@ -803,10 +799,10 @@ fn handle_bios_option(
         }
 
         if let Some(opt) = cmd.panel_overdrive_set {
-            dbus.proxies().rog_bios().set_panel_overdrive(opt)?;
+            dbus.proxies().rog_bios().set_panel_od(opt)?;
         }
         if cmd.panel_overdrive_get {
-            let res = dbus.proxies().rog_bios().panel_overdrive()?;
+            let res = dbus.proxies().rog_bios().panel_od()?;
             println!("Panel overdrive on: {}", res);
         }
     }

daemon-user/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "daemon-user"
-version = "1.3.1"
+version.workspace = true
 authors = ["Luke D Jones <luke@ljones.dev>"]
-edition = "2018"
+edition = "2021"
 description = "Usermode daemon for user settings, anime, per-key lighting"
 
 [lib]
@@ -14,20 +14,19 @@ name = "asusd-user"
 path = "src/daemon.rs"
 
 [dependencies]
+dirs.workspace = true
+smol.workspace = true
+
 # serialisation
-serde = "^1.0"
-serde_json = "^1.0"
-serde_derive = "^1.0"
+serde.workspace = true
+serde_json.workspace = true
+serde_derive.workspace = true
 
 rog_anime = { path = "../rog-anime" }
 rog_aura = { path = "../rog-aura" }
 rog_dbus = { path = "../rog-dbus" }
 rog_platform = { path = "../rog-platform" }
 
-dirs = "^4.0"
-
-zbus = "^2.2"
-zvariant = "^3.0"
-zvariant_derive = "^3.0"
-
-smol = "^1.2"
+zbus.workspace = true
+zvariant.workspace = true
+zvariant_derive.workspace = true

daemon-user/src/daemon.rs

@@ -86,7 +86,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             .map_err(|e| {
                 println!("{BOARD_NAME}, {e}");
             })
-            .unwrap_or(KeyLayout::ga401_layout());
+            .unwrap_or_else(|_| KeyLayout::ga401_layout());
 
         executor
             .spawn(async move {

daemon-user/src/user_config.rs

@@ -30,7 +30,7 @@ pub trait ConfigLoadSave<T: DeserializeOwned + serde::Serialize> {
         if !path.exists() {
             create_dir(path.clone())?;
         }
-        let name = self.name().clone();
+        let name = self.name();
         path.push(name + ".cfg");
 
         let mut file = OpenOptions::new()
@@ -230,7 +230,7 @@ impl Default for UserAuraConfig {
             80,
             40,
         ));
-        seq.push(key.clone());
+        seq.push(key);
 
         Self {
             name: "default".to_string(),

daemon/Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 name = "daemon"
-version = "4.4.0"
+version.workspace = true
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
 repository = "https://gitlab.com/asus-linux/asus-nb-ctrl"
 homepage = "https://gitlab.com/asus-linux/asus-nb-ctrl"
 description = "A daemon app for ASUS GX502 and similar laptops to control missing features"
-edition = "2018"
+edition = "2021"
 
 [lib]
 name = "daemon"
@@ -24,22 +24,24 @@ rog_platform = { path = "../rog-platform" }
 rog_profiles = { path = "../rog-profiles" }
 rog_dbus = { path = "../rog-dbus" }
 
-async-trait = "^0.1"
-smol = "^1.2"
+async-trait.workspace = true
+tokio.workspace = true
 
 # cli and logging
-log = "^0.4"
-env_logger = "^0.9"
+log.workspace = true
+env_logger.workspace = true
 
-zbus = "^2.2"
-zvariant = "^3.2"
-logind-zbus = { version = "^3.0" } #, default-features = false, features = ["non_blocking"] }
+zbus.workspace = true
+zvariant.workspace = true
+logind-zbus.workspace = true
 
 # serialisation
-serde = "^1.0"
-serde_derive = "^1.0"
-serde_json = "^1.0"
-toml = "^0.5.8"
+serde.workspace = true
+serde_derive.workspace = true
+serde_json.workspace = true
+toml.workspace = true
 
 # Device control
-sysfs-class = "^0.1.2" # used for backlight control and baord ID
+sysfs-class.workspace = true # used for backlight control and baord ID
+
+concat-idents.workspace = true

daemon/src/config.rs

@@ -61,7 +61,7 @@ impl Config {
     pub fn read(&mut self) {
         let mut file = OpenOptions::new()
             .read(true)
-            .open(&CONFIG_PATH)
+            .open(CONFIG_PATH)
             .unwrap_or_else(|err| panic!("Error reading {}: {}", CONFIG_PATH, err));
         let mut buf = String::new();
         if let Ok(l) = file.read_to_string(&mut buf) {

daemon/src/ctrl_anime/mod.rs

@@ -1,29 +1,19 @@
 pub mod config;
-pub mod zbus;
+/// Implements CtrlTask, Reloadable, ZbusRun
+pub mod trait_impls;
 
-use async_trait::async_trait;
+use self::config::{AnimeConfig, AnimeConfigCached};
+use crate::{error::RogError, GetSupported};
+use ::zbus::export::futures_util::lock::Mutex;
 use log::{error, info, warn};
 use rog_anime::{
     error::AnimeError,
-    usb::{
-        get_anime_type, pkt_for_apply, pkt_for_flush, pkt_for_set_boot, pkt_for_set_on,
-        pkts_for_init,
-    },
+    usb::{get_anime_type, pkt_for_flush, pkts_for_init},
     ActionData, AnimeDataBuffer, AnimePacketType, AnimeType,
 };
 use rog_platform::{hid_raw::HidRaw, supported::AnimeSupportedFunctions, usb_raw::USBRaw};
-use smol::Executor;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::{
-    convert::TryFrom,
-    error::Error,
-    sync::{Arc, Mutex, MutexGuard},
-    thread::sleep,
-};
-
-use crate::{error::RogError, GetSupported};
-
-use self::config::{AnimeConfig, AnimeConfigCached};
+use std::{convert::TryFrom, error::Error, sync::Arc, thread::sleep};
 
 impl GetSupported for CtrlAnime {
     type A = AnimeSupportedFunctions;
@@ -85,6 +75,7 @@ impl CtrlAnime {
 
         // The only reason for this outer thread is to prevent blocking while waiting for the
         // next spawned thread to exit
+        // TODO: turn this in to async task (maybe? COuld still risk blocking main thread)
         std::thread::Builder::new()
             .name("AniMe system thread start".into())
             .spawn(move || {
@@ -95,7 +86,7 @@ impl CtrlAnime {
                 let thread_running;
                 let anime_type;
                 loop {
-                    if let Ok(lock) = inner.try_lock() {
+                    if let Some(lock) = inner.try_lock() {
                         thread_exit = lock.thread_exit.clone();
                         thread_running = lock.thread_running.clone();
                         anime_type = lock.anime_type;
@@ -139,9 +130,10 @@ impl CtrlAnime {
                                                 .ok();
                                             false // Don't exit yet
                                         })
-                                        .map_err(|err| {
-                                            warn!("rog_anime::run_animation:callback {}", err);
-                                            AnimeError::NoFrames
+                                        .map(Ok)
+                                        .unwrap_or_else(|| {
+                                            warn!("rog_anime::run_animation:callback failed");
+                                            Err(AnimeError::NoFrames)
                                         })
                                 }) {
                                     warn!("rog_anime::run_animation:Animation {}", err);
@@ -150,7 +142,7 @@ impl CtrlAnime {
                             }
                             ActionData::Image(image) => {
                                 once = false;
-                                if let Ok(lock) = inner.try_lock() {
+                                if let Some(lock) = inner.try_lock() {
                                     lock.write_data_buffer(image.as_ref().clone())
                                         .map_err(|e| error!("{}", e))
                                         .ok();
@@ -171,7 +163,7 @@ impl CtrlAnime {
                     }
                 }
                 // Clear the display on exit
-                if let Ok(lock) = inner.try_lock() {
+                if let Some(lock) = inner.try_lock() {
                     if let Ok(data) =
                         AnimeDataBuffer::from_vec(anime_type, vec![0u8; anime_type.data_length()])
                             .map_err(|e| error!("{}", e))
@@ -216,85 +208,3 @@ impl CtrlAnime {
         Ok(())
     }
 }
-
-pub struct CtrlAnimeTask {
-    inner: Arc<Mutex<CtrlAnime>>,
-}
-
-impl CtrlAnimeTask {
-    pub async fn new(inner: Arc<Mutex<CtrlAnime>>) -> CtrlAnimeTask {
-        Self { inner }
-    }
-}
-
-#[async_trait]
-impl crate::CtrlTask for CtrlAnimeTask {
-    async fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
-        let run_action =
-            |start: bool, lock: MutexGuard<CtrlAnime>, inner: Arc<Mutex<CtrlAnime>>| {
-                if start {
-                    info!("CtrlAnimeTask running sleep animation");
-                    CtrlAnime::run_thread(inner.clone(), lock.cache.shutdown.clone(), true);
-                } else {
-                    info!("CtrlAnimeTask running wake animation");
-                    CtrlAnime::run_thread(inner.clone(), lock.cache.wake.clone(), true);
-                }
-            };
-
-        let inner1 = self.inner.clone();
-        let inner2 = self.inner.clone();
-        let inner3 = self.inner.clone();
-        let inner4 = self.inner.clone();
-        self.create_sys_event_tasks(
-            executor,
-            // Loop is required to try an attempt to get the mutex *without* blocking
-            // other threads - it is possible to end up with deadlocks otherwise.
-            move || loop {
-                if let Ok(lock) = inner1.clone().try_lock() {
-                    run_action(true, lock, inner1.clone());
-                    break;
-                }
-            },
-            move || loop {
-                if let Ok(lock) = inner2.clone().try_lock() {
-                    run_action(false, lock, inner2.clone());
-                    break;
-                }
-            },
-            move || loop {
-                if let Ok(lock) = inner3.clone().try_lock() {
-                    run_action(true, lock, inner3.clone());
-                    break;
-                }
-            },
-            move || loop {
-                if let Ok(lock) = inner4.clone().try_lock() {
-                    run_action(false, lock, inner4.clone());
-                    break;
-                }
-            },
-        )
-        .await;
-
-        Ok(())
-    }
-}
-
-pub struct CtrlAnimeReloader(pub Arc<Mutex<CtrlAnime>>);
-
-impl crate::Reloadable for CtrlAnimeReloader {
-    fn reload(&mut self) -> Result<(), RogError> {
-        if let Ok(lock) = self.0.try_lock() {
-            lock.node
-                .write_bytes(&pkt_for_set_on(lock.config.awake_enabled))?;
-            lock.node.write_bytes(&pkt_for_apply())?;
-            lock.node
-                .write_bytes(&pkt_for_set_boot(lock.config.boot_anim_enabled))?;
-            lock.node.write_bytes(&pkt_for_apply())?;
-
-            let action = lock.cache.boot.clone();
-            CtrlAnime::run_thread(self.0.clone(), action, true);
-        }
-        Ok(())
-    }
-}

daemon/src/ctrl_anime/trait_impls.rs

@@ -0,0 +1,216 @@
+use super::CtrlAnime;
+use crate::error::RogError;
+use async_trait::async_trait;
+use log::{info, warn};
+use rog_anime::{
+    usb::{pkt_for_apply, pkt_for_set_boot, pkt_for_set_on},
+    AnimeDataBuffer, AnimePowerStates,
+};
+use std::sync::{atomic::Ordering, Arc};
+use zbus::{
+    dbus_interface,
+    export::futures_util::lock::{Mutex, MutexGuard},
+    Connection, SignalContext,
+};
+
+pub(super) const ZBUS_PATH: &str = "/org/asuslinux/Anime";
+
+#[derive(Clone)]
+pub struct CtrlAnimeZbus(pub Arc<Mutex<CtrlAnime>>);
+
+/// The struct with the main dbus methods requires this trait
+#[async_trait]
+impl crate::ZbusRun for CtrlAnimeZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, ZBUS_PATH, 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.
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl CtrlAnimeZbus {
+    /// 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!("rog_anime::run_animation:callback {}", err);
+            err
+        })?;
+        Ok(())
+    }
+
+    /// Set the global AniMe brightness
+    async fn set_brightness(&self, bright: f32) {
+        let mut lock = self.0.lock().await;
+        let mut bright = bright;
+        if bright < 0.0 {
+            bright = 0.0
+        } else if bright > 1.0 {
+            bright = 1.0;
+        }
+        lock.config.brightness = bright;
+        lock.config.write();
+    }
+
+    /// Set whether the AniMe is displaying images/data
+    async fn set_on_off(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>, status: bool) {
+        let mut lock = self.0.lock().await;
+        lock.node
+            .write_bytes(&pkt_for_set_on(status))
+            .map_err(|err| {
+                warn!("rog_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        lock.config.awake_enabled = status;
+        lock.config.write();
+
+        Self::notify_power_states(
+            &ctxt,
+            AnimePowerStates {
+                brightness: lock.config.brightness.floor() as u8,
+                enabled: lock.config.awake_enabled,
+                boot_anim_enabled: lock.config.boot_anim_enabled,
+            },
+        )
+        .await
+        .ok();
+    }
+
+    /// Set whether the AniMe will show boot, suspend, or off animations
+    async fn set_boot_on_off(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>, on: bool) {
+        let mut lock = self.0.lock().await;
+        lock.node
+            .write_bytes(&pkt_for_set_boot(on))
+            .map_err(|err| {
+                warn!("rog_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        lock.node
+            .write_bytes(&pkt_for_apply())
+            .map_err(|err| {
+                warn!("rog_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        lock.config.boot_anim_enabled = on;
+        lock.config.write();
+
+        Self::notify_power_states(
+            &ctxt,
+            AnimePowerStates {
+                brightness: lock.config.brightness.floor() as u8,
+                enabled: lock.config.awake_enabled,
+                boot_anim_enabled: lock.config.boot_anim_enabled,
+            },
+        )
+        .await
+        .ok();
+    }
+
+    /// The main loop is the base system set action if the user isn't running
+    /// the user daemon
+    async fn run_main_loop(&self, start: bool) {
+        if start {
+            let lock = self.0.lock().await;
+            lock.thread_exit.store(true, Ordering::SeqCst);
+            CtrlAnime::run_thread(self.0.clone(), lock.cache.system.clone(), false);
+        }
+    }
+
+    /// Get status of if the AniMe LEDs are on/displaying while system is awake
+    #[dbus_interface(property)]
+    async fn awake_enabled(&self) -> bool {
+        let lock = self.0.lock().await;
+        lock.config.awake_enabled
+    }
+
+    /// Get the status of if factory system-status animations are enabled
+    #[dbus_interface(property)]
+    async fn boot_enabled(&self) -> bool {
+        let lock = self.0.lock().await;
+        lock.config.boot_anim_enabled
+    }
+
+    /// Notify listeners of the status of AniMe LED power and factory system-status animations
+    #[dbus_interface(signal)]
+    async fn notify_power_states(
+        ctxt: &SignalContext<'_>,
+        data: AnimePowerStates,
+    ) -> zbus::Result<()>;
+}
+
+#[async_trait]
+impl crate::CtrlTask for CtrlAnimeZbus {
+    fn zbus_path() -> &'static str {
+        ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, _: SignalContext<'static>) -> Result<(), RogError> {
+        let run_action =
+            |start: bool, lock: MutexGuard<CtrlAnime>, inner: Arc<Mutex<CtrlAnime>>| {
+                if start {
+                    info!("CtrlAnimeTask running sleep animation");
+                    CtrlAnime::run_thread(inner, lock.cache.shutdown.clone(), true);
+                } else {
+                    info!("CtrlAnimeTask running wake animation");
+                    CtrlAnime::run_thread(inner, lock.cache.wake.clone(), true);
+                }
+            };
+
+        let inner1 = self.0.clone();
+        let inner2 = self.0.clone();
+        let inner3 = self.0.clone();
+        let inner4 = self.0.clone();
+        self.create_sys_event_tasks(
+            // Loop is required to try an attempt to get the mutex *without* blocking
+            // other threads - it is possible to end up with deadlocks otherwise.
+            move || loop {
+                if let Some(lock) = inner1.try_lock() {
+                    run_action(true, lock, inner1.clone());
+                    break;
+                }
+            },
+            move || loop {
+                if let Some(lock) = inner2.try_lock() {
+                    run_action(false, lock, inner2.clone());
+                    break;
+                }
+            },
+            move || loop {
+                if let Some(lock) = inner3.try_lock() {
+                    run_action(true, lock, inner3.clone());
+                    break;
+                }
+            },
+            move || loop {
+                if let Some(lock) = inner4.try_lock() {
+                    run_action(false, lock, inner4.clone());
+                    break;
+                }
+            },
+        )
+        .await;
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl crate::Reloadable for CtrlAnimeZbus {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        if let Some(lock) = self.0.try_lock() {
+            lock.node
+                .write_bytes(&pkt_for_set_on(lock.config.awake_enabled))?;
+            lock.node.write_bytes(&pkt_for_apply())?;
+            lock.node
+                .write_bytes(&pkt_for_set_boot(lock.config.boot_anim_enabled))?;
+            lock.node.write_bytes(&pkt_for_apply())?;
+
+            let action = lock.cache.boot.clone();
+            CtrlAnime::run_thread(self.0.clone(), action, true);
+        }
+        Ok(())
+    }
+}

daemon/src/ctrl_anime/zbus.rs

@@ -1,160 +0,0 @@
-use std::sync::{Arc, Mutex};
-
-use async_trait::async_trait;
-use log::warn;
-use rog_anime::{
-    usb::{pkt_for_apply, pkt_for_set_boot, pkt_for_set_on},
-    AnimeDataBuffer, AnimePowerStates,
-};
-use zbus::{dbus_interface, Connection, SignalContext};
-
-use std::sync::atomic::Ordering;
-
-use super::CtrlAnime;
-
-pub struct CtrlAnimeZbus(pub Arc<Mutex<CtrlAnime>>);
-
-/// The struct with the main dbus methods requires this trait
-#[async_trait]
-impl crate::ZbusAdd for CtrlAnimeZbus {
-    async fn add_to_server(self, server: &mut Connection) {
-        Self::add_to_server_helper(self, "/org/asuslinux/Anime", 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.
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl CtrlAnimeZbus {
-    /// Writes a data stream of length. Will force system thread to exit until it is restarted
-    fn write(&self, input: AnimeDataBuffer) -> zbus::fdo::Result<()> {
-        'outer: loop {
-            if let Ok(lock) = self.0.try_lock() {
-                lock.thread_exit.store(true, Ordering::SeqCst);
-                lock.write_data_buffer(input).map_err(|err| {
-                    warn!("rog_anime::run_animation:callback {}", err);
-                    err
-                })?;
-                break 'outer;
-            }
-        }
-        Ok(())
-    }
-
-    /// Set the global AniMe brightness
-    fn set_brightness(&self, bright: f32) {
-        'outer: loop {
-            if let Ok(mut lock) = self.0.try_lock() {
-                let mut bright = bright;
-                if bright < 0.0 {
-                    bright = 0.0
-                } else if bright > 1.0 {
-                    bright = 1.0;
-                }
-                lock.config.brightness = bright;
-                lock.config.write();
-                break 'outer;
-            }
-        }
-    }
-
-    /// Set whether the AniMe is displaying images/data
-    async fn set_on_off(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>, status: bool) {
-        let states;
-        'outer: loop {
-            if let Ok(mut lock) = self.0.try_lock() {
-                lock.node
-                    .write_bytes(&pkt_for_set_on(status))
-                    .map_err(|err| {
-                        warn!("rog_anime::run_animation:callback {}", err);
-                    })
-                    .ok();
-                lock.config.awake_enabled = status;
-                lock.config.write();
-
-                states = Some(AnimePowerStates {
-                    brightness: lock.config.brightness.floor() as u8,
-                    enabled: lock.config.awake_enabled,
-                    boot_anim_enabled: lock.config.boot_anim_enabled,
-                });
-                break 'outer;
-            }
-        }
-        if let Some(state) = states {
-            Self::notify_power_states(&ctxt, state).await.ok();
-        }
-    }
-
-    /// Set whether the AniMe will show boot, suspend, or off animations
-    async fn set_boot_on_off(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>, on: bool) {
-        let states;
-        'outer: loop {
-            if let Ok(mut lock) = self.0.try_lock() {
-                lock.node
-                    .write_bytes(&pkt_for_set_boot(on))
-                    .map_err(|err| {
-                        warn!("rog_anime::run_animation:callback {}", err);
-                    })
-                    .ok();
-                lock.node
-                    .write_bytes(&pkt_for_apply())
-                    .map_err(|err| {
-                        warn!("rog_anime::run_animation:callback {}", err);
-                    })
-                    .ok();
-                lock.config.boot_anim_enabled = on;
-                lock.config.write();
-
-                states = Some(AnimePowerStates {
-                    brightness: lock.config.brightness.floor() as u8,
-                    enabled: lock.config.awake_enabled,
-                    boot_anim_enabled: lock.config.boot_anim_enabled,
-                });
-                break 'outer;
-            }
-        }
-        if let Some(state) = states {
-            Self::notify_power_states(&ctxt, state).await.ok();
-        }
-    }
-
-    /// The main loop is the base system set action if the user isn't running
-    /// the user daemon
-    fn run_main_loop(&self, start: bool) {
-        if start {
-            'outer: loop {
-                if let Ok(lock) = self.0.try_lock() {
-                    lock.thread_exit.store(true, Ordering::SeqCst);
-                    CtrlAnime::run_thread(self.0.clone(), lock.cache.system.clone(), false);
-                    break 'outer;
-                }
-            }
-        }
-    }
-
-    /// Get status of if the AniMe LEDs are on/displaying while system is awake
-    #[dbus_interface(property)]
-    fn awake_enabled(&self) -> bool {
-        if let Ok(ctrl) = self.0.try_lock() {
-            return ctrl.config.awake_enabled;
-        }
-        true
-    }
-
-    /// Get the status of if factory system-status animations are enabled
-    #[dbus_interface(property)]
-    fn boot_enabled(&self) -> bool {
-        if let Ok(ctrl) = self.0.try_lock() {
-            return ctrl.config.boot_anim_enabled;
-        }
-        true
-    }
-
-    /// Notify listeners of the status of AniMe LED power and factory system-status animations
-    #[dbus_interface(signal)]
-    async fn notify_power_states(
-        ctxt: &SignalContext<'_>,
-        data: AnimePowerStates,
-    ) -> zbus::Result<()>;
-}

daemon/src/ctrl_aura/config.rs

@@ -27,11 +27,11 @@ impl AuraPowerConfig {
         match control {
             AuraPowerConfig::AuraDevTuf(_) => [0, 0, 0],
             AuraPowerConfig::AuraDev1866(c) => {
-                let c: Vec<AuraDev1866> = c.iter().map(|v| *v).collect();
+                let c: Vec<AuraDev1866> = c.iter().copied().collect();
                 AuraDev1866::to_bytes(&c)
             }
             AuraPowerConfig::AuraDev19b6(c) => {
-                let c: Vec<AuraDev19b6> = c.iter().map(|v| *v).collect();
+                let c: Vec<AuraDev19b6> = c.iter().copied().collect();
                 AuraDev19b6::to_bytes(&c)
             }
         }
@@ -95,26 +95,26 @@ impl From<&AuraPowerConfig> for AuraPowerDev {
     fn from(config: &AuraPowerConfig) -> Self {
         match config {
             AuraPowerConfig::AuraDevTuf(d) => AuraPowerDev {
-                tuf: d.iter().map(|o| *o).collect(),
+                tuf: d.iter().copied().collect(),
                 x1866: vec![],
                 x19b6: vec![],
             },
             AuraPowerConfig::AuraDev1866(d) => AuraPowerDev {
                 tuf: vec![],
-                x1866: d.iter().map(|o| *o).collect(),
+                x1866: d.iter().copied().collect(),
                 x19b6: vec![],
             },
             AuraPowerConfig::AuraDev19b6(d) => AuraPowerDev {
                 tuf: vec![],
                 x1866: vec![],
-                x19b6: d.iter().map(|o| *o).collect(),
+                x19b6: d.iter().copied().collect(),
             },
         }
     }
 }
 
 #[derive(Deserialize, Serialize)]
-#[serde(default)]
+// #[serde(default)]
 pub struct AuraConfig {
     pub brightness: LedBrightness,
     pub current_mode: AuraModeNum,
@@ -128,7 +128,7 @@ impl Default for AuraConfig {
     fn default() -> Self {
         let mut prod_id = AuraDevice::Unknown;
         for prod in ASUS_KEYBOARD_DEVICES.iter() {
-            if let Ok(_) = HidRaw::new(prod) {
+            if HidRaw::new(prod).is_ok() {
                 prod_id = AuraDevice::from(*prod);
                 break;
             }
@@ -271,7 +271,7 @@ impl AuraConfig {
             if l == 0 {
                 warn!("File is empty {}", AURA_CONFIG_PATH);
             } else {
-                let x: AuraConfig = serde_json::from_str(&buf)
+                let x = serde_json::from_str(&buf)
                     .unwrap_or_else(|_| panic!("Could not deserialise {}", AURA_CONFIG_PATH));
                 *self = x;
             }
@@ -335,26 +335,34 @@ mod tests {
     fn set_multizone_4key_config() {
         let mut config = AuraConfig::default();
 
-        let mut effect = AuraEffect::default();
-        effect.colour1 = Colour(0xff, 0x00, 0xff);
-        effect.zone = AuraZone::Key1;
+        let effect = AuraEffect {
+            colour1: Colour(0xff, 0x00, 0xff),
+            zone: AuraZone::Key1,
+            ..Default::default()
+        };
         config.set_builtin(effect);
 
         assert!(config.multizone.is_some());
 
-        let mut effect = AuraEffect::default();
-        effect.colour1 = Colour(0x00, 0xff, 0xff);
-        effect.zone = AuraZone::Key2;
+        let effect = AuraEffect {
+            colour1: Colour(0x00, 0xff, 0xff),
+            zone: AuraZone::Key2,
+            ..Default::default()
+        };
         config.set_builtin(effect);
 
-        let mut effect = AuraEffect::default();
-        effect.colour1 = Colour(0xff, 0xff, 0x00);
-        effect.zone = AuraZone::Key3;
+        let effect = AuraEffect {
+            colour1: Colour(0xff, 0xff, 0x00),
+            zone: AuraZone::Key3,
+            ..Default::default()
+        };
         config.set_builtin(effect);
 
-        let mut effect = AuraEffect::default();
-        effect.colour1 = Colour(0x00, 0xff, 0x00);
-        effect.zone = AuraZone::Key4;
+        let effect = AuraEffect {
+            colour1: Colour(0x00, 0xff, 0x00),
+            zone: AuraZone::Key4,
+            ..Default::default()
+        };
         let effect_clone = effect.clone();
         config.set_builtin(effect);
         // This should replace existing
@@ -373,25 +381,33 @@ mod tests {
     fn set_multizone_multimode_config() {
         let mut config = AuraConfig::default();
 
-        let mut effect = AuraEffect::default();
-        effect.zone = AuraZone::Key1;
+        let effect = AuraEffect {
+            zone: AuraZone::Key1,
+            ..Default::default()
+        };
         config.set_builtin(effect);
 
         assert!(config.multizone.is_some());
 
-        let mut effect = AuraEffect::default();
-        effect.zone = AuraZone::Key2;
-        effect.mode = AuraModeNum::Breathe;
+        let effect = AuraEffect {
+            zone: AuraZone::Key2,
+            mode: AuraModeNum::Breathe,
+            ..Default::default()
+        };
         config.set_builtin(effect);
 
-        let mut effect = AuraEffect::default();
-        effect.zone = AuraZone::Key3;
-        effect.mode = AuraModeNum::Comet;
+        let effect = AuraEffect {
+            zone: AuraZone::Key3,
+            mode: AuraModeNum::Comet,
+            ..Default::default()
+        };
         config.set_builtin(effect);
 
-        let mut effect = AuraEffect::default();
-        effect.zone = AuraZone::Key4;
-        effect.mode = AuraModeNum::Pulse;
+        let effect = AuraEffect {
+            zone: AuraZone::Key4,
+            mode: AuraModeNum::Pulse,
+            ..Default::default()
+        };
         config.set_builtin(effect);
 
         let res = config.multizone.unwrap();

daemon/src/ctrl_aura/controller.rs

@@ -1,21 +1,15 @@
 use crate::{
     error::RogError,
     laptops::{LaptopLedData, ASUS_KEYBOARD_DEVICES},
-    CtrlTask,
 };
-use async_trait::async_trait;
-use log::{error, info, warn};
+use log::{info, warn};
 use rog_aura::{
     usb::{AuraDevice, LED_APPLY, LED_SET},
     AuraEffect, KeyColourArray, LedBrightness, PerKeyRaw, LED_MSG_LEN,
 };
 use rog_aura::{AuraZone, Direction, Speed, GRADIENT};
 use rog_platform::{hid_raw::HidRaw, keyboard_led::KeyboardLed, supported::LedSupportedFunctions};
-use smol::Executor;
 use std::collections::BTreeMap;
-use std::sync::Arc;
-use std::sync::Mutex;
-use std::sync::MutexGuard;
 
 use crate::GetSupported;
 
@@ -33,7 +27,7 @@ impl GetSupported for CtrlKbdLed {
 
         let mut prod_id = AuraDevice::Unknown;
         for prod in ASUS_KEYBOARD_DEVICES.iter() {
-            if let Ok(_) = HidRaw::new(prod) {
+            if HidRaw::new(prod).is_ok() {
                 prod_id = AuraDevice::from(*prod);
                 break;
             }
@@ -56,7 +50,7 @@ impl GetSupported for CtrlKbdLed {
     }
 }
 
-#[derive(Debug, PartialEq, PartialOrd)]
+#[derive(Debug, PartialEq, Eq, PartialOrd)]
 pub enum LEDNode {
     KbdLed(KeyboardLed),
     Rog(HidRaw),
@@ -74,104 +68,6 @@ pub struct CtrlKbdLed {
     pub config: AuraConfig,
 }
 
-pub struct CtrlKbdLedTask {
-    inner: Arc<Mutex<CtrlKbdLed>>,
-}
-
-impl CtrlKbdLedTask {
-    pub fn new(inner: Arc<Mutex<CtrlKbdLed>>) -> Self {
-        Self { inner }
-    }
-
-    fn update_config(lock: &mut CtrlKbdLed) -> Result<(), RogError> {
-        let bright = lock.kd_brightness.get_brightness()?;
-        lock.config.read();
-        lock.config.brightness = (bright as u32).into();
-        lock.config.write();
-        return Ok(());
-    }
-}
-
-#[async_trait]
-impl CtrlTask for CtrlKbdLedTask {
-    async fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
-        let load_save = |start: bool, mut lock: MutexGuard<CtrlKbdLed>| {
-            // If waking up
-            if !start {
-                info!("CtrlKbdLedTask reloading brightness and modes");
-                lock.set_brightness(lock.config.brightness)
-                    .map_err(|e| error!("CtrlKbdLedTask: {e}"))
-                    .ok();
-                lock.write_current_config_mode()
-                    .map_err(|e| error!("CtrlKbdLedTask: {e}"))
-                    .ok();
-            } else if start {
-                info!("CtrlKbdLedTask saving last brightness");
-                Self::update_config(&mut lock)
-                    .map_err(|e| error!("CtrlKbdLedTask: {e}"))
-                    .ok();
-            }
-        };
-
-        let inner1 = self.inner.clone();
-        let inner2 = self.inner.clone();
-        let inner3 = self.inner.clone();
-        let inner4 = self.inner.clone();
-        self.create_sys_event_tasks(
-            executor,
-            // Loop so that we do aquire the lock but also don't block other
-            // threads (prevents potential deadlocks)
-            move || loop {
-                if let Ok(lock) = inner1.clone().try_lock() {
-                    load_save(true, lock);
-                    break;
-                }
-            },
-            move || loop {
-                if let Ok(lock) = inner2.clone().try_lock() {
-                    load_save(false, lock);
-                    break;
-                }
-            },
-            move || loop {
-                if let Ok(lock) = inner3.clone().try_lock() {
-                    load_save(false, lock);
-                    break;
-                }
-            },
-            move || loop {
-                if let Ok(lock) = inner4.clone().try_lock() {
-                    load_save(false, lock);
-                    break;
-                }
-            },
-        )
-        .await;
-
-        Ok(())
-    }
-}
-
-pub struct CtrlKbdLedReloader(pub Arc<Mutex<CtrlKbdLed>>);
-
-impl crate::Reloadable for CtrlKbdLedReloader {
-    fn reload(&mut self) -> Result<(), RogError> {
-        if let Ok(mut ctrl) = self.0.try_lock() {
-            ctrl.write_current_config_mode()?;
-            ctrl.set_power_states().map_err(|err| warn!("{err}")).ok();
-        }
-        Ok(())
-    }
-}
-
-pub struct CtrlKbdLedZbus(pub Arc<Mutex<CtrlKbdLed>>);
-
-impl CtrlKbdLedZbus {
-    pub fn new(inner: Arc<Mutex<CtrlKbdLed>>) -> Self {
-        Self(inner)
-    }
-}
-
 impl CtrlKbdLed {
     pub fn new(supported_modes: LaptopLedData, config: AuraConfig) -> Result<Self, RogError> {
         let mut led_prod = None;
@@ -225,13 +121,13 @@ impl CtrlKbdLed {
     pub(super) fn get_brightness(&self) -> Result<u8, RogError> {
         self.kd_brightness
             .get_brightness()
-            .map_err(|e| RogError::Platform(e))
+            .map_err(RogError::Platform)
     }
 
     pub(super) fn set_brightness(&self, brightness: LedBrightness) -> Result<(), RogError> {
         self.kd_brightness
             .set_brightness(brightness as u8)
-            .map_err(|e| RogError::Platform(e))
+            .map_err(RogError::Platform)
     }
 
     pub fn next_brightness(&mut self) -> Result<(), RogError> {
@@ -280,10 +176,9 @@ impl CtrlKbdLed {
     /// On success the aura config file is read to refresh cached values, then the effect is
     /// stored and config written to disk.
     pub(crate) fn set_effect(&mut self, effect: AuraEffect) -> Result<(), RogError> {
-        if !self.supported_modes.standard.contains(&effect.mode) {
-            return Err(RogError::AuraEffectNotSupported);
-        } else if effect.zone != AuraZone::None
-            && !self.supported_modes.multizone.contains(&effect.zone)
+        if !self.supported_modes.standard.contains(&effect.mode)
+            || effect.zone != AuraZone::None
+                && !self.supported_modes.multizone.contains(&effect.zone)
         {
             return Err(RogError::AuraEffectNotSupported);
         }
@@ -393,7 +288,7 @@ impl CtrlKbdLed {
         Ok(())
     }
 
-    fn write_current_config_mode(&mut self) -> Result<(), RogError> {
+    pub(super) fn write_current_config_mode(&mut self) -> Result<(), RogError> {
         if self.config.multizone_on {
             let mode = self.config.current_mode;
             let mut create = false;
@@ -491,9 +386,11 @@ mod tests {
             config,
         };
 
-        let mut effect = AuraEffect::default();
-        effect.colour1 = Colour(0xff, 0x00, 0xff);
-        effect.zone = AuraZone::None;
+        let mut effect = AuraEffect {
+            colour1: Colour(0xff, 0x00, 0xff),
+            zone: AuraZone::None,
+            ..Default::default()
+        };
 
         // This error comes from write_bytes because we don't have a keyboard node stored
         assert_eq!(
@@ -525,10 +422,7 @@ mod tests {
 
         controller.supported_modes.multizone.push(AuraZone::Key2);
         assert_eq!(
-            controller
-                .set_effect(effect.clone())
-                .unwrap_err()
-                .to_string(),
+            controller.set_effect(effect).unwrap_err().to_string(),
             "No supported Aura keyboard"
         );
     }

daemon/src/ctrl_aura/mod.rs

@@ -1,3 +1,4 @@
 pub mod config;
 pub mod controller;
-pub mod zbus;
+/// Implements CtrlTask, Reloadable, ZbusRun
+pub mod trait_impls;

daemon/src/ctrl_aura/trait_impls.rs

@@ -0,0 +1,320 @@
+use async_trait::async_trait;
+use log::{error, info, warn};
+use rog_aura::{usb::AuraPowerDev, AuraEffect, AuraModeNum, LedBrightness, PerKeyRaw};
+use std::{collections::BTreeMap, sync::Arc};
+use zbus::{
+    dbus_interface,
+    export::futures_util::{
+        lock::{Mutex, MutexGuard},
+        StreamExt,
+    },
+    Connection, SignalContext,
+};
+
+use crate::{error::RogError, CtrlTask};
+
+use super::controller::CtrlKbdLed;
+
+pub(super) const ZBUS_PATH: &str = "/org/asuslinux/Aura";
+
+#[derive(Clone)]
+pub struct CtrlKbdLedZbus(pub Arc<Mutex<CtrlKbdLed>>);
+
+impl CtrlKbdLedZbus {
+    fn update_config(lock: &mut CtrlKbdLed) -> Result<(), RogError> {
+        let bright = lock.kd_brightness.get_brightness()?;
+        lock.config.read();
+        lock.config.brightness = (bright as u32).into();
+        lock.config.write();
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl crate::ZbusRun for CtrlKbdLedZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, ZBUS_PATH, server).await;
+    }
+}
+
+/// The main interface for changing, reading, or notfying signals
+///
+/// LED commands are split between Brightness, Modes, Per-Key
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl CtrlKbdLedZbus {
+    /// Set the keyboard brightness level (0-3)
+    async fn set_brightness(&mut self, brightness: LedBrightness) {
+        let ctrl = self.0.lock().await;
+        ctrl.set_brightness(brightness)
+            .map_err(|err| warn!("{}", err))
+            .ok();
+    }
+
+    /// Set a variety of states, input is array of enum.
+    /// `enabled` sets if the sent array should be disabled or enabled
+    ///
+    /// ```text
+    /// pub struct AuraPowerDev {
+    ///     pub x1866: Vec<AuraDev1866>,
+    ///     pub x19b6: Vec<AuraDev19b6>,
+    /// }
+    /// pub enum AuraDev1866 {
+    ///     Awake,
+    ///     Keyboard,
+    ///     Lightbar,
+    ///     Boot,
+    ///     Sleep,
+    /// }
+    /// enum AuraDev19b6 {
+    ///     BootLogo,
+    ///     BootKeyb,
+    ///     AwakeLogo,
+    ///     AwakeKeyb,
+    ///     SleepLogo,
+    ///     SleepKeyb,
+    ///     ShutdownLogo,
+    ///     ShutdownKeyb,
+    ///     AwakeBar,
+    ///     BootBar,
+    ///     SleepBar,
+    ///     ShutdownBar,
+    /// }
+    /// ```
+    async fn set_leds_power(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        options: AuraPowerDev,
+        enabled: bool,
+    ) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        for p in options.tuf {
+            ctrl.config.enabled.set_tuf(p, enabled);
+        }
+        for p in options.x1866 {
+            ctrl.config.enabled.set_0x1866(p, enabled);
+        }
+        for p in options.x19b6 {
+            ctrl.config.enabled.set_0x19b6(p, enabled);
+        }
+
+        ctrl.config.write();
+
+        ctrl.set_power_states().map_err(|e| {
+            warn!("{}", e);
+            e
+        })?;
+
+        Self::notify_power_states(&ctxt, &AuraPowerDev::from(&ctrl.config.enabled))
+            .await
+            .unwrap_or_else(|err| warn!("{}", err));
+        Ok(())
+    }
+
+    async fn set_led_mode(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        effect: AuraEffect,
+    ) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+
+        ctrl.set_effect(effect).map_err(|e| {
+            warn!("{}", e);
+            e
+        })?;
+
+        if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
+            Self::notify_led(&ctxt, mode.clone())
+                .await
+                .unwrap_or_else(|err| warn!("{}", err));
+        }
+        Ok(())
+    }
+
+    async fn next_led_mode(
+        &self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+    ) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+
+        ctrl.toggle_mode(false).map_err(|e| {
+            warn!("{}", e);
+            e
+        })?;
+
+        if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
+            Self::notify_led(&ctxt, mode.clone())
+                .await
+                .unwrap_or_else(|err| warn!("{}", err));
+        }
+
+        Ok(())
+    }
+
+    async fn prev_led_mode(
+        &self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+    ) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+
+        ctrl.toggle_mode(true).map_err(|e| {
+            warn!("{}", e);
+            e
+        })?;
+
+        if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
+            Self::notify_led(&ctxt, mode.clone())
+                .await
+                .unwrap_or_else(|err| warn!("{}", err));
+        }
+
+        Ok(())
+    }
+
+    async fn next_led_brightness(&self) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.next_brightness().map_err(|e| {
+            warn!("{}", e);
+            e
+        })?;
+        Ok(())
+    }
+
+    async fn prev_led_brightness(&self) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.prev_brightness().map_err(|e| {
+            warn!("{}", e);
+            e
+        })?;
+        Ok(())
+    }
+
+    // As property doesn't work for AuraPowerDev (complexity of serialization?)
+    // #[dbus_interface(property)]
+    async fn leds_enabled(&self) -> AuraPowerDev {
+        let ctrl = self.0.lock().await;
+        AuraPowerDev::from(&ctrl.config.enabled)
+    }
+
+    /// Return the current mode data
+    async fn led_mode(&self) -> AuraModeNum {
+        let ctrl = self.0.lock().await;
+        ctrl.config.current_mode
+    }
+
+    /// Return a list of available modes
+    async fn led_modes(&self) -> BTreeMap<AuraModeNum, AuraEffect> {
+        let ctrl = self.0.lock().await;
+        ctrl.config.builtins.clone()
+    }
+
+    async fn per_key_raw(&self, data: PerKeyRaw) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.write_effect_block(&data)?;
+        Ok(())
+    }
+
+    /// Return the current LED brightness
+    #[dbus_interface(property)]
+    async fn led_brightness(&self) -> i8 {
+        let ctrl = self.0.lock().await;
+        ctrl.get_brightness().map(|n| n as i8).unwrap_or(-1)
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_led(signal_ctxt: &SignalContext<'_>, data: AuraEffect) -> zbus::Result<()>;
+
+    #[dbus_interface(signal)]
+    async fn notify_power_states(
+        signal_ctxt: &SignalContext<'_>,
+        data: &AuraPowerDev,
+    ) -> zbus::Result<()>;
+}
+
+#[async_trait]
+impl CtrlTask for CtrlKbdLedZbus {
+    fn zbus_path() -> &'static str {
+        ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, _: SignalContext<'static>) -> Result<(), RogError> {
+        let load_save = |start: bool, mut lock: MutexGuard<CtrlKbdLed>| {
+            // If waking up
+            if !start {
+                info!("CtrlKbdLedTask reloading brightness and modes");
+                lock.set_brightness(lock.config.brightness)
+                    .map_err(|e| error!("CtrlKbdLedTask: {e}"))
+                    .ok();
+                lock.write_current_config_mode()
+                    .map_err(|e| error!("CtrlKbdLedTask: {e}"))
+                    .ok();
+            } else if start {
+                info!("CtrlKbdLedTask saving last brightness");
+                Self::update_config(&mut lock)
+                    .map_err(|e| error!("CtrlKbdLedTask: {e}"))
+                    .ok();
+            }
+        };
+
+        let inner1 = self.0.clone();
+        let inner2 = self.0.clone();
+        let inner3 = self.0.clone();
+        let inner4 = self.0.clone();
+        self.create_sys_event_tasks(
+            // Loop so that we do aquire the lock but also don't block other
+            // threads (prevents potential deadlocks)
+            move || loop {
+                if let Some(lock) = inner1.try_lock() {
+                    load_save(true, lock);
+                    break;
+                }
+            },
+            move || loop {
+                if let Some(lock) = inner2.try_lock() {
+                    load_save(false, lock);
+                    break;
+                }
+            },
+            move || loop {
+                if let Some(lock) = inner3.try_lock() {
+                    load_save(true, lock);
+                    break;
+                }
+            },
+            move || loop {
+                if let Some(lock) = inner4.try_lock() {
+                    load_save(false, lock);
+                    break;
+                }
+            },
+        )
+        .await;
+
+        let ctrl2 = self.0.clone();
+        let ctrl = self.0.lock().await;
+        let mut watch = ctrl.kd_brightness.monitor_brightness()?;
+        tokio::spawn(async move {
+            let mut buffer = [0; 32];
+            watch
+                .event_stream(&mut buffer)
+                .unwrap()
+                .for_each(|_| async {
+                    if let Some(lock) = ctrl2.try_lock() {
+                        load_save(true, lock);
+                    }
+                })
+                .await;
+        });
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl crate::Reloadable for CtrlKbdLedZbus {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.write_current_config_mode()?;
+        ctrl.set_power_states().map_err(|err| warn!("{err}")).ok();
+        Ok(())
+    }
+}

daemon/src/ctrl_aura/zbus.rs

@@ -1,238 +0,0 @@
-use std::collections::BTreeMap;
-
-use async_trait::async_trait;
-use log::warn;
-use rog_aura::{usb::AuraPowerDev, AuraEffect, AuraModeNum, LedBrightness, PerKeyRaw};
-use zbus::{dbus_interface, Connection, SignalContext};
-
-use super::controller::CtrlKbdLedZbus;
-
-#[async_trait]
-impl crate::ZbusAdd for CtrlKbdLedZbus {
-    async fn add_to_server(self, server: &mut Connection) {
-        Self::add_to_server_helper(self, "/org/asuslinux/Aura", server).await;
-    }
-}
-
-/// The main interface for changing, reading, or notfying signals
-///
-/// LED commands are split between Brightness, Modes, Per-Key
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl CtrlKbdLedZbus {
-    /// Set the keyboard brightness level (0-3)
-    async fn set_brightness(&mut self, brightness: LedBrightness) {
-        if let Ok(ctrl) = self.0.try_lock() {
-            ctrl.set_brightness(brightness)
-                .map_err(|err| warn!("{}", err))
-                .ok();
-        }
-    }
-
-    /// Set a variety of states, input is array of enum.
-    /// `enabled` sets if the sent array should be disabled or enabled
-    ///
-    /// ```text
-    /// pub struct AuraPowerDev {
-    ///     pub x1866: Vec<AuraDev1866>,
-    ///     pub x19b6: Vec<AuraDev19b6>,
-    /// }
-    /// pub enum AuraDev1866 {
-    ///     Awake,
-    ///     Keyboard,
-    ///     Lightbar,
-    ///     Boot,
-    ///     Sleep,
-    /// }
-    /// enum AuraDev19b6 {
-    ///     BootLogo,
-    ///     BootKeyb,
-    ///     AwakeLogo,
-    ///     AwakeKeyb,
-    ///     SleepLogo,
-    ///     SleepKeyb,
-    ///     ShutdownLogo,
-    ///     ShutdownKeyb,
-    ///     AwakeBar,
-    ///     BootBar,
-    ///     SleepBar,
-    ///     ShutdownBar,
-    /// }
-    /// ```
-    async fn set_leds_power(
-        &mut self,
-        #[zbus(signal_context)] ctxt: SignalContext<'_>,
-        options: AuraPowerDev,
-        enabled: bool,
-    ) -> zbus::fdo::Result<()> {
-        let mut states = None;
-        if let Ok(mut ctrl) = self.0.try_lock() {
-            for p in options.tuf {
-                ctrl.config.enabled.set_tuf(p, enabled);
-            }
-            for p in options.x1866 {
-                ctrl.config.enabled.set_0x1866(p, enabled);
-            }
-            for p in options.x19b6 {
-                ctrl.config.enabled.set_0x19b6(p, enabled);
-            }
-
-            ctrl.config.write();
-
-            ctrl.set_power_states().map_err(|e| {
-                warn!("{}", e);
-                e
-            })?;
-
-            states = Some(AuraPowerDev::from(&ctrl.config.enabled));
-        }
-        // Need to pull state out like this due to MutexGuard
-        if let Some(states) = states {
-            Self::notify_power_states(&ctxt, &states)
-                .await
-                .unwrap_or_else(|err| warn!("{}", err));
-        }
-        Ok(())
-    }
-
-    async fn set_led_mode(
-        &mut self,
-        #[zbus(signal_context)] ctxt: SignalContext<'_>,
-        effect: AuraEffect,
-    ) -> zbus::fdo::Result<()> {
-        let mut led = None;
-        if let Ok(mut ctrl) = self.0.try_lock() {
-            ctrl.set_effect(effect).map_err(|e| {
-                warn!("{}", e);
-                e
-            })?;
-            if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
-                led = Some(mode.clone());
-            }
-        }
-        if let Some(led) = led {
-            Self::notify_led(&ctxt, led)
-                .await
-                .unwrap_or_else(|err| warn!("{}", err));
-        }
-        Ok(())
-    }
-
-    async fn next_led_mode(
-        &self,
-        #[zbus(signal_context)] ctxt: SignalContext<'_>,
-    ) -> zbus::fdo::Result<()> {
-        let mut led = None;
-        if let Ok(mut ctrl) = self.0.lock() {
-            ctrl.toggle_mode(false).map_err(|e| {
-                warn!("{}", e);
-                e
-            })?;
-
-            if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
-                led = Some(mode.clone());
-            }
-        }
-        if let Some(led) = led {
-            Self::notify_led(&ctxt, led)
-                .await
-                .unwrap_or_else(|err| warn!("{}", err));
-        }
-        Ok(())
-    }
-
-    async fn prev_led_mode(
-        &self,
-        #[zbus(signal_context)] ctxt: SignalContext<'_>,
-    ) -> zbus::fdo::Result<()> {
-        let mut led = None;
-        if let Ok(mut ctrl) = self.0.lock() {
-            ctrl.toggle_mode(true).map_err(|e| {
-                warn!("{}", e);
-                e
-            })?;
-
-            if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
-                led = Some(mode.clone());
-            }
-        }
-        if let Some(led) = led {
-            Self::notify_led(&ctxt, led)
-                .await
-                .unwrap_or_else(|err| warn!("{}", err));
-        }
-        Ok(())
-    }
-
-    async fn next_led_brightness(&self) -> zbus::fdo::Result<()> {
-        if let Ok(mut ctrl) = self.0.try_lock() {
-            ctrl.next_brightness().map_err(|e| {
-                warn!("{}", e);
-                e
-            })?;
-        }
-        Ok(())
-    }
-
-    async fn prev_led_brightness(&self) -> zbus::fdo::Result<()> {
-        if let Ok(mut ctrl) = self.0.try_lock() {
-            ctrl.prev_brightness().map_err(|e| {
-                warn!("{}", e);
-                e
-            })?;
-        }
-        Ok(())
-    }
-
-    // As property doesn't work for AuraPowerDev (complexity of serialization?)
-    // #[dbus_interface(property)]
-    async fn leds_enabled(&self) -> AuraPowerDev {
-        loop {
-            if let Ok(ctrl) = self.0.try_lock() {
-                return AuraPowerDev::from(&ctrl.config.enabled);
-            }
-        }
-    }
-
-    /// Return the current mode data
-    async fn led_mode(&self) -> AuraModeNum {
-        if let Ok(ctrl) = self.0.try_lock() {
-            return ctrl.config.current_mode;
-        }
-        AuraModeNum::Static
-    }
-
-    /// Return a list of available modes
-    async fn led_modes(&self) -> BTreeMap<AuraModeNum, AuraEffect> {
-        loop {
-            if let Ok(ctrl) = self.0.try_lock() {
-                return ctrl.config.builtins.clone();
-            }
-        }
-    }
-
-    async fn per_key_raw(&self, data: PerKeyRaw) -> zbus::fdo::Result<()> {
-        if let Ok(mut ctrl) = self.0.try_lock() {
-            ctrl.write_effect_block(&data)?;
-        }
-        Ok(())
-    }
-
-    /// Return the current LED brightness
-    #[dbus_interface(property)]
-    async fn led_brightness(&self) -> i8 {
-        if let Ok(ctrl) = self.0.try_lock() {
-            return ctrl.get_brightness().map(|n| n as i8).unwrap_or(-1);
-        }
-        warn!("SetKeyBacklight could not serialise");
-        -1
-    }
-
-    #[dbus_interface(signal)]
-    async fn notify_led(signal_ctxt: &SignalContext<'_>, data: AuraEffect) -> zbus::Result<()>;
-
-    #[dbus_interface(signal)]
-    async fn notify_power_states(
-        signal_ctxt: &SignalContext<'_>,
-        data: &AuraPowerDev,
-    ) -> zbus::Result<()>;
-}

daemon/src/ctrl_platform.rs

@@ -1,29 +1,29 @@
-use crate::CtrlTask;
 use crate::{config::Config, error::RogError, GetSupported};
+use crate::{task_watch_item, CtrlTask};
 use async_trait::async_trait;
 use log::{info, warn};
 use rog_platform::platform::{AsusPlatform, GpuMode};
 use rog_platform::supported::RogBiosSupportedFunctions;
-use smol::Executor;
 use std::fs::OpenOptions;
 use std::io::{Read, Write};
 use std::path::Path;
 use std::process::Command;
 use std::sync::Arc;
-use std::sync::Mutex;
+use zbus::export::futures_util::lock::Mutex;
 use zbus::Connection;
 use zbus::{dbus_interface, SignalContext};
 
-static ASUS_POST_LOGO_SOUND: &str =
+const ZBUS_PATH: &str = "/org/asuslinux/Platform";
+const ASUS_POST_LOGO_SOUND: &str =
     "/sys/firmware/efi/efivars/AsusPostLogoSound-607005d5-3f75-4b2e-98f0-85ba66797a3e";
 
 #[derive(Clone)]
-pub struct CtrlRogBios {
+pub struct CtrlPlatform {
     platform: AsusPlatform,
     config: Arc<Mutex<Config>>,
 }
 
-impl GetSupported for CtrlRogBios {
+impl GetSupported for CtrlPlatform {
     type A = RogBiosSupportedFunctions;
 
     fn get_supported() -> Self::A {
@@ -49,7 +49,7 @@ impl GetSupported for CtrlRogBios {
     }
 }
 
-impl CtrlRogBios {
+impl CtrlPlatform {
     pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
         let platform = AsusPlatform::new()?;
 
@@ -59,12 +59,12 @@ impl CtrlRogBios {
         }
 
         if Path::new(ASUS_POST_LOGO_SOUND).exists() {
-            CtrlRogBios::set_path_mutable(ASUS_POST_LOGO_SOUND)?;
+            CtrlPlatform::set_path_mutable(ASUS_POST_LOGO_SOUND)?;
         } else {
             info!("Switch for POST boot sound not detected");
         }
 
-        Ok(CtrlRogBios { platform, config })
+        Ok(CtrlPlatform { platform, config })
     }
 
     fn set_path_mutable(path: &str) -> Result<(), RogError> {
@@ -78,7 +78,7 @@ impl CtrlRogBios {
     }
 
     fn set_gfx_mode(&self, mode: GpuMode) -> Result<(), RogError> {
-        self.platform.set_gpu_mux_mode(mode.to_mux())?;
+        self.platform.set_gpu_mux_mode(mode.to_mux_attr())?;
         // self.update_initramfs(enable)?;
         if mode == GpuMode::Discrete {
             info!("Set system-level graphics mode: Dedicated Nvidia");
@@ -129,7 +129,7 @@ impl CtrlRogBios {
         Ok(())
     }
 
-    fn set_panel_od(&self, enable: bool) -> Result<(), RogError> {
+    fn set_panel_overdrive(&self, enable: bool) -> Result<(), RogError> {
         self.platform.set_panel_od(enable).map_err(|err| {
             warn!("CtrlRogBios: set_panel_overdrive {}", err);
             err
@@ -139,7 +139,7 @@ impl CtrlRogBios {
 }
 
 #[dbus_interface(name = "org.asuslinux.Daemon")]
-impl CtrlRogBios {
+impl CtrlPlatform {
     async fn set_gpu_mux_mode(
         &mut self,
         #[zbus(signal_context)] ctxt: SignalContext<'_>,
@@ -147,7 +147,7 @@ impl CtrlRogBios {
     ) {
         self.set_gfx_mode(mode)
             .map_err(|err| {
-                warn!("CtrlRogBios: set_asus_switch_graphic_mode {}", err);
+                warn!("CtrlRogBios: set_gpu_mux_mode {}", err);
                 err
             })
             .ok();
@@ -156,7 +156,7 @@ impl CtrlRogBios {
 
     fn gpu_mux_mode(&self) -> GpuMode {
         match self.platform.get_gpu_mux_mode() {
-            Ok(m) => GpuMode::from_mux(m),
+            Ok(m) => GpuMode::from_mux(m as u8),
             Err(e) => {
                 warn!("CtrlRogBios: get_gfx_mode {}", e);
                 GpuMode::Error
@@ -197,80 +197,148 @@ impl CtrlRogBios {
     #[dbus_interface(signal)]
     async fn notify_post_boot_sound(ctxt: &SignalContext<'_>, on: bool) -> zbus::Result<()> {}
 
-    async fn set_panel_overdrive(
+    async fn set_panel_od(
         &mut self,
         #[zbus(signal_context)] ctxt: SignalContext<'_>,
         overdrive: bool,
     ) {
-        if self
-            .set_panel_od(overdrive)
-            .map_err(|err| {
-                warn!("CtrlRogBios: set_panel_overdrive {}", err);
-                err
-            })
-            .is_ok()
-        {
-            if let Ok(mut lock) = self.config.try_lock() {
-                lock.panel_od = overdrive;
-                lock.write();
+        match self.platform.set_panel_od(overdrive) {
+            Ok(_) => {
+                if let Some(mut lock) = self.config.try_lock() {
+                    lock.panel_od = overdrive;
+                    lock.write();
+                }
+                Self::notify_panel_od(&ctxt, overdrive).await.ok();
             }
-            Self::notify_panel_overdrive(&ctxt, overdrive).await.ok();
-        }
+            Err(err) => warn!("CtrlRogBios: set_panel_overdrive {}", err),
+        };
     }
 
-    fn panel_overdrive(&self) -> bool {
-        self.platform
+    /// Get the `panel_od` value from platform. Updates the stored value in internal config also.
+    fn panel_od(&self) -> bool {
+        let od = self
+            .platform
             .get_panel_od()
             .map_err(|err| {
-                warn!("CtrlRogBios: get panel overdrive {}", err);
+                warn!("CtrlRogBios: get_panel_od {}", err);
+                err
+            })
+            .unwrap_or(false);
+        if let Some(mut lock) = self.config.try_lock() {
+            lock.panel_od = od;
+            lock.write();
+        }
+        od
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_panel_od(signal_ctxt: &SignalContext<'_>, overdrive: bool) -> zbus::Result<()> {
+    }
+
+    async fn set_dgpu_disable(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        disable: bool,
+    ) {
+        match self.platform.set_dgpu_disable(disable) {
+            Ok(_) => {
+                Self::notify_dgpu_disable(&ctxt, disable).await.ok();
+            }
+            Err(err) => warn!("CtrlRogBios: set_dgpu_disable {}", err),
+        };
+    }
+
+    fn dgpu_disable(&self) -> bool {
+        self.platform
+            .get_dgpu_disable()
+            .map_err(|err| {
+                warn!("CtrlRogBios: get_dgpu_disable {}", err);
                 err
             })
             .unwrap_or(false)
     }
 
     #[dbus_interface(signal)]
-    async fn notify_panel_overdrive(
+    async fn notify_dgpu_disable(
         signal_ctxt: &SignalContext<'_>,
-        overdrive: bool,
+        disable: bool,
     ) -> zbus::Result<()> {
     }
+
+    async fn set_egpu_enable(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        enable: bool,
+    ) {
+        match self.platform.set_egpu_enable(enable) {
+            Ok(_) => {
+                Self::notify_egpu_enable(&ctxt, enable).await.ok();
+            }
+            Err(err) => warn!("CtrlRogBios: set_egpu_enable {}", err),
+        };
+    }
+
+    fn egpu_enable(&self) -> bool {
+        self.platform
+            .get_egpu_enable()
+            .map_err(|err| {
+                warn!("CtrlRogBios: get_egpu_enable {}", err);
+                err
+            })
+            .unwrap_or(false)
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_egpu_enable(signal_ctxt: &SignalContext<'_>, enable: bool) -> zbus::Result<()> {
+    }
 }
 
 #[async_trait]
-impl crate::ZbusAdd for CtrlRogBios {
+impl crate::ZbusRun for CtrlPlatform {
     async fn add_to_server(self, server: &mut Connection) {
         Self::add_to_server_helper(self, "/org/asuslinux/Platform", server).await;
     }
 }
 
-impl crate::Reloadable for CtrlRogBios {
-    fn reload(&mut self) -> Result<(), RogError> {
+#[async_trait]
+impl crate::Reloadable for CtrlPlatform {
+    async fn reload(&mut self) -> Result<(), RogError> {
         if self.platform.has_panel_od() {
-            let p = if let Ok(lock) = self.config.try_lock() {
+            let p = if let Some(lock) = self.config.try_lock() {
                 lock.panel_od
             } else {
                 false
             };
-            self.set_panel_od(p)?;
+            self.set_panel_overdrive(p)?;
         }
         Ok(())
     }
 }
 
+impl CtrlPlatform {
+    task_watch_item!(panel_od platform);
+    task_watch_item!(dgpu_disable platform);
+    task_watch_item!(egpu_enable platform);
+    task_watch_item!(gpu_mux_mode platform);
+}
+
 #[async_trait]
-impl CtrlTask for CtrlRogBios {
-    async fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
+impl CtrlTask for CtrlPlatform {
+    fn zbus_path() -> &'static str {
+        ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
         let platform1 = self.clone();
         let platform2 = self.clone();
         self.create_sys_event_tasks(
-            executor,
             move || {},
             move || {
                 info!("CtrlRogBios reloading panel_od");
-                if let Ok(lock) = platform1.config.try_lock() {
+                if let Some(lock) = platform1.config.try_lock() {
                     if platform1.platform.has_panel_od() {
                         platform1
-                            .set_panel_od(lock.panel_od)
+                            .set_panel_overdrive(lock.panel_od)
                             .map_err(|err| {
                                 warn!("CtrlCharge: set_limit {}", err);
                                 err
@@ -282,10 +350,10 @@ impl CtrlTask for CtrlRogBios {
             move || {},
             move || {
                 info!("CtrlRogBios reloading panel_od");
-                if let Ok(lock) = platform2.config.try_lock() {
+                if let Some(lock) = platform2.config.try_lock() {
                     if platform2.platform.has_panel_od() {
                         platform2
-                            .set_panel_od(lock.panel_od)
+                            .set_panel_overdrive(lock.panel_od)
                             .map_err(|err| {
                                 warn!("CtrlCharge: set_limit {}", err);
                                 err
@@ -297,6 +365,11 @@ impl CtrlTask for CtrlRogBios {
         )
         .await;
 
+        self.watch_panel_od(signal_ctxt.clone()).await?;
+        self.watch_dgpu_disable(signal_ctxt.clone()).await?;
+        self.watch_egpu_enable(signal_ctxt.clone()).await?;
+        self.watch_gpu_mux_mode(signal_ctxt.clone()).await?;
+
         Ok(())
     }
 }

daemon/src/ctrl_power.rs

@@ -1,16 +1,21 @@
-use crate::CtrlTask;
+use crate::systemd::{do_systemd_unit_action, SystemdUnitAction};
 use crate::{config::Config, error::RogError, GetSupported};
+use crate::{task_watch_item, CtrlTask};
 use async_trait::async_trait;
 use log::{info, warn};
 use rog_platform::power::AsusPower;
 use rog_platform::supported::ChargeSupportedFunctions;
-use smol::Executor;
 use std::sync::Arc;
-use std::sync::Mutex;
+use std::time::Duration;
+use tokio::time::sleep;
 use zbus::dbus_interface;
+use zbus::export::futures_util::lock::Mutex;
 use zbus::Connection;
 use zbus::SignalContext;
 
+const ZBUS_PATH: &str = "/org/asuslinux/Power";
+const NVIDIA_POWERD: &str = "nvidia-powerd.service";
+
 impl GetSupported for CtrlPower {
     type A = ChargeSupportedFunctions;
 
@@ -33,7 +38,7 @@ pub struct CtrlPower {
 
 #[dbus_interface(name = "org.asuslinux.Daemon")]
 impl CtrlPower {
-    async fn set_limit(
+    async fn set_charge_control_end_threshold(
         &mut self,
         #[zbus(signal_context)] ctxt: SignalContext<'_>,
         limit: u8,
@@ -47,31 +52,63 @@ impl CtrlPower {
                 err
             })
             .ok();
-        Self::notify_charge(&ctxt, limit).await?;
+        Self::notify_charge_control_end_threshold(&ctxt, limit)
+            .await
+            .ok();
         Ok(())
     }
 
-    fn limit(&self) -> i8 {
-        if let Ok(config) = self.config.try_lock() {
-            return config.bat_charge_limit as i8;
+    fn charge_control_end_threshold(&self) -> u8 {
+        loop {
+            if let Some(mut config) = self.config.try_lock() {
+                let limit = self
+                    .power
+                    .get_charge_control_end_threshold()
+                    .map_err(|err| {
+                        warn!("CtrlCharge: get_charge_control_end_threshold {}", err);
+                        err
+                    })
+                    .unwrap_or(100);
+
+                config.read();
+                config.bat_charge_limit = limit;
+                config.write();
+
+                return config.bat_charge_limit;
+            }
         }
-        -1
+    }
+
+    fn mains_online(&self) -> bool {
+        if self.power.has_online() {
+            if let Ok(v) = self.power.get_online() {
+                return v == 1;
+            }
+        }
+        false
     }
 
     #[dbus_interface(signal)]
-    async fn notify_charge(ctxt: &SignalContext<'_>, limit: u8) -> zbus::Result<()>;
+    async fn notify_charge_control_end_threshold(
+        ctxt: &SignalContext<'_>,
+        limit: u8,
+    ) -> zbus::Result<()>;
+
+    #[dbus_interface(signal)]
+    async fn notify_mains_online(ctxt: &SignalContext<'_>, on: bool) -> zbus::Result<()>;
 }
 
 #[async_trait]
-impl crate::ZbusAdd for CtrlPower {
+impl crate::ZbusRun for CtrlPower {
     async fn add_to_server(self, server: &mut Connection) {
-        Self::add_to_server_helper(self, "/org/asuslinux/Charge", server).await;
+        Self::add_to_server_helper(self, ZBUS_PATH, server).await;
     }
 }
 
+#[async_trait]
 impl crate::Reloadable for CtrlPower {
-    fn reload(&mut self) -> Result<(), RogError> {
-        if let Ok(mut config) = self.config.try_lock() {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        if let Some(mut config) = self.config.try_lock() {
             config.read();
             self.set(config.bat_charge_limit)?;
         }
@@ -96,7 +133,7 @@ impl CtrlPower {
 
         info!("Battery charge limit: {}", limit);
 
-        if let Ok(mut config) = self.config.try_lock() {
+        if let Some(mut config) = self.config.try_lock() {
             config.read();
             config.bat_charge_limit = limit;
             config.write();
@@ -104,19 +141,24 @@ impl CtrlPower {
 
         Ok(())
     }
+
+    task_watch_item!(charge_control_end_threshold power);
 }
 
 #[async_trait]
 impl CtrlTask for CtrlPower {
-    async fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
+    fn zbus_path() -> &'static str {
+        ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
         let power1 = self.clone();
         let power2 = self.clone();
         self.create_sys_event_tasks(
-            executor,
             move || {},
             move || {
                 info!("CtrlCharge reloading charge limit");
-                if let Ok(lock) = power1.config.try_lock() {
+                if let Some(lock) = power1.config.try_lock() {
                     power1
                         .set(lock.bat_charge_limit)
                         .map_err(|err| {
@@ -125,11 +167,21 @@ impl CtrlTask for CtrlPower {
                         })
                         .ok();
                 }
+                if let Ok(value) = power1.power.get_online() {
+                    let action = if value == 1 {
+                        SystemdUnitAction::Restart
+                    } else {
+                        SystemdUnitAction::Stop
+                    };
+                    if do_systemd_unit_action(action, NVIDIA_POWERD).is_ok() {
+                        info!("CtrlPower task: did {action:?} on {NVIDIA_POWERD}");
+                    }
+                }
             },
             move || {},
             move || {
                 info!("CtrlCharge reloading charge limit");
-                if let Ok(lock) = power2.config.try_lock() {
+                if let Some(lock) = power2.config.try_lock() {
                     power2
                         .set(lock.bat_charge_limit)
                         .map_err(|err| {
@@ -138,10 +190,50 @@ impl CtrlTask for CtrlPower {
                         })
                         .ok();
                 }
+                if let Ok(value) = power2.power.get_online() {
+                    let action = if value == 1 {
+                        SystemdUnitAction::Restart
+                    } else {
+                        SystemdUnitAction::Stop
+                    };
+                    if do_systemd_unit_action(action, NVIDIA_POWERD).is_ok() {
+                        info!("CtrlPower task: did {action:?} on {NVIDIA_POWERD}");
+                    }
+                }
             },
         )
         .await;
 
+        self.watch_charge_control_end_threshold(signal_ctxt.clone())
+            .await?;
+
+        let ctrl = self.clone();
+        tokio::spawn(async move {
+            let mut online = 10;
+            loop {
+                if let Ok(value) = ctrl.power.get_online() {
+                    if online != value {
+                        online = value;
+                        let action = if value == 1 {
+                            SystemdUnitAction::Restart
+                        } else {
+                            SystemdUnitAction::Stop
+                        };
+                        if do_systemd_unit_action(action, NVIDIA_POWERD).is_ok() {
+                            info!("CtrlPower task: did {action:?} on {NVIDIA_POWERD}");
+                        }
+
+                        Self::notify_mains_online(&signal_ctxt, value == 1)
+                            .await
+                            .unwrap();
+                    }
+                }
+                // The inotify doesn't pick up events when the kernel changes internal value
+                // so we need to watch it with a thread and sleep unfortunately
+                sleep(Duration::from_secs(1)).await;
+            }
+        });
+
         Ok(())
     }
 }

daemon/src/ctrl_profiles/controller.rs

@@ -1,17 +1,16 @@
 use crate::error::RogError;
-use crate::{CtrlTask, GetSupported};
-use async_trait::async_trait;
+use crate::GetSupported;
 use log::{info, warn};
+use rog_platform::platform::AsusPlatform;
 use rog_platform::supported::PlatformProfileFunctions;
 use rog_profiles::error::ProfileError;
 use rog_profiles::{FanCurveProfiles, Profile};
-use smol::Executor;
-use std::sync::{Arc, Mutex};
 
 use super::config::ProfileConfig;
 
 pub struct CtrlPlatformProfile {
     pub config: ProfileConfig,
+    pub platform: AsusPlatform,
 }
 
 impl GetSupported for CtrlPlatformProfile {
@@ -39,27 +38,13 @@ impl GetSupported for CtrlPlatformProfile {
     }
 }
 
-impl crate::Reloadable for CtrlPlatformProfile {
-    /// Fetch the active profile and use that to set all related components up
-    fn reload(&mut self) -> Result<(), RogError> {
-        if let Some(curves) = &mut self.config.fan_curves {
-            if let Ok(mut device) = FanCurveProfiles::get_device() {
-                // There is a possibility that the curve was default zeroed, so this call initialises
-                // the data from system read and we need to save it after
-                curves.write_profile_curve_to_platform(self.config.active_profile, &mut device)?;
-                self.config.write();
-            }
-        }
-        Ok(())
-    }
-}
-
 impl CtrlPlatformProfile {
     pub fn new(config: ProfileConfig) -> Result<Self, RogError> {
-        if Profile::is_platform_profile_supported() {
+        let platform = AsusPlatform::new()?;
+        if platform.has_platform_profile() || platform.has_throttle_thermal_policy() {
             info!("Device has profile control available");
 
-            let mut controller = CtrlPlatformProfile { config };
+            let mut controller = CtrlPlatformProfile { config, platform };
             if FanCurveProfiles::get_device().is_ok() {
                 info!("Device has fan curves available");
                 if controller.config.fan_curves.is_none() {
@@ -129,32 +114,3 @@ impl CtrlPlatformProfile {
         Ok(())
     }
 }
-
-pub struct CtrlProfileTask {
-    ctrl: Arc<Mutex<CtrlPlatformProfile>>,
-}
-
-impl CtrlProfileTask {
-    pub fn new(ctrl: Arc<Mutex<CtrlPlatformProfile>>) -> Self {
-        Self { ctrl }
-    }
-}
-
-#[async_trait]
-impl CtrlTask for CtrlProfileTask {
-    async fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
-        let ctrl = self.ctrl.clone();
-        self.repeating_task(666, executor, move || {
-            if let Ok(ref mut lock) = ctrl.try_lock() {
-                let new_profile = Profile::get_active_profile().unwrap();
-                if new_profile != lock.config.active_profile {
-                    lock.config.active_profile = new_profile;
-                    lock.write_profile_curve_to_platform().unwrap();
-                    lock.save_config();
-                }
-            }
-        })
-        .await;
-        Ok(())
-    }
-}

daemon/src/ctrl_profiles/mod.rs

@@ -1,3 +1,4 @@
 pub mod config;
 pub mod controller;
-pub mod zbus;
+/// Implements CtrlTask, Reloadable, ZbusRun
+pub mod trait_impls;

daemon/src/ctrl_profiles/trait_impls.rs

@@ -0,0 +1,246 @@
+use async_trait::async_trait;
+use log::warn;
+use rog_profiles::fan_curve_set::CurveData;
+use rog_profiles::fan_curve_set::FanCurveSet;
+use rog_profiles::FanCurveProfiles;
+use rog_profiles::Profile;
+use zbus::export::futures_util::lock::Mutex;
+use zbus::export::futures_util::StreamExt;
+use zbus::Connection;
+use zbus::SignalContext;
+
+use std::sync::Arc;
+use zbus::{dbus_interface, fdo::Error};
+
+use crate::error::RogError;
+use crate::CtrlTask;
+
+use super::controller::CtrlPlatformProfile;
+
+const ZBUS_PATH: &str = "/org/asuslinux/Profile";
+const UNSUPPORTED_MSG: &str =
+    "Fan curves are not supported on this laptop or you require a patched kernel";
+
+#[derive(Clone)]
+pub struct ProfileZbus(pub Arc<Mutex<CtrlPlatformProfile>>);
+
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl ProfileZbus {
+    /// Fetch profile names
+    fn profiles(&mut self) -> zbus::fdo::Result<Vec<Profile>> {
+        if let Ok(profiles) = Profile::get_profile_names() {
+            return Ok(profiles);
+        }
+        Err(Error::Failed(
+            "Failed to get all profile details".to_string(),
+        ))
+    }
+
+    /// Toggle to next platform_profile. Names provided by `Profiles`.
+    /// If fan-curves are supported will also activate a fan curve for profile.
+    async fn next_profile(&mut self, #[zbus(signal_context)] ctxt: SignalContext<'_>) {
+        let mut ctrl = self.0.lock().await;
+        ctrl.set_next_profile()
+            .unwrap_or_else(|err| warn!("{}", err));
+        ctrl.save_config();
+
+        Self::notify_profile(&ctxt, ctrl.config.active_profile)
+            .await
+            .ok();
+    }
+
+    /// Fetch the active profile name
+    async fn active_profile(&mut self) -> zbus::fdo::Result<Profile> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.config.read();
+        Ok(ctrl.config.active_profile)
+    }
+
+    /// Set this platform_profile name as active
+    async fn set_active_profile(
+        &self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        profile: Profile,
+    ) {
+        let mut ctrl = self.0.lock().await;
+        // Read first just incase the user has modified the config before calling this
+        ctrl.config.read();
+        Profile::set_profile(profile)
+            .map_err(|e| warn!("set_profile, {}", e))
+            .ok();
+        ctrl.config.active_profile = profile;
+        ctrl.write_profile_curve_to_platform()
+            .map_err(|e| warn!("write_profile_curve_to_platform, {}", e))
+            .ok();
+
+        ctrl.save_config();
+
+        Self::notify_profile(&ctxt, ctrl.config.active_profile)
+            .await
+            .ok();
+    }
+
+    /// Get a list of profiles that have fan-curves enabled.
+    async fn enabled_fan_profiles(&mut self) -> zbus::fdo::Result<Vec<Profile>> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.config.read();
+        if let Some(curves) = &ctrl.config.fan_curves {
+            return Ok(curves.get_enabled_curve_profiles().to_vec());
+        }
+        Err(Error::Failed(UNSUPPORTED_MSG.to_string()))
+    }
+
+    /// Set a profile fan curve enabled status. Will also activate a fan curve if in the
+    /// same profile mode
+    async fn set_fan_curve_enabled(
+        &mut self,
+        profile: Profile,
+        enabled: bool,
+    ) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.config.read();
+        if let Some(curves) = &mut ctrl.config.fan_curves {
+            curves.set_profile_curve_enabled(profile, enabled);
+
+            ctrl.write_profile_curve_to_platform()
+                .map_err(|e| warn!("write_profile_curve_to_platform, {}", e))
+                .ok();
+
+            ctrl.save_config();
+            Ok(())
+        } else {
+            Err(Error::Failed(UNSUPPORTED_MSG.to_string()))
+        }
+    }
+
+    /// Get the fan-curve data for the currently active Profile
+    async fn fan_curve_data(&mut self, profile: Profile) -> zbus::fdo::Result<FanCurveSet> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.config.read();
+        if let Some(curves) = &ctrl.config.fan_curves {
+            let curve = curves.get_fan_curves_for(profile);
+            return Ok(curve.clone());
+        }
+        Err(Error::Failed(UNSUPPORTED_MSG.to_string()))
+    }
+
+    /// Set the fan curve for the specified profile.
+    /// Will also activate the fan curve if the user is in the same mode.
+    async fn set_fan_curve(&self, profile: Profile, curve: CurveData) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.config.read();
+        if let Some(curves) = &mut ctrl.config.fan_curves {
+            curves
+                .save_fan_curve(curve, profile)
+                .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
+        } else {
+            return Err(Error::Failed(UNSUPPORTED_MSG.to_string()));
+        }
+        ctrl.write_profile_curve_to_platform()
+            .map_err(|e| warn!("Profile::set_profile, {}", e))
+            .ok();
+        ctrl.save_config();
+
+        Ok(())
+    }
+
+    /// Reset the stored (self) and device curve to the defaults of the platform.
+    ///
+    /// Each platform_profile has a different default and the defualt can be read
+    /// only for the currently active profile.
+    async fn set_active_curve_to_defaults(&self) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.config.read();
+        ctrl.set_active_curve_to_defaults()
+            .map_err(|e| warn!("Profile::set_active_curve_to_defaults, {}", e))
+            .ok();
+        ctrl.save_config();
+        Ok(())
+    }
+
+    /// Reset the stored (self) and device curve to the defaults of the platform.
+    ///
+    /// Each platform_profile has a different default and the defualt can be read
+    /// only for the currently active profile.
+    async fn reset_profile_curves(&self, profile: Profile) -> zbus::fdo::Result<()> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.config.read();
+        let active = Profile::get_active_profile().unwrap_or(Profile::Balanced);
+
+        Profile::set_profile(profile)
+            .map_err(|e| warn!("set_profile, {}", e))
+            .ok();
+        ctrl.set_active_curve_to_defaults()
+            .map_err(|e| warn!("Profile::set_active_curve_to_defaults, {}", e))
+            .ok();
+
+        Profile::set_profile(active)
+            .map_err(|e| warn!("set_profile, {}", e))
+            .ok();
+        ctrl.save_config();
+        Ok(())
+    }
+
+    #[dbus_interface(signal)]
+    async fn notify_profile(signal_ctxt: &SignalContext<'_>, profile: Profile) -> zbus::Result<()> {
+    }
+}
+
+#[async_trait]
+impl crate::ZbusRun for ProfileZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, ZBUS_PATH, server).await;
+    }
+}
+
+#[async_trait]
+impl CtrlTask for ProfileZbus {
+    fn zbus_path() -> &'static str {
+        ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
+        let ctrl = self.0.clone();
+        let mut watch = self.0.lock().await.platform.monitor_platform_profile()?;
+
+        tokio::spawn(async move {
+            let mut buffer = [0; 32];
+            watch
+                .event_stream(&mut buffer)
+                .unwrap()
+                .for_each(|_| async {
+                    let mut lock = ctrl.lock().await;
+                    let new_profile = Profile::get_active_profile().unwrap();
+                    if new_profile != lock.config.active_profile {
+                        lock.config.active_profile = new_profile;
+                        lock.write_profile_curve_to_platform().unwrap();
+                        lock.save_config();
+                    }
+                    Self::notify_profile(&signal_ctxt.clone(), lock.config.active_profile)
+                        .await
+                        .ok();
+                })
+                .await;
+        });
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl crate::Reloadable for ProfileZbus {
+    /// Fetch the active profile and use that to set all related components up
+    async fn reload(&mut self) -> Result<(), RogError> {
+        let mut ctrl = self.0.lock().await;
+        let active = ctrl.config.active_profile;
+        if let Some(curves) = &mut ctrl.config.fan_curves {
+            if let Ok(mut device) = FanCurveProfiles::get_device() {
+                // There is a possibility that the curve was default zeroed, so this call initialises
+                // the data from system read and we need to save it after
+                curves.write_profile_curve_to_platform(active, &mut device)?;
+                ctrl.config.write();
+            }
+        }
+        Ok(())
+    }
+}

daemon/src/ctrl_profiles/zbus.rs

@@ -1,211 +0,0 @@
-use async_trait::async_trait;
-use log::warn;
-use rog_profiles::fan_curve_set::CurveData;
-use rog_profiles::fan_curve_set::FanCurveSet;
-use rog_profiles::Profile;
-use zbus::Connection;
-use zbus::SignalContext;
-
-use std::sync::Arc;
-use std::sync::Mutex;
-use zbus::{dbus_interface, fdo::Error};
-
-use super::controller::CtrlPlatformProfile;
-
-static UNSUPPORTED_MSG: &str =
-    "Fan curves are not supported on this laptop or you require a patched kernel";
-
-pub struct ProfileZbus {
-    inner: Arc<Mutex<CtrlPlatformProfile>>,
-}
-
-impl ProfileZbus {
-    pub fn new(inner: Arc<Mutex<CtrlPlatformProfile>>) -> Self {
-        Self { inner }
-    }
-}
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl ProfileZbus {
-    /// Fetch profile names
-    fn profiles(&mut self) -> zbus::fdo::Result<Vec<Profile>> {
-        if let Ok(profiles) = Profile::get_profile_names() {
-            return Ok(profiles);
-        }
-        Err(Error::Failed(
-            "Failed to get all profile details".to_string(),
-        ))
-    }
-
-    /// Toggle to next platform_profile. Names provided by `Profiles`.
-    /// If fan-curves are supported will also activate a fan curve for profile.
-    async fn next_profile(&mut self, #[zbus(signal_context)] ctxt: SignalContext<'_>) {
-        let mut profile = None;
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.set_next_profile()
-                .unwrap_or_else(|err| warn!("{}", err));
-            ctrl.save_config();
-            profile = Some(ctrl.config.active_profile);
-        }
-        if let Some(profile) = profile {
-            Self::notify_profile(&ctxt, profile).await.ok();
-        }
-    }
-
-    /// Fetch the active profile name
-    fn active_profile(&mut self) -> zbus::fdo::Result<Profile> {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.config.read();
-            return Ok(ctrl.config.active_profile);
-        }
-        Err(Error::Failed(
-            "Failed to get active profile name".to_string(),
-        ))
-    }
-
-    /// Set this platform_profile name as active
-    async fn set_active_profile(
-        &self,
-        #[zbus(signal_context)] ctxt: SignalContext<'_>,
-        profile: Profile,
-    ) {
-        let mut tmp = None;
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            // Read first just incase the user has modified the config before calling this
-            ctrl.config.read();
-            Profile::set_profile(profile)
-                .map_err(|e| warn!("set_profile, {}", e))
-                .ok();
-            ctrl.config.active_profile = profile;
-            ctrl.write_profile_curve_to_platform()
-                .map_err(|e| warn!("write_profile_curve_to_platform, {}", e))
-                .ok();
-
-            ctrl.save_config();
-            tmp = Some(ctrl.config.active_profile);
-        }
-        if let Some(profile) = tmp {
-            Self::notify_profile(&ctxt, profile).await.ok();
-        }
-    }
-
-    /// Get a list of profiles that have fan-curves enabled.
-    fn enabled_fan_profiles(&mut self) -> zbus::fdo::Result<Vec<Profile>> {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.config.read();
-            if let Some(curves) = &ctrl.config.fan_curves {
-                return Ok(curves.get_enabled_curve_profiles().to_vec());
-            }
-            return Err(Error::Failed(UNSUPPORTED_MSG.to_string()));
-        }
-        Err(Error::Failed(
-            "Failed to get enabled fan curve names".to_string(),
-        ))
-    }
-
-    /// Set a profile fan curve enabled status. Will also activate a fan curve if in the
-    /// same profile mode
-    fn set_fan_curve_enabled(&mut self, profile: Profile, enabled: bool) -> zbus::fdo::Result<()> {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.config.read();
-            return if let Some(curves) = &mut ctrl.config.fan_curves {
-                curves.set_profile_curve_enabled(profile, enabled);
-
-                ctrl.write_profile_curve_to_platform()
-                    .map_err(|e| warn!("write_profile_curve_to_platform, {}", e))
-                    .ok();
-
-                ctrl.save_config();
-                Ok(())
-            } else {
-                Err(Error::Failed(UNSUPPORTED_MSG.to_string()))
-            };
-        }
-        Err(Error::Failed(
-            "Failed to get enabled fan curve names".to_string(),
-        ))
-    }
-
-    /// Get the fan-curve data for the currently active Profile
-    fn fan_curve_data(&mut self, profile: Profile) -> zbus::fdo::Result<FanCurveSet> {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.config.read();
-            if let Some(curves) = &ctrl.config.fan_curves {
-                let curve = curves.get_fan_curves_for(profile);
-                return Ok(curve.clone());
-            }
-            return Err(Error::Failed(UNSUPPORTED_MSG.to_string()));
-        }
-        Err(Error::Failed("Failed to get fan curve data".to_string()))
-    }
-
-    /// Set the fan curve for the specified profile.
-    /// Will also activate the fan curve if the user is in the same mode.
-    fn set_fan_curve(&self, profile: Profile, curve: CurveData) -> zbus::fdo::Result<()> {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.config.read();
-            if let Some(curves) = &mut ctrl.config.fan_curves {
-                curves
-                    .save_fan_curve(curve, profile)
-                    .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
-            } else {
-                return Err(Error::Failed(UNSUPPORTED_MSG.to_string()));
-            }
-            ctrl.write_profile_curve_to_platform()
-                .map_err(|e| warn!("Profile::set_profile, {}", e))
-                .ok();
-            ctrl.save_config();
-        }
-        Ok(())
-    }
-
-    /// Reset the stored (self) and device curve to the defaults of the platform.
-    ///
-    /// Each platform_profile has a different default and the defualt can be read
-    /// only for the currently active profile.
-    fn set_active_curve_to_defaults(&self) -> zbus::fdo::Result<()> {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.config.read();
-            ctrl.set_active_curve_to_defaults()
-                .map_err(|e| warn!("Profile::set_active_curve_to_defaults, {}", e))
-                .ok();
-            ctrl.save_config();
-        }
-        Ok(())
-    }
-
-    /// Reset the stored (self) and device curve to the defaults of the platform.
-    ///
-    /// Each platform_profile has a different default and the defualt can be read
-    /// only for the currently active profile.
-    fn reset_profile_curves(&self, profile: Profile) -> zbus::fdo::Result<()> {
-        if let Ok(mut ctrl) = self.inner.try_lock() {
-            ctrl.config.read();
-            let active = Profile::get_active_profile().unwrap_or(Profile::Balanced);
-
-            Profile::set_profile(profile)
-                .map_err(|e| warn!("set_profile, {}", e))
-                .ok();
-            ctrl.set_active_curve_to_defaults()
-                .map_err(|e| warn!("Profile::set_active_curve_to_defaults, {}", e))
-                .ok();
-
-            Profile::set_profile(active)
-                .map_err(|e| warn!("set_profile, {}", e))
-                .ok();
-            ctrl.save_config();
-        }
-        Ok(())
-    }
-
-    #[dbus_interface(signal)]
-    async fn notify_profile(signal_ctxt: &SignalContext<'_>, profile: Profile) -> zbus::Result<()> {
-    }
-}
-
-#[async_trait]
-impl crate::ZbusAdd for ProfileZbus {
-    async fn add_to_server(self, server: &mut Connection) {
-        Self::add_to_server_helper(self, "/org/asuslinux/Profile", server).await;
-    }
-}

daemon/src/ctrl_supported.rs

@@ -5,7 +5,7 @@ use zbus::Connection;
 use zvariant::Type;
 
 use crate::{
-    ctrl_anime::CtrlAnime, ctrl_aura::controller::CtrlKbdLed, ctrl_platform::CtrlRogBios,
+    ctrl_anime::CtrlAnime, ctrl_aura::controller::CtrlKbdLed, ctrl_platform::CtrlPlatform,
     ctrl_power::CtrlPower, ctrl_profiles::controller::CtrlPlatformProfile, GetSupported,
 };
 
@@ -28,7 +28,7 @@ impl SupportedFunctions {
 }
 
 #[async_trait]
-impl crate::ZbusAdd for SupportedFunctions {
+impl crate::ZbusRun for SupportedFunctions {
     async fn add_to_server(self, server: &mut Connection) {
         Self::add_to_server_helper(self, "/org/asuslinux/Supported", server).await;
     }
@@ -43,7 +43,7 @@ impl GetSupported for SupportedFunctions {
             keyboard_led: CtrlKbdLed::get_supported(),
             charge_ctrl: CtrlPower::get_supported(),
             platform_profile: CtrlPlatformProfile::get_supported(),
-            rog_bios_ctrl: CtrlRogBios::get_supported(),
+            rog_bios_ctrl: CtrlPlatform::get_supported(),
         }
     }
 }

daemon/src/daemon.rs

@@ -1,38 +1,36 @@
 use std::env;
 use std::error::Error;
 use std::io::Write;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
+use std::time::Duration;
 
+use ::zbus::export::futures_util::lock::Mutex;
 use ::zbus::Connection;
-use daemon::ctrl_profiles::controller::CtrlProfileTask;
+use daemon::ctrl_anime::CtrlAnime;
 use log::LevelFilter;
 use log::{error, info, warn};
-use smol::Executor;
+use tokio::time::sleep;
+use zbus::SignalContext;
 
-use daemon::ctrl_anime::config::AnimeConfig;
-use daemon::ctrl_anime::zbus::CtrlAnimeZbus;
-use daemon::ctrl_anime::*;
-use daemon::ctrl_aura::config::AuraConfig;
-use daemon::ctrl_aura::controller::{
-    CtrlKbdLed, CtrlKbdLedReloader, CtrlKbdLedTask, CtrlKbdLedZbus,
-};
-use daemon::ctrl_platform::CtrlRogBios;
+use daemon::ctrl_anime::{config::AnimeConfig, trait_impls::CtrlAnimeZbus};
+use daemon::ctrl_aura::{config::AuraConfig, controller::CtrlKbdLed, trait_impls::CtrlKbdLedZbus};
+use daemon::ctrl_platform::CtrlPlatform;
 use daemon::ctrl_power::CtrlPower;
-use daemon::ctrl_profiles::config::ProfileConfig;
+use daemon::ctrl_profiles::{
+    config::ProfileConfig, controller::CtrlPlatformProfile, trait_impls::ProfileZbus,
+};
+use daemon::laptops::LaptopLedData;
 use daemon::{
     config::Config, ctrl_supported::SupportedFunctions, laptops::print_board_info, GetSupported,
 };
-use daemon::{
-    ctrl_profiles::{controller::CtrlPlatformProfile, zbus::ProfileZbus},
-    laptops::LaptopLedData,
-};
-use daemon::{CtrlTask, Reloadable, ZbusAdd};
+use daemon::{CtrlTask, Reloadable, ZbusRun};
 use rog_dbus::DBUS_NAME;
 use rog_profiles::Profile;
 
 static PROFILE_CONFIG_PATH: &str = "/etc/asusd/profile.conf";
 
-pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut logger = env_logger::Builder::new();
     logger
         .target(env_logger::Target::Stdout)
@@ -61,14 +59,12 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
     info!(" rog-profiles v{}", rog_profiles::VERSION);
     info!("rog-platform v{}", rog_platform::VERSION);
 
-    let mut executor = Executor::new();
-
-    smol::block_on(start_daemon(&mut executor))?;
+    start_daemon().await?;
     Ok(())
 }
 
 /// The actual main loop for the daemon
-async fn start_daemon(executor: &mut Executor<'_>) -> Result<(), Box<dyn Error>> {
+async fn start_daemon() -> Result<(), Box<dyn Error>> {
     let supported = SupportedFunctions::get_supported();
     print_board_info();
     println!("{}", serde_json::to_string_pretty(&supported)?);
@@ -81,77 +77,50 @@ async fn start_daemon(executor: &mut Executor<'_>) -> Result<(), Box<dyn Error>>
 
     supported.add_to_server(&mut connection).await;
 
-    match CtrlRogBios::new(config.clone()) {
-        Ok(mut ctrl) => {
-            // Do a reload of any settings
-            ctrl.reload()
-                .unwrap_or_else(|err| warn!("CtrlRogBios: {}", err));
-            // Then register to dbus server
-            ctrl.add_to_server(&mut connection).await;
-
-            let task = CtrlRogBios::new(config.clone())?;
-            task.create_tasks(executor).await.ok();
+    match CtrlPlatform::new(config.clone()) {
+        Ok(ctrl) => {
+            let sig_ctx = CtrlPlatform::signal_context(&connection)?;
+            start_tasks(ctrl, &mut connection, sig_ctx).await?;
         }
         Err(err) => {
-            error!("rog_bios_control: {}", err);
+            error!("CtrlPlatform: {}", err);
         }
     }
 
     match CtrlPower::new(config.clone()) {
-        Ok(mut ctrl) => {
-            // Do a reload of any settings
-            ctrl.reload()
-                .unwrap_or_else(|err| warn!("CtrlPower: {}", err));
-            // Then register to dbus server
-            ctrl.add_to_server(&mut connection).await;
-
-            let task = CtrlPower::new(config)?;
-            task.create_tasks(executor).await.ok();
+        Ok(ctrl) => {
+            let sig_ctx = CtrlPower::signal_context(&connection)?;
+            start_tasks(ctrl, &mut connection, sig_ctx).await?;
         }
         Err(err) => {
-            error!("charge_control: {}", err);
+            error!("CtrlPower: {}", err);
         }
     }
 
     if Profile::is_platform_profile_supported() {
         let profile_config = ProfileConfig::load(PROFILE_CONFIG_PATH.into());
         match CtrlPlatformProfile::new(profile_config) {
-            Ok(mut ctrl) => {
-                ctrl.reload()
-                    .unwrap_or_else(|err| warn!("Profile control: {}", err));
-
-                let tmp = Arc::new(Mutex::new(ctrl));
-                let task = CtrlProfileTask::new(tmp.clone());
-                task.create_tasks(executor).await.ok();
-
-                let task = ProfileZbus::new(tmp.clone());
-                task.add_to_server(&mut connection).await;
+            Ok(ctrl) => {
+                let zbus = ProfileZbus(Arc::new(Mutex::new(ctrl)));
+                let sig_ctx = ProfileZbus::signal_context(&connection)?;
+                start_tasks(zbus, &mut connection, sig_ctx).await?;
             }
             Err(err) => {
                 error!("Profile control: {}", err);
             }
         }
     } else {
-        warn!("platform_profile support not found. This requires kernel 5.15.x or the patch applied: https://lkml.org/lkml/2021/8/18/1022");
+        warn!("platform_profile support not found");
     }
 
     match CtrlAnime::new(AnimeConfig::load()) {
         Ok(ctrl) => {
-            let inner = Arc::new(Mutex::new(ctrl));
-
-            let mut reload = CtrlAnimeReloader(inner.clone());
-            reload
-                .reload()
-                .unwrap_or_else(|err| warn!("AniMe: {}", err));
-
-            let zbus = CtrlAnimeZbus(inner.clone());
-            zbus.add_to_server(&mut connection).await;
-
-            let task = CtrlAnimeTask::new(inner).await;
-            task.create_tasks(executor).await.ok();
+            let zbus = CtrlAnimeZbus(Arc::new(Mutex::new(ctrl)));
+            let sig_ctx = CtrlAnimeZbus::signal_context(&connection)?;
+            start_tasks(zbus, &mut connection, sig_ctx).await?;
         }
         Err(err) => {
-            error!("AniMe control: {}", err);
+            info!("AniMe control: {}", err);
         }
     }
 
@@ -159,19 +128,9 @@ async fn start_daemon(executor: &mut Executor<'_>) -> Result<(), Box<dyn Error>>
     let aura_config = AuraConfig::load(&laptop);
     match CtrlKbdLed::new(laptop, aura_config) {
         Ok(ctrl) => {
-            let inner = Arc::new(Mutex::new(ctrl));
-
-            let mut reload = CtrlKbdLedReloader(inner.clone());
-            reload
-                .reload()
-                .unwrap_or_else(|err| warn!("Keyboard LED control: {}", err));
-
-            CtrlKbdLedZbus::new(inner.clone())
-                .add_to_server(&mut connection)
-                .await;
-
-            let task = CtrlKbdLedTask::new(inner);
-            task.create_tasks(executor).await.ok();
+            let zbus = CtrlKbdLedZbus(Arc::new(Mutex::new(ctrl)));
+            let sig_ctx = CtrlKbdLedZbus::signal_context(&connection)?;
+            start_tasks(zbus, &mut connection, sig_ctx).await?;
         }
         Err(err) => {
             error!("Keyboard control: {}", err);
@@ -180,7 +139,28 @@ async fn start_daemon(executor: &mut Executor<'_>) -> Result<(), Box<dyn Error>>
 
     // Request dbus name after finishing initalizing all functions
     connection.request_name(DBUS_NAME).await?;
+
     loop {
-        smol::block_on(executor.tick());
+        // This is just a blocker to idle and ensure the reator reacts
+        sleep(Duration::from_millis(1000)).await;
     }
 }
+
+async fn start_tasks<T>(
+    mut zbus: T,
+    connection: &mut Connection,
+    signal_ctx: SignalContext<'static>,
+) -> Result<(), Box<dyn Error>>
+where
+    T: ZbusRun + Reloadable + CtrlTask + Clone,
+{
+    let task = zbus.clone();
+
+    zbus.reload()
+        .await
+        .unwrap_or_else(|err| warn!("Controller error: {}", err));
+    zbus.add_to_server(connection).await;
+
+    task.create_tasks(signal_ctx).await.ok();
+    Ok(())
+}

daemon/src/error.rs

@@ -30,6 +30,9 @@ pub enum RogError {
     NoAuraNode,
     Anime(AnimeError),
     Platform(PlatformError),
+    SystemdUnitAction(String),
+    SystemdUnitWaitTimeout(String),
+    Command(String, std::io::Error),
 }
 
 impl fmt::Display for RogError {
@@ -60,6 +63,17 @@ impl fmt::Display for RogError {
             RogError::NoAuraNode => write!(f, "No Aura keyboard node found"),
             RogError::Anime(deets) => write!(f, "AniMe Matrix error: {}", deets),
             RogError::Platform(deets) => write!(f, "Asus Platform error: {}", deets),
+            RogError::SystemdUnitAction(action) => {
+                write!(f, "systemd unit action {} failed", action)
+            }
+            RogError::SystemdUnitWaitTimeout(state) => {
+                write!(
+                    f,
+                    "Timed out waiting for systemd unit change {} state",
+                    state
+                )
+            }
+            RogError::Command(func, error) => write!(f, "Command exec error: {}: {}", func, error),
         }
     }
 }

daemon/src/laptops.rs

@@ -90,7 +90,7 @@ impl LedSupportFile {
         let mut loaded = false;
         let mut data = LedSupportFile::default();
         // Load user configs first so they are first to be checked
-        if let Ok(mut file) = OpenOptions::new().read(true).open(&ASUS_LED_MODE_USER_CONF) {
+        if let Ok(mut file) = OpenOptions::new().read(true).open(ASUS_LED_MODE_USER_CONF) {
             let mut buf = String::new();
             if let Ok(l) = file.read_to_string(&mut buf) {
                 if l == 0 {
@@ -107,7 +107,7 @@ impl LedSupportFile {
             }
         }
         // Load and append the default LED support data
-        if let Ok(mut file) = OpenOptions::new().read(true).open(&ASUS_LED_MODE_CONF) {
+        if let Ok(mut file) = OpenOptions::new().read(true).open(ASUS_LED_MODE_CONF) {
             let mut buf = String::new();
             if let Ok(l) = file.read_to_string(&mut buf) {
                 if l == 0 {

daemon/src/lib.rs

@@ -14,30 +14,80 @@ pub mod ctrl_profiles;
 /// Laptop matching to determine capabilities
 pub mod laptops;
 
+pub mod systemd;
+
 /// Fetch all supported functions for the laptop
 pub mod ctrl_supported;
 
 pub mod error;
 
-use std::time::Duration;
-
 use crate::error::RogError;
 use async_trait::async_trait;
-use config::Config;
 use log::warn;
 use logind_zbus::manager::ManagerProxy;
-use smol::{stream::StreamExt, Executor, Timer};
-use zbus::Connection;
+use zbus::{export::futures_util::StreamExt, Connection, SignalContext};
 use zvariant::ObjectPath;
 
+/// This macro adds a function which spawns an `inotify` task on the passed in `Executor`.
+///
+/// The generated function is `watch_<name>()`. Self requires the following methods to be available:
+/// - `<name>() -> SomeValue`, functionally is a getter, but is allowed to have side effects.
+/// - `notify_<name>(SignalContext, SomeValue)`
+///
+/// In most cases if `SomeValue` is stored in a config then `<name>()` getter is expected to update it.
+/// The getter should *never* write back to the path or attribute that is being watched or an
+/// infinite loop will occur.
+///
+/// # Example
+///
+/// ```ignore
+/// impl CtrlRogBios {
+///     task_watch_item!(panel_od platform);
+///     task_watch_item!(gpu_mux_mode platform);
+/// }
+/// ```
+#[macro_export]
+macro_rules! task_watch_item {
+    ($name:ident $self_inner:ident) => {
+        concat_idents::concat_idents!(fn_name = watch_, $name {
+        async fn fn_name(
+            &self,
+            signal_ctxt: SignalContext<'static>,
+        ) -> Result<(), RogError> {
+            use zbus::export::futures_util::StreamExt;
+
+            let ctrl = self.clone();
+            concat_idents::concat_idents!(watch_fn = monitor_, $name {
+                match self.$self_inner.watch_fn() {
+                    Ok(mut watch) => {
+                        tokio::spawn(async move {
+                            let mut buffer = [0; 32];
+                            watch.event_stream(&mut buffer).unwrap().for_each(|_| async {
+                                let value = ctrl.$name();
+                                concat_idents::concat_idents!(notif_fn = notify_, $name {
+                                    Self::notif_fn(&signal_ctxt, value).await.ok();
+                                });
+                            }).await;
+                        });
+                    }
+                    Err(e) => info!("inotify watch failed: {}. You can ignore this if your device does not support the feature", e),
+                }
+            });
+            Ok(())
+        }
+        });
+    };
+}
+
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 
+#[async_trait]
 pub trait Reloadable {
-    fn reload(&mut self) -> Result<(), RogError>;
+    async fn reload(&mut self) -> Result<(), RogError>;
 }
 
 #[async_trait]
-pub trait ZbusAdd {
+pub trait ZbusRun {
     async fn add_to_server(self, server: &mut Connection);
 
     async fn add_to_server_helper(
@@ -60,29 +110,33 @@ pub trait ZbusAdd {
 /// Set up a task to run on the async executor
 #[async_trait]
 pub trait CtrlTask {
-    /// Implement to set up various tasks that may be required, using the `Executor`.
-    /// No blocking loops are allowed, or they must be run on a separate thread.
-    async fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError>;
+    fn zbus_path() -> &'static str;
 
-    /// Create a timed repeating task
-    async fn repeating_task(
-        &self,
-        millis: u64,
-        executor: &mut Executor,
-        mut task: impl FnMut() + Send + 'static,
-    ) {
-        let timer = Timer::interval(Duration::from_millis(millis));
-        executor
-            .spawn(async move {
-                timer.for_each(|_| task()).await;
-            })
-            .detach();
+    fn signal_context(connection: &Connection) -> Result<SignalContext<'static>, zbus::Error> {
+        SignalContext::new(connection, Self::zbus_path())
     }
 
+    /// Implement to set up various tasks that may be required, using the `Executor`.
+    /// No blocking loops are allowed, or they must be run on a separate thread.
+    async fn create_tasks(&self, signal: SignalContext<'static>) -> Result<(), RogError>;
+
+    // /// Create a timed repeating task
+    // async fn repeating_task(&self, millis: u64, mut task: impl FnMut() + Send + 'static) {
+    //     use std::time::Duration;
+    //     use tokio::time;
+    //     let mut timer = time::interval(Duration::from_millis(millis));
+    //     tokio::spawn(async move {
+    //         timer.tick().await;
+    //         task();
+    //     });
+    // }
+
     /// Free helper method to create tasks to run on: sleep, wake, shutdown, boot
+    ///
+    /// The closures can potentially block, so execution time should be the minimal possible
+    /// such as save a variable.
     async fn create_sys_event_tasks(
         &self,
-        executor: &mut Executor,
         mut on_sleep: impl FnMut() + Send + 'static,
         mut on_wake: impl FnMut() + Send + 'static,
         mut on_shutdown: impl FnMut() + Send + 'static,
@@ -96,54 +150,40 @@ pub trait CtrlTask {
             .await
             .expect("Controller could not create ManagerProxy");
 
-        executor
-            .spawn(async move {
-                if let Ok(notif) = manager.receive_prepare_for_sleep().await {
-                    notif
-                        .for_each(|event| {
-                            if let Ok(args) = event.args() {
-                                if args.start {
-                                    on_sleep();
-                                } else if !args.start() {
-                                    on_wake();
-                                }
-                            }
-                        })
-                        .await;
+        tokio::spawn(async move {
+            if let Ok(mut notif) = manager.receive_prepare_for_sleep().await {
+                while let Some(event) = notif.next().await {
+                    if let Ok(args) = event.args() {
+                        if args.start {
+                            on_sleep();
+                        } else if !args.start() {
+                            on_wake();
+                        }
+                    }
                 }
-            })
-            .detach();
+            }
+        });
 
         let manager = ManagerProxy::new(&connection)
             .await
             .expect("Controller could not create ManagerProxy");
 
-        executor
-            .spawn(async move {
-                if let Ok(notif) = manager.receive_prepare_for_shutdown().await {
-                    notif
-                        .for_each(|event| {
-                            if let Ok(args) = event.args() {
-                                if args.start {
-                                    on_shutdown();
-                                } else if !args.start() {
-                                    on_boot();
-                                }
-                            }
-                        })
-                        .await;
+        tokio::spawn(async move {
+            if let Ok(mut notif) = manager.receive_prepare_for_shutdown().await {
+                while let Some(event) = notif.next().await {
+                    if let Ok(args) = event.args() {
+                        if args.start {
+                            on_shutdown();
+                        } else if !args.start() {
+                            on_boot();
+                        }
+                    }
                 }
-            })
-            .detach();
+            }
+        });
     }
 }
 
-pub trait CtrlTaskComplex {
-    type A;
-
-    fn do_task(&mut self, config: &mut Config, event: Self::A);
-}
-
 pub trait GetSupported {
     type A;
 

daemon/src/systemd.rs

@@ -0,0 +1,90 @@
+use std::process::Command;
+
+use crate::error::RogError;
+
+/// An action for `systemctl`
+#[derive(Debug, Copy, Clone)]
+pub enum SystemdUnitAction {
+    Stop,
+    Start,
+    Restart,
+}
+
+impl From<SystemdUnitAction> for &str {
+    fn from(s: SystemdUnitAction) -> Self {
+        match s {
+            SystemdUnitAction::Stop => "stop",
+            SystemdUnitAction::Start => "start",
+            SystemdUnitAction::Restart => "restart",
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+pub enum SystemdUnitState {
+    Active,
+    Inactive,
+}
+
+impl From<SystemdUnitState> for &str {
+    fn from(s: SystemdUnitState) -> Self {
+        match s {
+            SystemdUnitState::Active => "active",
+            SystemdUnitState::Inactive => "inactive",
+        }
+    }
+}
+
+/// Change the state of a systemd unit. Blocks while running command.
+pub fn do_systemd_unit_action(action: SystemdUnitAction, unit: &str) -> Result<(), RogError> {
+    let mut cmd = Command::new("systemctl");
+    cmd.arg(<&str>::from(action));
+    cmd.arg(unit);
+
+    let status = cmd
+        .status()
+        .map_err(|err| RogError::Command(format!("{:?}", cmd), err))?;
+    if !status.success() {
+        let msg = format!("systemctl {action:?} {unit} failed: {status:?}",);
+        return Err(RogError::SystemdUnitAction(msg));
+    }
+    Ok(())
+}
+
+/// Get systemd unit state. Blocks while command is run.
+pub fn is_systemd_unit_state(state: SystemdUnitState, unit: &str) -> Result<bool, RogError> {
+    let mut cmd = Command::new("systemctl");
+    cmd.arg("is-active");
+    cmd.arg(unit);
+
+    let output = cmd
+        .output()
+        .map_err(|err| RogError::Command(format!("{:?}", cmd), err))?;
+    if output.stdout.starts_with(<&str>::from(state).as_bytes()) {
+        return Ok(true);
+    }
+    Ok(false)
+}
+
+/// Wait for a systemd unit to change to `state`. Checks state every 250ms for 3 seconds. Blocks while running wait.
+pub fn wait_systemd_unit_state(state: SystemdUnitState, unit: &str) -> Result<(), RogError> {
+    let mut cmd = Command::new("systemctl");
+    cmd.arg("is-active");
+    cmd.arg(unit);
+
+    let mut count = 0;
+
+    while count <= (4 * 3) {
+        // 3 seconds max
+        let output = cmd
+            .output()
+            .map_err(|err| RogError::Command(format!("{:?}", cmd), err))?;
+        if output.stdout.starts_with(<&str>::from(state).as_bytes()) {
+            return Ok(());
+        }
+        // fine to block here, nobody doing shit now
+        std::thread::sleep(std::time::Duration::from_millis(250));
+        count += 1;
+    }
+    Err(RogError::SystemdUnitWaitTimeout(<&str>::from(state).into()))
+}

data/asus-notify.service

@@ -1,14 +0,0 @@
-[Unit]
-Description=ASUS Notifications
-StartLimitInterval=200
-StartLimitBurst=2
-
-[Service]
-ExecStartPre=/usr/bin/sleep 2
-ExecStart=/usr/bin/asus-notify
-Restart=on-failure
-RestartSec=1
-Type=simple
-
-[Install]
-WantedBy=default.target

data/asusd-ledmodes.toml

@@ -12,6 +12,13 @@ standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
 multizone = []
 per_key = false
 
+[[led_data]]
+prod_family = "ASUS TUF Gaming A15"
+board_names = ["FA506I"]
+standard = ["Static", "Breathe", "Strobe", "Pulse"]
+multizone = []
+per_key = false
+
 [[led_data]]
 prod_family = "Zephyrus S"
 board_names = ["GX502", "GX701", "G531", "GL531", "G532"]
@@ -21,21 +28,7 @@ per_key = true
 
 [[led_data]]
 prod_family = "Zephyrus M"
-board_names = ["GU502GV"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = []
-per_key = true
-
-[[led_data]]
-prod_family = "Zephyrus M"
-board_names = ["GM501GS"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = ["Key1", "Key2", "Key3", "Key4"]
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Zephyrus M15"
-board_names = ["GU502LW", "GU502LV"]
+board_names = ["GU502G"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
 multizone = []
 per_key = true
@@ -47,9 +40,23 @@ standard = ["Static", "Breathe", "Strobe", "Pulse"]
 multizone = []
 per_key = false
 
+[[led_data]]
+prod_family = "ROG Zephyrus M15"
+board_names = ["GU502L"]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
+multizone = []
+per_key = true
+
+[[led_data]]
+prod_family = "ROG Zephyrus M16"
+board_names = ["GU603Z", "GU603H"]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
+multizone = []
+per_key = false
+
 [[led_data]]
 prod_family = "ROG Zephyrus S17"
-board_names = ["GX703HS"]
+board_names = ["GX703H"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
 multizone = []
 per_key = false
@@ -57,14 +64,14 @@ per_key = false
 
 [[led_data]]
 prod_family = "Zephyrus"
-board_names = ["GM501GM", "GX531"]
+board_names = ["GM501G", "GX531"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
 multizone = ["Key1", "Key2", "Key3", "Key4"]
 per_key = false
 
 [[led_data]]
 prod_family = "ROG Strix"
-board_names = ["G531GW", "G533QR", "G533QS", "G733QS", "G733QR", "G513QR", "G713QR", "G513QM", "G713IC", "G713RS"]
+board_names = ["G531GW", "G533QR", "G533QS", "G733Q", "G513QR", "G713QR", "G513QM", "G713IC", "G713RS"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
 multizone = []
 per_key = true
@@ -170,7 +177,7 @@ per_key = true
 
 [[led_data]]
 prod_family = "ROG Flow X13"
-board_names = ["GV301QH", "GV301QE"]
+board_names = ["GV301Q"]
 standard = ["Static", "Breathe", "Pulse"]
 multizone = []
 per_key = false
@@ -181,3 +188,10 @@ board_names = ["G513IC", "G513RC"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
 multizone = []
 per_key = false
+
+[[led_data]]
+prod_family = "ROG Flow X16"
+board_names = ["GV601R"]
+standard = ["Static", "Breathe", "Strobe", "Pulse"]
+multizone = []
+per_key = false

data/asusd.rules

@@ -9,6 +9,7 @@ ENV{DMI_FAMILY}=="*TUF*", GOTO="asusd_start"
 ENV{DMI_FAMILY}=="*ROG*", GOTO="asusd_start"
 ENV{DMI_FAMILY}=="*Zephyrus*", GOTO="asusd_start"
 ENV{DMI_FAMILY}=="*Strix*", GOTO="asusd_start"
+ENV{DMI_FAMILY}=="*Vivobook*", GOTO="asusd_start"
 # No match so
 GOTO="asusd_end"
 

design-patterns.md

@@ -18,81 +18,112 @@ Then for each trait that is required a new struct is required that can have the
 
 Main controller:
 
+For a very simple controller that doesn't need exclusive access you can clone across threads
+
+```rust
+#[derive(Clone)]
+pub struct CtrlAnime {
+    <things the controller requires>
+    config: Arc<Mutex<Config>>,
+}
+
+// This is the task trait used for such things as file watches, or logind
+// notifications (boot/suspend/shutdown etc)
+impl crate::CtrlTask for CtrlAnime {}
+
+// The trait to easily add the controller to Zbus to enable the zbus derived functions
+// to be polled, run, react etc.
+impl crate::ZbusAdd for CtrlAnime {}
+
+impl CtrlAnime {}
+```
+
+ Otherwise, you will need to share the controller via mutex
+
 ```rust
 pub struct CtrlAnime {
     <things the controller requires>
 }
+// Like this
+#[derive(Clone)]
+pub struct CtrlAnimeTask(Arc<Mutex<CtrlAnime>>);
 
-impl CtrlAnime {
-    <functions the controller exposes>
-}
+#[derive(Clone)]
+pub struct CtrlAnimeZbus(Arc<Mutex<CtrlAnime>>);
+
+impl CtrlAnime {}
 ```
 
-The task trait. There are three ways to implement this:
+The task trait:
 
 ```rust
+// Mutex should always be async mutex
 pub struct CtrlAnimeTask(Arc<Mutex<CtrlAnime>>);
 
 impl crate::CtrlTask for CtrlAnimeTask {
     // This will run once only
-    fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
-       if let Ok(lock) = self.inner.try_lock() {
-            <some action>
-        }
+    async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
+       let lock self.inner.lock().await;
+        <some action>
         Ok(())
     }
 
     // This will run until the notification stream closes (which in most cases will be never)
-    fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
-        let connection = Connection::system().await.unwrap();
-        let manager = ManagerProxy::new(&connection).await.unwrap();
-
-        let inner = self.inner.clone();
-        executor
-            .spawn(async move {
-                // A notification from logind dbus interface
-                if let Ok(p) = manager.receive_prepare_for_sleep().await {
-                    // A stream that will continuously output events
-                    p.for_each(|_| {
-                        if let Ok(lock) = inner.try_lock() {
-                            // Do stuff here
-                        }
-                    })
-                    .await;
+    async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
+        let inner1 = self.inner.clone();
+        let inner2 = self.inner.clone();
+        let inner3 = self.inner.clone();
+        let inner4 = self.inner.clone();
+        // This is a free method on CtrlTask trait
+        self.create_sys_event_tasks(
+            // Loop is required to try an attempt to get the mutex *without* blocking
+            // other threads - it is possible to end up with deadlocks otherwise.
+            move || loop {
+                if let Some(lock) = inner1.try_lock() {
+                    run_action(true, lock, inner1.clone());
+                    break;
                 }
-            })
-            .detach();
-    }
-
-    // This task will run every 500 milliseconds
-    fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
-        let inner = self.inner.clone();
-        // This is a provided free trait to help set up a repeating task
-        self.repeating_task(500, executor, move || {
-            if let Ok(lock) = inner.try_lock() {
-                // Do stuff here
-            }
-        })
+            },
+            move || loop {
+                if let Some(lock) = inner2.try_lock() {
+                    run_action(false, lock, inner2.clone());
+                    break;
+                }
+            },
+            move || loop {
+                if let Some(lock) = inner3.try_lock() {
+                    run_action(true, lock, inner3.clone());
+                    break;
+                }
+            },
+            move || loop {
+                if let Some(lock) = inner4.try_lock() {
+                    run_action(false, lock, inner4.clone());
+                    break;
+                }
+            },
+        )
         .await;
     }
 }
 ```
 
 The reloader trait
+
 ```rust
 pub struct CtrlAnimeReloader(Arc<Mutex<CtrlAnime>>);
 
 impl crate::Reloadable for CtrlAnimeReloader {
-    fn reload(&mut self) -> Result<(), RogError> {
-        if let Ok(lock) = self.inner.try_lock() {
-            <some action>
-        }
+    async fn reload(&mut self) -> Result<(), RogError> {
+        let lock = self.inner.lock().await;
+        <some action>
         Ok(())
     }
 }
 ```
 
 The Zbus requirements:
+
 ```rust
 pub struct CtrlAnimeZbus(Arc<Mutex<CtrlAnime>>);
 
@@ -106,10 +137,9 @@ impl crate::ZbusAdd for CtrlAnimeZbus {
 
 #[dbus_interface(name = "org.asuslinux.Daemon")]
 impl CtrlAnimeZbus {
-    fn <zbus method>() {
-       if let Ok(lock) = self.inner.try_lock() {
-            <some action>
-        }
+    async fn <zbus method>() {
+       let lock = self.inner.lock().await;
+        <some action>
     }
 }
 ```

rog-anime/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rog_anime"
-version = "1.3.5"
+version.workspace = true
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
@@ -9,7 +9,7 @@ homepage = "https://gitlab.com/asus-linux/asus-nb-ctrl"
 documentation = "https://docs.rs/rog-anime"
 description = "Types useful for translating images and other data for display on the ASUS AniMe Matrix display"
 keywords = ["ROG", "ASUS", "AniMe"]
-edition = "2018"
+edition = "2021"
 exclude = ["data"]
 
 [features]
@@ -18,17 +18,17 @@ dbus = ["zvariant", "zbus"]
 detect = ["sysfs-class"]
 
 [dependencies]
-png_pong = "^0.8.0"
-pix = "0.13"
-gif = "^0.11.2"
-log = "*"
+png_pong.workspace = true
+pix.workspace = true
+gif.workspace = true
+log.workspace = true
 
-serde = "^1.0"
-serde_derive = "^1.0"
+serde.workspace = true
+serde_derive.workspace = true
 
-glam = { version = "^0.21.2", features = ["serde"] }
+glam.workspace = true
 
-zvariant = { version = "^3.0", optional = true }
-zbus = { version = "^2.2", optional = true }
+zvariant = { workspace = true, optional = true }
+zbus = { workspace = true, optional = true }
 
-sysfs-class = { version = "^0.1", optional = true }
+sysfs-class = { workspace = true, optional = true }

rog-anime/src/data.rs

@@ -29,7 +29,7 @@ const USB_PREFIX2: [u8; 7] = [0x5e, 0xc0, 0x02, 0x74, 0x02, 0x73, 0x02];
 const USB_PREFIX3: [u8; 7] = [0x5e, 0xc0, 0x02, 0xe7, 0x04, 0x73, 0x02];
 
 #[cfg_attr(feature = "dbus", derive(Type))]
-#[derive(Debug, PartialEq, Copy, Clone, Deserialize, Serialize)]
+#[derive(Debug, PartialEq, Eq, Copy, Clone, Deserialize, Serialize)]
 pub struct AnimePowerStates {
     pub brightness: u8,
     pub enabled: bool,

rog-anime/src/diagonal.rs

@@ -131,14 +131,14 @@ impl AnimeDiagonal {
     #[inline]
     pub fn into_data_buffer(&self, anime_type: AnimeType) -> Result<AnimeDataBuffer> {
         match anime_type {
-            AnimeType::GA401 => self.into_ga401_packets(),
-            AnimeType::GA402 => self.into_ga402_packets(),
+            AnimeType::GA401 => self.to_ga401_packets(),
+            AnimeType::GA402 => self.to_ga402_packets(),
         }
     }
 
     /// Do conversion from the nested Vec in AnimeMatrix to the two required
     /// packets suitable for sending over USB
-    fn into_ga401_packets(&self) -> Result<AnimeDataBuffer> {
+    fn to_ga401_packets(&self) -> Result<AnimeDataBuffer> {
         let mut buf = vec![0u8; AnimeType::GA401.data_length()];
 
         buf[1..=32].copy_from_slice(&self.get_row(0, 3, 32));
@@ -200,12 +200,12 @@ impl AnimeDiagonal {
         AnimeDataBuffer::from_vec(crate::AnimeType::GA401, buf)
     }
 
-    fn into_ga402_packets(&self) -> Result<AnimeDataBuffer> {
+    fn to_ga402_packets(&self) -> Result<AnimeDataBuffer> {
         let mut buf = vec![0u8; AnimeType::GA402.data_length()];
         let mut start_index: usize = 0;
 
         fn copy_slice(
-            buf: &mut Vec<u8>,
+            buf: &mut [u8],
             anime: &AnimeDiagonal,
             x: usize,
             y: usize,

rog-anime/src/image.rs

@@ -88,7 +88,7 @@ impl AnimeImage {
         width: u32,
         anime_type: AnimeType,
     ) -> Result<Self> {
-        if bright < 0.0 || bright > 1.0 {
+        if !(0.0..=1.0).contains(&bright) {
             return Err(AnimeError::InvalidBrightness(bright));
         }
 

rog-anime/src/usb.rs

@@ -26,9 +26,7 @@ pub fn get_anime_type() -> Result<AnimeType, AnimeError> {
     let dmi = sysfs_class::DmiId::default();
     let board_name = dmi.board_name()?;
 
-    if board_name.contains("GA401I") {
-        return Ok(AnimeType::GA401);
-    } else if board_name.contains("GA401Q") {
+    if board_name.contains("GA401I") || board_name.contains("GA401Q") {
         return Ok(AnimeType::GA401);
     } else if board_name.contains("GA402R") {
         return Ok(AnimeType::GA402);

rog-aura/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rog_aura"
-version = "1.3.3"
+version.workspace = true
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
@@ -9,7 +9,7 @@ homepage = "https://gitlab.com/asus-linux/asusctl"
 documentation = "https://docs.rs/rog-anime"
 description = "Types useful for fancy keyboards on ASUS ROG laptops"
 keywords = ["ROG", "ASUS", "Aura"]
-edition = "2018"
+edition = "2021"
 exclude = ["data"]
 
 [features]
@@ -17,10 +17,10 @@ default = ["dbus", "toml"]
 dbus = ["zvariant"]
 
 [dependencies]
-serde = "^1.0"
-serde_derive = "^1.0"
-toml = { version = "^0.5", optional = true }
-zvariant = { version = "^3.0", optional = true }
+serde.workspace = true
+serde_derive.workspace = true
+toml = { workspace = true, optional = true }
+zvariant = { workspace = true, optional = true }
 
 [dev-dependencies]
-serde_json = "^1.0"
+serde_json.workspace = true

rog-aura/src/builtin_modes.rs

@@ -5,14 +5,14 @@ pub const LED_INIT4: &str = "^ASUS Tech.Inc."; // ^ == 0x5e
 pub const LED_INIT5: [u8; 6] = [0x5e, 0x05, 0x20, 0x31, 0, 0x08];
 
 use serde_derive::{Deserialize, Serialize};
-use std::str::FromStr;
+use std::{fmt::Display, str::FromStr};
 #[cfg(feature = "dbus")]
 use zvariant::Type;
 
 use crate::{error::Error, LED_MSG_LEN};
 
 #[cfg_attr(feature = "dbus", derive(Type))]
-#[derive(Debug, Copy, Clone, PartialEq, Deserialize, Serialize)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Deserialize, Serialize)]
 pub enum LedBrightness {
     Off,
     Low,
@@ -33,7 +33,7 @@ impl From<u32> for LedBrightness {
 }
 
 #[cfg_attr(feature = "dbus", derive(Type))]
-#[derive(Debug, Clone, PartialEq, PartialOrd, Copy, Deserialize, Serialize)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Copy, Deserialize, Serialize)]
 pub struct Colour(pub u8, pub u8, pub u8);
 
 impl Default for Colour {
@@ -85,7 +85,7 @@ impl From<Colour> for [u8; 3] {
 }
 
 #[cfg_attr(feature = "dbus", derive(Type))]
-#[derive(Debug, Copy, Clone, PartialEq, Deserialize, Serialize)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Deserialize, Serialize)]
 pub enum Speed {
     Low = 0xe1,
     Med = 0xeb,
@@ -123,7 +123,7 @@ impl From<Speed> for u8 {
 ///
 /// Enum corresponds to the required integer value
 #[cfg_attr(feature = "dbus", derive(Type))]
-#[derive(Debug, Copy, Clone, PartialEq, Deserialize, Serialize)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Deserialize, Serialize)]
 pub enum Direction {
     Right,
     Left,
@@ -171,6 +171,12 @@ pub enum AuraModeNum {
     Flash = 12,
 }
 
+impl Display for AuraModeNum {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", <&str>::from(self))
+    }
+}
+
 impl From<AuraModeNum> for String {
     fn from(mode: AuraModeNum) -> Self {
         match mode {
@@ -251,7 +257,7 @@ impl From<u8> for AuraModeNum {
 
 /// Base effects have no zoning, while multizone is 1-4
 #[cfg_attr(feature = "dbus", derive(Type))]
-#[derive(Debug, Default, Copy, Clone, PartialEq, Deserialize, Serialize)]
+#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Deserialize, Serialize)]
 pub enum AuraZone {
     /// Used if keyboard has no zones, or if setting all
     #[default]
@@ -325,8 +331,8 @@ impl AuraEffect {
         &self.mode
     }
 
-    pub fn mode_name(&self) -> String {
-        (<&str>::from(&self.mode)).to_string()
+    pub fn mode_name(&self) -> &str {
+        <&str>::from(&self.mode)
     }
 
     pub fn mode_num(&self) -> u8 {

rog-aura/src/keys.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Default, PartialEq, Copy, Clone, Serialize, Deserialize)]
+#[derive(Debug, Default, PartialEq, Eq, Copy, Clone, Serialize, Deserialize)]
 pub enum Key {
     VolUp,
     VolDown,
@@ -235,51 +235,44 @@ impl KeyShape {
     /// A blank is used to space keys out in GUI's and can be used or ignored
     /// depednign on the per-key effect
     pub const fn is_blank(&self) -> bool {
-        match self {
+        matches!(
+            self,
             Self::NormalBlank
-            | Self::FuncBlank
-            | Self::ArrowBlank
-            | Self::ArrowSplitBlank
-            | Self::ArrowRegularBlank => true,
-            _ => false,
-        }
+                | Self::FuncBlank
+                | Self::ArrowBlank
+                | Self::ArrowSplitBlank
+                | Self::ArrowRegularBlank
+        )
     }
 
     /// A spacer is used to space keys out in GUI's, but ignored in per-key effects
     pub const fn is_spacer(&self) -> bool {
-        match self {
+        matches!(
+            self,
             Self::FuncSpacer
-            | Self::NormalSpacer
-            | Self::ArrowSpacer
-            | Self::ArrowSplitSpacer
-            | Self::ArrowRegularSpacer => true,
-            _ => false,
-        }
+                | Self::NormalSpacer
+                | Self::ArrowSpacer
+                | Self::ArrowSplitSpacer
+                | Self::ArrowRegularSpacer
+        )
     }
 
     /// All keys with a postfix of some number
     pub const fn is_group(&self) -> bool {
-        match self {
-            Self::LShift3 | Self::RShift3 => true,
-            Self::Return3 | Self::Space5 | Self::Backspace3 => true,
-            _ => false,
-        }
+        matches!(
+            self,
+            Self::LShift3 | Self::RShift3 | Self::Return3 | Self::Space5 | Self::Backspace3
+        )
     }
 
     /// Mostly intended as a helper for signalling when to draw a
     /// split/compact arrow cluster
     pub const fn is_arrow_cluster(&self) -> bool {
-        match self {
-            Self::Arrow | Self::ArrowBlank | Self::ArrowSpacer => true,
-            _ => false,
-        }
+        matches!(self, Self::Arrow | Self::ArrowBlank | Self::ArrowSpacer)
     }
 
     pub const fn is_arrow_splits(&self) -> bool {
-        match self {
-            Self::ArrowSplit | Self::ArrowSplitBlank | Self::ArrowSplitSpacer => true,
-            _ => false,
-        }
+        matches!(self, Self::Arrow | Self::ArrowBlank | Self::ArrowSpacer)
     }
 }
 

rog-aura/src/layouts/mod.rs

@@ -35,9 +35,9 @@ impl KeyLayout {
         let mut buf = String::new();
         let read_len = file.read_to_string(&mut buf)?;
         if read_len == 0 {
-            return Err(Error::Io(std::io::ErrorKind::InvalidData.into()));
+            Err(Error::Io(std::io::ErrorKind::InvalidData.into()))
         } else {
-            return Ok(toml::from_str::<Self>(&buf)?);
+            Ok(toml::from_str::<Self>(&buf)?)
         }
     }
 

rog-aura/src/sequencer/effects.rs

@@ -138,16 +138,11 @@ impl EffectState for Breathe {
 
         let speed = 4 - <u8>::from(*speed);
 
-        let colour: &mut Colour;
         if *colour_actual == Colour(0, 0, 0) {
             *use_colour1 = !*use_colour1;
         }
 
-        if !*use_colour1 {
-            colour = colour2;
-        } else {
-            colour = colour1;
-        }
+        let colour = if !*use_colour1 { colour2 } else { colour1 };
 
         let r1_scale = colour.0 / speed / 2;
         let g1_scale = colour.1 / speed / 2;

rog-aura/src/usb.rs

@@ -21,7 +21,7 @@ pub const fn aura_brightness_bytes(brightness: u8) -> [u8; 17] {
 }
 
 #[cfg_attr(feature = "dbus", derive(Type))]
-#[derive(Clone, Debug, PartialEq, PartialOrd, Serialize, Deserialize, Default)]
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Serialize, Deserialize, Default)]
 pub enum AuraDevice {
     Tuf,
     X1854,
@@ -127,7 +127,7 @@ impl BitOr<AuraDev1866> for AuraDev1866 {
     type Output = u32;
 
     fn bitor(self, rhs: AuraDev1866) -> Self::Output {
-        return self as u32 | rhs as u32;
+        self as u32 | rhs as u32
     }
 }
 
@@ -135,7 +135,7 @@ impl BitAnd<AuraDev1866> for AuraDev1866 {
     type Output = u32;
 
     fn bitand(self, rhs: AuraDev1866) -> Self::Output {
-        return self as u32 & rhs as u32;
+        self as u32 & rhs as u32
     }
 }
 
@@ -178,14 +178,14 @@ pub enum AuraDev19b6 {
     SleepKeyb = 1 << 5,
     ShutdownLogo = 1 << 6,
     ShutdownKeyb = 1 << 7,
-    BootBar = 1 << 7 + 2,
-    AwakeBar = 1 << 7 + 3,
-    SleepBar = 1 << 7 + 4,
-    ShutdownBar = 1 << 7 + 5,
-    BootLid = 1 << 15 + 1,
-    AwakeLid = 1 << 15 + 2,
-    SleepLid = 1 << 15 + 3,
-    ShutdownLid = 1 << 15 + 4,
+    BootBar = 1 << (7 + 2),
+    AwakeBar = 1 << (7 + 3),
+    SleepBar = 1 << (7 + 4),
+    ShutdownBar = 1 << (7 + 5),
+    BootLid = 1 << (15 + 1),
+    AwakeLid = 1 << (15 + 2),
+    SleepLid = 1 << (15 + 3),
+    ShutdownLid = 1 << (15 + 4),
 }
 
 impl From<AuraDev19b6> for u32 {
@@ -216,7 +216,7 @@ impl BitOr<AuraDev19b6> for AuraDev19b6 {
     type Output = u16;
 
     fn bitor(self, rhs: AuraDev19b6) -> Self::Output {
-        return self as u16 | rhs as u16;
+        self as u16 | rhs as u16
     }
 }
 
@@ -224,7 +224,7 @@ impl BitAnd<AuraDev19b6> for AuraDev19b6 {
     type Output = u16;
 
     fn bitand(self, rhs: AuraDev19b6) -> Self::Output {
-        return self as u16 & rhs as u16;
+        self as u16 & rhs as u16
     }
 }
 

rog-control-center/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rog-control-center"
-version = "1.1.1"
+version.workspace = true
 authors = ["Luke D. Jones <luke@ljones.dev>"]
 edition = "2021"
 
@@ -8,30 +8,35 @@ edition = "2021"
 mocking = []
 
 [dependencies]
-egui = { git = "https://github.com/emilk/egui" }
-eframe= { git = "https://github.com/emilk/egui" }
+egui = { git = "https://github.com/flukejones/egui" }
+eframe= { git = "https://github.com/flukejones/egui" }
 #eframe= { git = "https://github.com/emilk/egui", default-features = false, features = ["dark-light", "default_fonts", "wgpu"] }
 
+libappindicator = "0.7" # Tray icon
+gtk = "0.15"
+
 daemon = { path = "../daemon" }
 rog_anime = { path = "../rog-anime" }
 rog_dbus = { path = "../rog-dbus" }
 rog_aura = { path = "../rog-aura" }
 rog_profiles = { path = "../rog-profiles" }
 rog_platform = { path = "../rog-platform" }
-# supergfxctl = { git = "https://gitlab.com/asus-linux/supergfxctl.git" }
+supergfxctl = { git = "https://gitlab.com/asus-linux/supergfxctl.git", default-features = false }
+#supergfxctl = { path = "../../supergfxctl", default-features = false }
 
-smol = "^1.2"
+log.workspace = true
+env_logger.workspace = true
 
-serde = "^1.0"
-toml = "^0.5"
-serde_json = "^1.0"
-serde_derive = "^1.0"
-zbus = "^2.3"
-nix = "^0.20.0"
-tempfile = "3.2.0"
-dirs = "3.0.1"
+tokio.workspace = true
+serde.workspace = true
+toml.workspace = true
+serde_json.workspace = true
+serde_derive.workspace = true
+zbus.workspace = true
+dirs.workspace = true
+notify-rust.workspace = true
 
-[dependencies.notify-rust]
-version = "^4.3"
-default-features = false
-features = ["z"]
+png_pong.workspace = true
+
+nix = "^0.25"
+tempfile = "3.2.0"

rog-control-center/src/app.rs

@@ -2,7 +2,7 @@ use std::{
     f64::consts::PI,
     sync::{
         atomic::{AtomicBool, AtomicU8, Ordering},
-        Arc,
+        Arc, Mutex,
     },
     time::{Duration, Instant},
 };
@@ -14,13 +14,12 @@ use crate::{
     config::Config, error::Result, page_states::PageDataStates, Page, RogDbusClientBlocking,
 };
 
-pub struct RogApp<'a> {
+pub struct RogApp {
     pub page: Page,
-    pub states: PageDataStates,
+    pub states: Arc<Mutex<PageDataStates>>,
     pub supported: SupportedFunctions,
     // TODO: can probably just open and read whenever
     pub config: Config,
-    pub asus_dbus: RogDbusClientBlocking<'a>,
     /// Oscillator in percentage
     pub oscillator1: Arc<AtomicU8>,
     pub oscillator2: Arc<AtomicU8>,
@@ -31,11 +30,11 @@ pub struct RogApp<'a> {
     pub oscillator_toggle: Arc<AtomicBool>,
 }
 
-impl<'a> RogApp<'a> {
+impl RogApp {
     /// Called once before the first frame.
     pub fn new(
         config: Config,
-        states: PageDataStates,
+        states: Arc<Mutex<PageDataStates>>,
         _cc: &eframe::CreationContext<'_>,
     ) -> Result<Self> {
         let (dbus, _) = RogDbusClientBlocking::new()?;
@@ -55,6 +54,7 @@ impl<'a> RogApp<'a> {
         let oscillator_freq1 = oscillator_freq.clone();
         let oscillator_toggle = Arc::new(AtomicBool::new(false));
         let oscillator_toggle1 = oscillator_toggle.clone();
+
         std::thread::spawn(move || {
             let started = Instant::now();
             let mut toggled = false;
@@ -83,6 +83,7 @@ impl<'a> RogApp<'a> {
                 oscillator1_1.store(tmp1, Ordering::SeqCst);
                 oscillator1_2.store(tmp2, Ordering::SeqCst);
                 oscillator1_3.store(tmp3, Ordering::SeqCst);
+
                 std::thread::sleep(Duration::from_millis(33));
             }
         });
@@ -92,7 +93,6 @@ impl<'a> RogApp<'a> {
             states,
             page: Page::System,
             config,
-            asus_dbus: dbus,
             oscillator1,
             oscillator2,
             oscillator3,
@@ -102,60 +102,63 @@ impl<'a> RogApp<'a> {
     }
 }
 
-impl<'a> eframe::App for RogApp<'a> {
+impl eframe::App for RogApp {
     /// Called each time the UI needs repainting, which may be many times per second.
     /// Put your widgets into a `SidePanel`, `TopPanel`, `CentralPanel`, `Window` or `Area`.
     fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
-        let Self {
-            supported,
-            asus_dbus: dbus,
-            states,
-            ..
-        } = self;
-        states
-            .refresh_if_notfied(supported, dbus)
-            .map(|repaint| {
-                if repaint {
-                    ctx.request_repaint();
-                }
-            })
-            .map_err(|e| self.states.error = Some(e.to_string()))
-            .ok();
+        let states = self.states.clone();
+
+        if let Ok(mut states) = states.try_lock() {
+            if states.app_should_update {
+                states.app_should_update = false;
+                ctx.request_repaint();
+            }
+        }
 
         let page = self.page;
 
         self.top_bar(ctx, frame);
         self.side_panel(ctx);
 
-        if let Some(err) = self.states.error.clone() {
-            egui::CentralPanel::default().show(ctx, |ui| {
-                ui.heading(RichText::new("Error!").size(28.0));
+        let mut was_error = false;
 
-                ui.centered_and_justified(|ui| {
-                    ui.label(RichText::new(format!("The error was: {:?}", err)).size(22.0));
-                });
-            });
-            egui::TopBottomPanel::bottom("error_bar")
-                .default_height(26.0)
-                .show(ctx, |ui| {
-                    ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
-                        if ui
-                            .add(Button::new(RichText::new("Okay").size(20.0)))
-                            .clicked()
-                        {
-                            self.states.error = None;
-                        }
+        if let Ok(mut states) = states.try_lock() {
+            if let Some(err) = states.error.clone() {
+                was_error = true;
+                egui::CentralPanel::default().show(ctx, |ui| {
+                    ui.heading(RichText::new("Error!").size(28.0));
+
+                    ui.centered_and_justified(|ui| {
+                        ui.label(RichText::new(format!("The error was: {:?}", err)).size(22.0));
                     });
                 });
-        } else if page == Page::System {
-            self.system_page(ctx);
-        } else if page == Page::AuraEffects {
-            self.aura_page(ctx);
-        // TODO: Anime page is not complete
-        // } else if page == Page::AnimeMatrix {
-        //     self.anime_page(ctx);
-        } else if page == Page::FanCurves {
-            self.fan_curve_page(ctx);
+                egui::TopBottomPanel::bottom("error_bar")
+                    .default_height(26.0)
+                    .show(ctx, |ui| {
+                        ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
+                            if ui
+                                .add(Button::new(RichText::new("Okay").size(20.0)))
+                                .clicked()
+                            {
+                                states.error = None;
+                            }
+                        });
+                    });
+            }
+        }
+        if !was_error {
+            if let Ok(mut states) = states.try_lock() {
+                if page == Page::System {
+                    self.system_page(&mut states, ctx);
+                } else if page == Page::AuraEffects {
+                    self.aura_page(&mut states, ctx);
+                // TODO: Anime page is not complete
+                // } else if page == Page::AnimeMatrix {
+                //     self.anime_page(ctx);
+                } else if page == Page::FanCurves {
+                    self.fan_curve_page(&mut states, ctx);
+                }
+            }
         }
     }
 }

rog-control-center/src/config.rs

@@ -6,17 +6,18 @@ use std::{
 use serde_derive::{Deserialize, Serialize};
 //use log::{error, info, warn};
 
-use crate::error::Error;
+use crate::{error::Error, notify::EnabledNotifications};
 
 const CFG_DIR: &str = "rog";
 const CFG_FILE_NAME: &str = "rog-control-center.cfg";
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(default)]
 pub struct Config {
     pub run_in_background: bool,
     pub startup_in_background: bool,
     pub enable_notifications: bool,
+    pub enabled_notifications: EnabledNotifications,
 }
 
 impl Default for Config {
@@ -25,6 +26,7 @@ impl Default for Config {
             run_in_background: true,
             startup_in_background: false,
             enable_notifications: true,
+            enabled_notifications: EnabledNotifications::default(),
         }
     }
 }
@@ -65,7 +67,7 @@ impl Config {
         Err(Error::ConfigLoadFail)
     }
 
-    pub fn save(&self) -> Result<(), Error> {
+    pub fn save(&mut self, enabled_notifications: &EnabledNotifications) -> Result<(), Error> {
         let mut path = if let Some(dir) = dirs::config_dir() {
             dir
         } else {
@@ -85,6 +87,7 @@ impl Config {
             .truncate(true)
             .open(&path)?;
 
+        self.enabled_notifications = enabled_notifications.clone();
         let t = toml::to_string_pretty(&self).unwrap();
         file.write_all(t.as_bytes())?;
         Ok(())

rog-control-center/src/error.rs

@@ -10,6 +10,7 @@ pub enum Error {
     ConfigLockFail,
     XdgVars,
     Zbus(zbus::Error),
+    Notification(notify_rust::error::Error),
 }
 
 impl fmt::Display for Error {
@@ -22,6 +23,7 @@ impl fmt::Display for Error {
             Error::ConfigLockFail => write!(f, "Failed to lock user config"),
             Error::XdgVars => write!(f, "XDG environment vars appear unset"),
             Error::Zbus(err) => write!(f, "Error: {}", err),
+            Error::Notification(err) => write!(f, "Notification Error: {}", err),
         }
     }
 }
@@ -45,3 +47,9 @@ impl From<zbus::Error> for Error {
         Error::Zbus(err)
     }
 }
+
+impl From<notify_rust::error::Error> for Error {
+    fn from(err: notify_rust::error::Error) -> Self {
+        Error::Notification(err)
+    }
+}

rog-control-center/src/lib.rs

@@ -17,6 +17,7 @@ pub mod notify;
 pub mod page_states;
 pub mod pages;
 pub mod startup_error;
+pub mod tray;
 pub mod widgets;
 
 #[cfg(feature = "mocking")]
@@ -45,7 +46,7 @@ pub fn print_versions() {
 pub const SHOWING_GUI: u8 = 1;
 pub const SHOW_GUI: u8 = 2;
 
-#[derive(PartialEq, Clone, Copy)]
+#[derive(PartialEq, Eq, Clone, Copy)]
 pub enum Page {
     System,
     AuraEffects,
@@ -75,7 +76,7 @@ pub fn on_tmp_dir_exists() -> Result<TempDir, std::io::Error> {
     // If the app is running this ends up stacked on top of SHOWING_GUI
     ipc_file.write_all(&[SHOW_GUI])?;
     // tiny sleep to give the app a chance to respond
-    sleep(Duration::from_millis(10));
+    sleep(Duration::from_millis(100));
     ipc_file.read(&mut buf).ok();
 
     // First entry is the actual state
@@ -96,7 +97,7 @@ pub fn get_ipc_file() -> Result<File, crate::error::Error> {
     let tmp_dir = std::env::temp_dir().join("rog-gui");
     let fifo_path = tmp_dir.join("ipc.pipe");
     if let Err(e) = unistd::mkfifo(&fifo_path, stat::Mode::S_IRWXU) {
-        if !matches!(e, nix::Error::Sys(nix::errno::Errno::EEXIST)) {
+        if !matches!(e, nix::errno::Errno::EEXIST) {
             return Err(e)?;
         }
     }

rog-control-center/src/main.rs

@@ -1,32 +1,52 @@
+use eframe::{IconData, NativeOptions};
+use log::{error, LevelFilter};
 use rog_aura::layouts::KeyLayout;
+use rog_control_center::notify::EnabledNotifications;
+use rog_control_center::tray::init_tray;
 use rog_control_center::{
-    config::Config, get_ipc_file, notify::start_notifications, on_tmp_dir_exists,
+    config::Config, error::Result, get_ipc_file, notify::start_notifications, on_tmp_dir_exists,
     page_states::PageDataStates, print_versions, startup_error::AppErrorShow, RogApp,
     RogDbusClientBlocking, SHOWING_GUI, SHOW_GUI,
 };
-
+use rog_platform::supported::SupportedFunctions;
+use std::sync::Mutex;
 use std::{
     fs::OpenOptions,
     io::{Read, Write},
     path::PathBuf,
-    sync::{atomic::AtomicBool, Arc},
+    sync::Arc,
 };
+use tokio::runtime::Runtime;
 
 #[cfg(not(feature = "mocking"))]
 const DATA_DIR: &str = "/usr/share/rog-gui/";
 #[cfg(feature = "mocking")]
 const DATA_DIR: &str = env!("CARGO_MANIFEST_DIR");
 const BOARD_NAME: &str = "/sys/class/dmi/id/board_name";
+const APP_ICON_PATH: &str = "/usr/share/icons/hicolor/512x512/apps/rog-control-center.png";
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
+fn main() -> Result<()> {
     print_versions();
+    let mut logger = env_logger::Builder::new();
+    logger
+        .target(env_logger::Target::Stdout)
+        .format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()))
+        .filter(None, LevelFilter::Info)
+        .init();
+
+    // start tokio
+    let rt = Runtime::new().expect("Unable to create Runtime");
+    // Enter the runtime so that `tokio::spawn` is available immediately.
+    let _enter = rt.enter();
 
     let native_options = eframe::NativeOptions {
-        decorated: false,
+        vsync: true,
+        decorated: true,
         transparent: false,
         min_window_size: Some(egui::vec2(840.0, 600.0)),
         max_window_size: Some(egui::vec2(840.0, 600.0)),
         run_and_return: true,
+        icon_data: Some(load_icon()),
         ..Default::default()
     };
 
@@ -40,14 +60,28 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         })
         .unwrap();
 
+    let supported = match dbus.proxies().supported().supported_functions() {
+        Ok(s) => s,
+        Err(e) => {
+            eframe::run_native(
+                "ROG Control Center",
+                native_options.clone(),
+                Box::new(move |_| Box::new(AppErrorShow::new(e.to_string()))),
+            );
+            SupportedFunctions::default()
+        }
+    };
+
     // Startup
     let mut config = Config::load()?;
     let mut start_closed = config.startup_in_background;
 
     if config.startup_in_background {
         config.run_in_background = true;
-        config.save()?;
+        let tmp = config.enabled_notifications.clone(); // ends up being a double clone, oh well.
+        config.save(&tmp)?;
     }
+    let enabled_notifications = EnabledNotifications::tokio_mutex(&config);
 
     // Find and load a matching layout for laptop
     let mut file = OpenOptions::new()
@@ -72,27 +106,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .map_err(|e| {
             println!("{BOARD_NAME}, {e}");
         })
-        .unwrap_or(KeyLayout::ga401_layout());
-
-    // Cheap method to alert to notifications rather than spinning a thread for each
-    // This is quite different when done in a retained mode app
-    let charge_notified = Arc::new(AtomicBool::new(false));
-    let bios_notified = Arc::new(AtomicBool::new(false));
-    let aura_notified = Arc::new(AtomicBool::new(false));
-    let anime_notified = Arc::new(AtomicBool::new(false));
-    let profiles_notified = Arc::new(AtomicBool::new(false));
-    let fans_notified = Arc::new(AtomicBool::new(false));
-    let notifs_enabled = Arc::new(AtomicBool::new(config.enable_notifications));
-
-    start_notifications(
-        charge_notified.clone(),
-        bios_notified.clone(),
-        aura_notified.clone(),
-        anime_notified.clone(),
-        profiles_notified.clone(),
-        fans_notified.clone(),
-        notifs_enabled.clone(),
-    )?;
+        .unwrap_or_else(|_| KeyLayout::ga401_layout());
 
     // tmp-dir must live to the end of program life
     let _tmp_dir = match tempfile::Builder::new()
@@ -104,44 +118,13 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         Err(_) => on_tmp_dir_exists().unwrap(),
     };
 
+    let states = setup_page_state_and_notifs(layout, enabled_notifications, &supported).unwrap();
+
+    init_tray(supported, states.clone());
+
     loop {
-        let states = {
-            let supported = match dbus.proxies().supported().supported_functions() {
-                Ok(s) => s,
-                Err(e) => {
-                    eframe::run_native(
-                        "ROG Control Center",
-                        native_options.clone(),
-                        Box::new(move |_| Box::new(AppErrorShow::new(e.to_string()))),
-                    );
-                    return Ok(());
-                }
-            };
-
-            PageDataStates::new(
-                layout.clone(),
-                notifs_enabled.clone(),
-                charge_notified.clone(),
-                bios_notified.clone(),
-                aura_notified.clone(),
-                anime_notified.clone(),
-                profiles_notified.clone(),
-                fans_notified.clone(),
-                &supported,
-                &dbus,
-            )?
-        };
-
         if !start_closed {
-            let mut ipc_file = get_ipc_file().unwrap();
-            ipc_file.write_all(&[SHOWING_GUI]).unwrap();
-            eframe::run_native(
-                "ROG Control Center",
-                native_options.clone(),
-                Box::new(move |cc| {
-                    Box::new(RogApp::new(Config::load().unwrap(), states, cc).unwrap())
-                }),
-            );
+            start_app(states.clone(), native_options.clone())?;
         }
 
         let config = Config::load().unwrap();
@@ -149,14 +132,85 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             break;
         }
 
-        let mut buf = [0u8; 4];
-        // blocks until it is read, typically the read will happen after a second
-        // process writes to the IPC (so there is data to actually read)
-        if get_ipc_file().unwrap().read(&mut buf).is_ok() && buf[0] == SHOW_GUI {
-            start_closed = false;
-            continue;
+        if config.run_in_background {
+            let mut buf = [0u8; 4];
+            // blocks until it is read, typically the read will happen after a second
+            // process writes to the IPC (so there is data to actually read)
+            if get_ipc_file().unwrap().read(&mut buf).is_ok() && buf[0] == SHOW_GUI {
+                start_closed = false;
+                continue;
+            }
         }
-        dbg!("asda");
     }
+
+    // loop {
+    //     // This is just a blocker to idle and ensure the reator reacts
+    //     sleep(Duration::from_millis(1000)).await;
+    // }
     Ok(())
 }
+
+fn setup_page_state_and_notifs(
+    keyboard_layout: KeyLayout,
+    enabled_notifications: Arc<Mutex<EnabledNotifications>>,
+    supported: &SupportedFunctions,
+) -> Result<Arc<Mutex<PageDataStates>>> {
+    let page_states = Arc::new(Mutex::new(PageDataStates::new(
+        keyboard_layout,
+        enabled_notifications.clone(),
+        supported,
+    )?));
+
+    start_notifications(page_states.clone(), enabled_notifications)?;
+
+    Ok(page_states)
+}
+
+fn start_app(states: Arc<Mutex<PageDataStates>>, native_options: NativeOptions) -> Result<()> {
+    let mut ipc_file = get_ipc_file().unwrap();
+    ipc_file.write_all(&[SHOWING_GUI]).unwrap();
+    eframe::run_native(
+        "ROG Control Center",
+        native_options,
+        Box::new(move |cc| Box::new(RogApp::new(Config::load().unwrap(), states, cc).unwrap())),
+    );
+    Ok(())
+}
+
+/// Bah.. the icon dosn't work on wayland anyway, but we'll leave it in for now.
+fn load_icon() -> IconData {
+    let path = PathBuf::from(APP_ICON_PATH);
+    let mut buf = Vec::new();
+    let mut rgba = Vec::new();
+    let mut height = 512;
+    let mut width = 512;
+    if path.exists() {
+        if let Ok(mut file) = OpenOptions::new()
+            .read(true)
+            .open(path)
+            .map_err(|e| error!("Error opening app icon: {e:?}"))
+        {
+            file.read_to_end(&mut buf)
+                .map_err(|e| error!("Error reading app icon: {e:?}"))
+                .ok();
+
+            let data = std::io::Cursor::new(buf);
+            let decoder = png_pong::Decoder::new(data).unwrap().into_steps();
+            let png_pong::Step { raster, delay: _ } = decoder.last().unwrap().unwrap();
+
+            if let png_pong::PngRaster::Rgba8(ras) = raster {
+                rgba = ras.as_u8_slice().to_vec();
+                width = ras.width();
+                height = ras.height();
+            }
+        }
+    } else {
+        error!("Missing {APP_ICON_PATH}")
+    }
+
+    IconData {
+        height,
+        width,
+        rgba,
+    }
+}

rog-control-center/src/mocking.rs

@@ -65,7 +65,7 @@ impl Bios {
     pub fn gpu_mux_mode(&self) -> Result<i16> {
         Ok(1)
     }
-    pub fn panel_overdrive(&self) -> Result<i16> {
+    pub fn panel_od(&self) -> Result<i16> {
         Ok(1)
     }
     pub fn set_post_boot_sound(&self, _b: bool) -> Result<()> {
@@ -74,7 +74,7 @@ impl Bios {
     pub fn set_gpu_mux_mode(&self, _b: bool) -> Result<()> {
         Ok(())
     }
-    pub fn set_panel_overdrive(&self, _b: bool) -> Result<()> {
+    pub fn set_panel_od(&self, _b: bool) -> Result<()> {
         Ok(())
     }
 }
@@ -217,7 +217,7 @@ impl Supported {
             rog_bios_ctrl: RogBiosSupportedFunctions {
                 post_sound: true,
                 dedicated_gfx: true,
-                panel_overdrive: true,
+                panel_od: true,
                 dgpu_disable: true,
                 egpu_enable: true,
             },

rog-control-center/src/notify.rs

@@ -1,256 +1,410 @@
-//TODO: a lot of app state refresh depends on this so there needs
-// to be an extra AtomicBool for checking if notifications are enabled
-
-use notify_rust::{Hint, Notification, NotificationHandle};
-use rog_aura::AuraEffect;
+use crate::{config::Config, error::Result, page_states::PageDataStates};
+use notify_rust::{Hint, Notification, NotificationHandle, Urgency};
 use rog_dbus::{
-    zbus_anime::AnimeProxy, zbus_charge::ChargeProxy, zbus_led::LedProxy,
-    zbus_platform::RogBiosProxy, zbus_profile::ProfileProxy,
+    zbus_anime::AnimeProxy, zbus_led::LedProxy, zbus_platform::RogBiosProxy,
+    zbus_power::PowerProxy, zbus_profile::ProfileProxy,
 };
+use rog_platform::platform::GpuMode;
 use rog_profiles::Profile;
-use smol::{future, Executor};
+use serde::{Deserialize, Serialize};
 use std::{
-    error::Error,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc, Mutex,
-    },
-    thread::spawn,
+    fmt::Display,
+    process::Command,
+    sync::{Arc, Mutex},
 };
-use zbus::export::futures_util::StreamExt;
+use supergfxctl::{pci_device::GfxPower, zbus_proxy::DaemonProxy as SuperProxy};
+use zbus::export::futures_util::{future, StreamExt};
 
 const NOTIF_HEADER: &str = "ROG Control";
 
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(default)]
+pub struct EnabledNotifications {
+    pub receive_notify_post_boot_sound: bool,
+    pub receive_notify_panel_od: bool,
+    pub receive_notify_dgpu_disable: bool,
+    pub receive_notify_egpu_enable: bool,
+    pub receive_notify_gpu_mux_mode: bool,
+    pub receive_notify_charge_control_end_threshold: bool,
+    pub receive_notify_mains_online: bool,
+    pub receive_notify_profile: bool,
+    pub receive_notify_led: bool,
+    /// Anime
+    pub receive_power_states: bool,
+    pub receive_notify_gfx: bool,
+    pub receive_notify_gfx_status: bool,
+    pub all_enabled: bool,
+}
+
+impl Default for EnabledNotifications {
+    fn default() -> Self {
+        Self {
+            receive_notify_post_boot_sound: false,
+            receive_notify_panel_od: true,
+            receive_notify_dgpu_disable: true,
+            receive_notify_egpu_enable: true,
+            receive_notify_gpu_mux_mode: true,
+            receive_notify_charge_control_end_threshold: true,
+            receive_notify_mains_online: false,
+            receive_notify_profile: true,
+            receive_notify_led: false,
+            receive_power_states: false,
+            receive_notify_gfx: false,
+            receive_notify_gfx_status: false,
+            all_enabled: false,
+        }
+    }
+}
+
+impl EnabledNotifications {
+    pub fn tokio_mutex(config: &Config) -> Arc<Mutex<Self>> {
+        Arc::new(Mutex::new(config.enabled_notifications.clone()))
+    }
+}
+
 macro_rules! notify {
-    ($notifier:ident, $last_notif:ident, $data:expr) => {
+    ($notifier:expr, $last_notif:ident) => {
         if let Some(notif) = $last_notif.take() {
             notif.close();
         }
-        if let Ok(x) = $notifier($data) {
+        if let Ok(x) = $notifier {
             $last_notif.replace(x);
         }
     };
 }
 
-macro_rules! base_notification {
-    ($body:expr) => {
-        Notification::new()
-            .summary(NOTIF_HEADER)
-            .body($body)
-            .timeout(2000)
-            .show()
+// TODO: drop the macro and use generics plus closure
+macro_rules! recv_notif {
+    ($proxy:ident,
+        $signal:ident,
+        $last_notif:ident,
+        $notif_enabled:ident,
+        $page_states:ident,
+        ($($args: tt)*),
+        ($($out_arg:tt)+),
+        $msg:literal,
+        $notifier:ident) => {
+
+        let last_notif = $last_notif.clone();
+        let notifs_enabled1 = $notif_enabled.clone();
+        let page_states1 = $page_states.clone();
+
+        tokio::spawn(async move {
+                let conn = zbus::Connection::system().await.unwrap();
+                let proxy = $proxy::new(&conn).await.unwrap();
+                if let Ok(mut p) = proxy.$signal().await {
+                    while let Some(e) = p.next().await {
+                        if let Ok(out) = e.args() {
+                            if let Ok(config) = notifs_enabled1.lock() {
+                                if config.all_enabled && config.$signal {
+                                    if let Ok(ref mut lock) = last_notif.lock() {
+                                        notify!($notifier($msg, &out.$($out_arg)+()), lock);
+                                    }
+                                }
+                            }
+                            if let Ok(mut lock) = page_states1.lock() {
+                                lock.$($args)+ = *out.$($out_arg)+();
+                                lock.set_notified();
+                            }
+                        }
+                    }
+                };
+            });
     };
 }
 
 type SharedHandle = Arc<Mutex<Option<NotificationHandle>>>;
 
 pub fn start_notifications(
-    charge_notified: Arc<AtomicBool>,
-    bios_notified: Arc<AtomicBool>,
-    aura_notified: Arc<AtomicBool>,
-    anime_notified: Arc<AtomicBool>,
-    profiles_notified: Arc<AtomicBool>,
-    _fans_notified: Arc<AtomicBool>,
-    notifs_enabled: Arc<AtomicBool>,
-) -> Result<(), Box<dyn std::error::Error>> {
+    page_states: Arc<Mutex<PageDataStates>>,
+    enabled_notifications: Arc<Mutex<EnabledNotifications>>,
+) -> Result<()> {
     let last_notification: SharedHandle = Arc::new(Mutex::new(None));
 
-    let executor = Executor::new();
     // BIOS notif
-    let last_notif = last_notification.clone();
-    let notifs_enabled1 = notifs_enabled.clone();
-    let bios_notified1 = bios_notified.clone();
-    // TODO: make a macro or generic function or something...
-    executor
-        .spawn(async move {
-            let conn = zbus::Connection::system().await.unwrap();
-            let proxy = RogBiosProxy::new(&conn).await.unwrap();
-            if let Ok(p) = proxy.receive_notify_post_boot_sound().await {
-                p.for_each(|e| {
-                    if let Ok(out) = e.args() {
-                        if notifs_enabled1.load(Ordering::SeqCst) {
-                            if let Ok(ref mut lock) = last_notif.try_lock() {
-                                notify!(do_post_sound_notif, lock, &out.sound());
-                            }
-                        }
-                        bios_notified1.store(true, Ordering::SeqCst);
-                    }
-                    future::ready(())
-                })
-                .await;
-            };
-        })
-        .detach();
+    recv_notif!(
+        RogBiosProxy,
+        receive_notify_post_boot_sound,
+        last_notification,
+        enabled_notifications,
+        page_states,
+        (bios.post_sound),
+        (on),
+        "BIOS Post sound",
+        do_notification
+    );
 
-    executor
-        .spawn(async move {
-            let conn = zbus::Connection::system().await.unwrap();
-            let proxy = RogBiosProxy::new(&conn).await.unwrap();
-            if let Ok(p) = proxy.receive_notify_panel_overdrive().await {
-                p.for_each(|_| {
-                    bios_notified.store(true, Ordering::SeqCst);
-                    future::ready(())
-                })
-                .await;
-            };
-        })
-        .detach();
+    recv_notif!(
+        RogBiosProxy,
+        receive_notify_panel_od,
+        last_notification,
+        enabled_notifications,
+        page_states,
+        (bios.panel_overdrive),
+        (overdrive),
+        "Panel Overdrive enabled:",
+        do_notification
+    );
+
+    recv_notif!(
+        RogBiosProxy,
+        receive_notify_dgpu_disable,
+        last_notification,
+        enabled_notifications,
+        page_states,
+        (bios.dgpu_disable),
+        (disable),
+        "BIOS dGPU disabled",
+        do_notification
+    );
+
+    recv_notif!(
+        RogBiosProxy,
+        receive_notify_egpu_enable,
+        last_notification,
+        enabled_notifications,
+        page_states,
+        (bios.egpu_enable),
+        (enable),
+        "BIOS eGPU enabled",
+        do_notification
+    );
+
+    recv_notif!(
+        RogBiosProxy,
+        receive_notify_gpu_mux_mode,
+        last_notification,
+        enabled_notifications,
+        page_states,
+        (bios.dedicated_gfx),
+        (mode),
+        "Reboot required. BIOS GPU MUX mode set to",
+        do_mux_notification
+    );
 
     // Charge notif
-    let last_notif = last_notification.clone();
-    let notifs_enabled1 = notifs_enabled.clone();
-    executor
-        .spawn(async move {
-            let conn = zbus::Connection::system().await.unwrap();
-            let proxy = ChargeProxy::new(&conn).await.unwrap();
-            if let Ok(p) = proxy.receive_notify_charge().await {
-                p.for_each(|e| {
-                    if let Ok(out) = e.args() {
-                        if notifs_enabled1.load(Ordering::SeqCst) {
-                            if let Ok(ref mut lock) = last_notif.try_lock() {
-                                notify!(do_charge_notif, lock, &out.limit);
-                            }
-                        }
-                        charge_notified.store(true, Ordering::SeqCst);
-                    }
-                    future::ready(())
-                })
-                .await;
-            };
-        })
-        .detach();
+    recv_notif!(
+        PowerProxy,
+        receive_notify_charge_control_end_threshold,
+        last_notification,
+        enabled_notifications,
+        page_states,
+        (power_state.charge_limit),
+        (limit),
+        "Battery charge limit changed to",
+        do_notification
+    );
+
+    recv_notif!(
+        PowerProxy,
+        receive_notify_mains_online,
+        last_notification,
+        enabled_notifications,
+        page_states,
+        (power_state.ac_power),
+        (on),
+        "AC Power power is",
+        ac_power_notification
+    );
 
     // Profile notif
-    let last_notif = last_notification.clone();
-    let notifs_enabled1 = notifs_enabled.clone();
-    executor
-        .spawn(async move {
-            let conn = zbus::Connection::system().await.unwrap();
-            let proxy = ProfileProxy::new(&conn).await.unwrap();
-            if let Ok(p) = proxy.receive_notify_profile().await {
-                p.for_each(|e| {
-                    if let Ok(out) = e.args() {
-                        if notifs_enabled1.load(Ordering::SeqCst) {
-                            if let Ok(ref mut lock) = last_notif.try_lock() {
-                                notify!(do_thermal_notif, lock, &out.profile);
-                            }
-                        }
-                        profiles_notified.store(true, Ordering::SeqCst);
-                    }
-                    future::ready(())
-                })
-                .await;
-            };
-        })
-        .detach();
+    recv_notif!(
+        ProfileProxy,
+        receive_notify_profile,
+        last_notification,
+        enabled_notifications,
+        page_states,
+        (profiles.current),
+        (profile),
+        "Profile changed to",
+        do_thermal_notif
+    );
+    // notify!(do_thermal_notif(&out.profile), lock);
 
     // LED notif
-    let last_notif = last_notification.clone();
-    let aura_notif = aura_notified.clone();
-    let notifs_enabled1 = notifs_enabled.clone();
-    executor
-        .spawn(async move {
-            let conn = zbus::Connection::system().await.unwrap();
-            let proxy = LedProxy::new(&conn).await.unwrap();
-            if let Ok(p) = proxy.receive_notify_led().await {
-                p.for_each(|e| {
-                    if let Ok(out) = e.args() {
-                        if notifs_enabled1.load(Ordering::SeqCst) {
-                            if let Ok(ref mut lock) = last_notif.try_lock() {
-                                notify!(do_led_notif, lock, &out.data);
+    recv_notif!(
+        LedProxy,
+        receive_notify_led,
+        last_notification,
+        enabled_notifications,
+        page_states,
+        (aura.current_mode),
+        (data.mode),
+        "Keyboard LED mode changed to",
+        do_notification
+    );
+
+    let page_states1 = page_states.clone();
+    tokio::spawn(async move {
+        let conn = zbus::Connection::system().await.unwrap();
+        let proxy = AnimeProxy::new(&conn).await.unwrap();
+        if let Ok(p) = proxy.receive_power_states().await {
+            p.for_each(|_| {
+                if let Ok(_lock) = page_states1.lock() {
+                    // TODO: lock.anime.
+                }
+                future::ready(())
+            })
+            .await;
+        };
+    });
+
+    recv_notif!(
+        SuperProxy,
+        receive_notify_gfx,
+        last_notification,
+        enabled_notifications,
+        page_states,
+        (gfx_state.mode),
+        (mode),
+        "Gfx mode changed to",
+        do_notification
+    );
+
+    // recv_notif!(
+    //     SuperProxy,
+    //     receive_notify_action,
+    //     bios_notified,
+    //     last_gfx_action_notif,
+    //     enabled_notifications,
+    //     [action],
+    //     "Gfx mode change requires",
+    //     do_gfx_action_notif
+    // );
+
+    tokio::spawn(async move {
+        let conn = zbus::Connection::system().await.unwrap();
+        let proxy = SuperProxy::new(&conn).await.unwrap();
+        if let Ok(mut p) = proxy.receive_notify_action().await {
+            while let Some(e) = p.next().await {
+                if let Ok(out) = e.args() {
+                    let action = out.action();
+                    do_gfx_action_notif("Gfx mode change requires", &format!("{action:?}",))
+                        .unwrap();
+                }
+            }
+        };
+    });
+
+    let notifs_enabled1 = enabled_notifications;
+    let last_notif = last_notification;
+    tokio::spawn(async move {
+        let conn = zbus::Connection::system().await.unwrap();
+        let proxy = SuperProxy::new(&conn).await.unwrap();
+        if let Ok(mut p) = proxy.receive_notify_gfx_status().await {
+            while let Some(e) = p.next().await {
+                if let Ok(out) = e.args() {
+                    let status = out.status;
+                    if status != GfxPower::Unknown {
+                        if let Ok(config) = notifs_enabled1.lock() {
+                            if config.all_enabled && config.receive_notify_gfx_status {
+                                // Required check because status cycles through active/unknown/suspended
+                                if let Ok(ref mut lock) = last_notif.lock() {
+                                    notify!(
+                                        do_gpu_status_notif("dGPU status changed:", &status),
+                                        lock
+                                    );
+                                }
                             }
                         }
-                        aura_notif.store(true, Ordering::SeqCst);
+                        if let Ok(mut lock) = page_states.lock() {
+                            lock.gfx_state.power_status = status;
+                            lock.set_notified();
+                        }
                     }
-                    future::ready(())
-                })
-                .await;
-            };
-        })
-        .detach();
-
-    let aura_notif = aura_notified.clone();
-    executor
-        .spawn(async move {
-            let conn = zbus::Connection::system().await.unwrap();
-            let proxy = LedProxy::new(&conn).await.unwrap();
-            if let Ok(p) = proxy.receive_notify_led().await {
-                p.for_each(|_| {
-                    aura_notif.store(true, Ordering::SeqCst);
-                    future::ready(())
-                })
-                .await;
-            };
-        })
-        .detach();
-
-    executor
-        .spawn(async move {
-            let conn = zbus::Connection::system().await.unwrap();
-            let proxy = LedProxy::new(&conn).await.unwrap();
-            if let Ok(p) = proxy.receive_all_signals().await {
-                p.for_each(|_| {
-                    aura_notified.store(true, Ordering::SeqCst);
-                    future::ready(())
-                })
-                .await;
-            };
-        })
-        .detach();
-
-    executor
-        .spawn(async move {
-            let conn = zbus::Connection::system().await.unwrap();
-            let proxy = AnimeProxy::new(&conn).await.unwrap();
-            if let Ok(p) = proxy.receive_power_states().await {
-                p.for_each(|_| {
-                    anime_notified.store(true, Ordering::SeqCst);
-                    future::ready(())
-                })
-                .await;
-            };
-        })
-        .detach();
-
-    spawn(move || loop {
-        smol::block_on(executor.tick());
+                }
+            }
+        };
     });
+
     Ok(())
 }
 
-fn do_thermal_notif(profile: &Profile) -> Result<NotificationHandle, Box<dyn Error>> {
+fn base_notification<T>(message: &str, data: &T) -> Notification
+where
+    T: Display,
+{
+    let mut notif = Notification::new();
+
+    notif
+        .summary(NOTIF_HEADER)
+        .body(&format!("{message} {data}"))
+        .timeout(2000)
+        //.hint(Hint::Resident(true))
+        .hint(Hint::Category("device".into()));
+
+    notif
+}
+
+fn do_notification<T>(message: &str, data: &T) -> Result<NotificationHandle>
+where
+    T: Display,
+{
+    Ok(base_notification(message, data).show()?)
+}
+
+fn ac_power_notification(message: &str, on: &bool) -> Result<NotificationHandle> {
+    let data = if *on {
+        "plugged".to_string()
+    } else {
+        "unplugged".to_string()
+    };
+    Ok(base_notification(message, &data).show()?)
+}
+
+fn do_thermal_notif(message: &str, profile: &Profile) -> Result<NotificationHandle> {
     let icon = match profile {
         Profile::Balanced => "asus_notif_yellow",
         Profile::Performance => "asus_notif_red",
         Profile::Quiet => "asus_notif_green",
     };
     let profile: &str = (*profile).into();
-    let x = Notification::new()
-        .summary("ASUS ROG")
-        .body(&format!(
-            "Thermal profile changed to {}",
-            profile.to_uppercase(),
-        ))
-        .hint(Hint::Resident(true))
-        .timeout(2000)
-        .hint(Hint::Category("device".into()))
-        //.hint(Hint::Transient(true))
-        .icon(icon)
-        .show()?;
-    Ok(x)
+    let mut notif = base_notification(message, &profile.to_uppercase());
+    Ok(notif.icon(icon).show()?)
 }
 
-fn do_led_notif(ledmode: &AuraEffect) -> Result<NotificationHandle, notify_rust::error::Error> {
-    base_notification!(&format!(
-        "Keyboard LED mode changed to {}",
-        ledmode.mode_name()
-    ))
+fn do_gpu_status_notif(message: &str, data: &GfxPower) -> Result<NotificationHandle> {
+    // eww
+    let mut notif = base_notification(message, &<&str>::from(data).to_string());
+    let icon = match data {
+        GfxPower::Active => "asus_notif_red",
+        GfxPower::Suspended => "asus_notif_blue",
+        GfxPower::Off => "asus_notif_green",
+        GfxPower::AsusDisabled => "asus_notif_white",
+        GfxPower::AsusMuxDiscreet => "asus_notif_red",
+        GfxPower::Unknown => "gpu-integrated",
+    };
+    notif.icon(icon);
+    Ok(Notification::show(&notif)?)
 }
 
-fn do_charge_notif(limit: &u8) -> Result<NotificationHandle, notify_rust::error::Error> {
-    base_notification!(&format!("Battery charge limit changed to {}", limit))
+fn do_gfx_action_notif<T>(message: &str, data: &T) -> Result<()>
+where
+    T: Display,
+{
+    let mut notif = base_notification(message, data);
+    notif.action("gnome-session-quit", "Logout");
+    notif.urgency(Urgency::Critical);
+    notif.timeout(3000);
+    notif.icon("dialog-warning");
+    notif.hint(Hint::Transient(true));
+    let handle = notif.show()?;
+    handle.wait_for_action(|id| {
+        if id == "gnome-session-quit" {
+            let mut cmd = Command::new("gnome-session-quit");
+            cmd.spawn().ok();
+        } else if id == "__closed" {
+            // TODO: cancel the switching
+        }
+    });
+    Ok(())
 }
 
-fn do_post_sound_notif(on: &bool) -> Result<NotificationHandle, notify_rust::error::Error> {
-    base_notification!(&format!("BIOS Post sound {}", on))
+/// Actual GpuMode unused as data is never correct until switched by reboot
+fn do_mux_notification(message: &str, _: &GpuMode) -> Result<NotificationHandle> {
+    let mut notif = base_notification(message, &"");
+    notif.urgency(Urgency::Critical);
+    notif.icon("system-reboot-symbolic");
+    notif.hint(Hint::Transient(true));
+    Ok(notif.show()?)
 }

rog-control-center/src/page_states.rs

@@ -1,24 +1,24 @@
 use std::{
     collections::{BTreeMap, HashSet},
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc,
-    },
+    sync::{Arc, Mutex},
 };
 
 use egui::Vec2;
 use rog_aura::{layouts::KeyLayout, usb::AuraPowerDev, AuraEffect, AuraModeNum};
 use rog_platform::{platform::GpuMode, supported::SupportedFunctions};
 use rog_profiles::{fan_curve_set::FanCurveSet, FanCurvePU, Profile};
+use supergfxctl::{
+    pci_device::{GfxMode, GfxPower},
+    zbus_proxy::DaemonProxyBlocking as GfxProxyBlocking,
+};
 
-use crate::{error::Result, RogDbusClientBlocking};
+use crate::{error::Result, notify::EnabledNotifications, RogDbusClientBlocking};
 
 #[derive(Clone, Debug)]
 pub struct BiosState {
     /// To be shared to a thread that checks notifications.
     /// It's a bit general in that it won't provide *what* was
     /// updated, so the full state needs refresh
-    pub was_notified: Arc<AtomicBool>,
     pub post_sound: bool,
     pub dedicated_gfx: GpuMode,
     pub panel_overdrive: bool,
@@ -27,13 +27,8 @@ pub struct BiosState {
 }
 
 impl BiosState {
-    pub fn new(
-        was_notified: Arc<AtomicBool>,
-        supported: &SupportedFunctions,
-        dbus: &RogDbusClientBlocking,
-    ) -> Result<Self> {
+    pub fn new(supported: &SupportedFunctions, dbus: &RogDbusClientBlocking) -> Result<Self> {
         Ok(Self {
-            was_notified,
             post_sound: if supported.rog_bios_ctrl.post_sound {
                 dbus.proxies().rog_bios().post_boot_sound()? != 0
             } else {
@@ -45,7 +40,7 @@ impl BiosState {
                 GpuMode::NotSupported
             },
             panel_overdrive: if supported.rog_bios_ctrl.panel_overdrive {
-                dbus.proxies().rog_bios().panel_overdrive()?
+                dbus.proxies().rog_bios().panel_od()?
             } else {
                 false
             },
@@ -58,19 +53,13 @@ impl BiosState {
 
 #[derive(Clone, Debug)]
 pub struct ProfilesState {
-    pub was_notified: Arc<AtomicBool>,
     pub list: Vec<Profile>,
     pub current: Profile,
 }
 
 impl ProfilesState {
-    pub fn new(
-        was_notified: Arc<AtomicBool>,
-        supported: &SupportedFunctions,
-        dbus: &RogDbusClientBlocking,
-    ) -> Result<Self> {
+    pub fn new(supported: &SupportedFunctions, dbus: &RogDbusClientBlocking) -> Result<Self> {
         Ok(Self {
-            was_notified,
             list: if supported.platform_profile.platform_profile {
                 let mut list = dbus.proxies().profile().profiles()?;
                 list.sort();
@@ -89,7 +78,6 @@ impl ProfilesState {
 
 #[derive(Clone, Debug)]
 pub struct FanCurvesState {
-    pub was_notified: Arc<AtomicBool>,
     pub show_curve: Profile,
     pub show_graph: FanCurvePU,
     pub enabled: HashSet<Profile>,
@@ -98,11 +86,7 @@ pub struct FanCurvesState {
 }
 
 impl FanCurvesState {
-    pub fn new(
-        was_notified: Arc<AtomicBool>,
-        supported: &SupportedFunctions,
-        dbus: &RogDbusClientBlocking,
-    ) -> Result<Self> {
+    pub fn new(supported: &SupportedFunctions, dbus: &RogDbusClientBlocking) -> Result<Self> {
         let profiles = if supported.platform_profile.platform_profile {
             dbus.proxies().profile().profiles()?
         } else {
@@ -143,7 +127,6 @@ impl FanCurvesState {
         };
 
         Ok(Self {
-            was_notified,
             show_curve,
             show_graph: FanCurvePU::CPU,
             enabled,
@@ -155,7 +138,6 @@ impl FanCurvesState {
 
 #[derive(Clone, Debug)]
 pub struct AuraState {
-    pub was_notified: Arc<AtomicBool>,
     pub current_mode: AuraModeNum,
     pub modes: BTreeMap<AuraModeNum, AuraEffect>,
     pub enabled: AuraPowerDev,
@@ -167,13 +149,8 @@ pub struct AuraState {
 }
 
 impl AuraState {
-    pub fn new(
-        was_notified: Arc<AtomicBool>,
-        supported: &SupportedFunctions,
-        dbus: &RogDbusClientBlocking,
-    ) -> Result<Self> {
+    pub fn new(supported: &SupportedFunctions, dbus: &RogDbusClientBlocking) -> Result<Self> {
         Ok(Self {
-            was_notified,
             current_mode: if !supported.keyboard_led.stock_led_modes.is_empty() {
                 dbus.proxies().led().led_mode().unwrap_or_default()
             } else {
@@ -214,7 +191,6 @@ impl AuraState {
 
 #[derive(Clone, Debug)]
 pub struct AnimeState {
-    pub was_notified: Arc<AtomicBool>,
     pub bright: u8,
     pub boot: bool,
     pub awake: bool,
@@ -222,13 +198,8 @@ pub struct AnimeState {
 }
 
 impl AnimeState {
-    pub fn new(
-        was_notified: Arc<AtomicBool>,
-        supported: &SupportedFunctions,
-        dbus: &RogDbusClientBlocking,
-    ) -> Result<Self> {
+    pub fn new(supported: &SupportedFunctions, dbus: &RogDbusClientBlocking) -> Result<Self> {
         Ok(Self {
-            was_notified,
             boot: if supported.anime_ctrl.0 {
                 dbus.proxies().anime().boot_enabled()?
             } else {
@@ -246,11 +217,39 @@ impl AnimeState {
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
+pub struct GfxState {
+    pub mode: GfxMode,
+    pub power_status: GfxPower,
+}
+
+impl GfxState {
+    pub fn new(_supported: &SupportedFunctions, dbus: &GfxProxyBlocking) -> Result<Self> {
+        Ok(Self {
+            mode: dbus.mode()?,
+            power_status: dbus.power()?,
+        })
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct PowerState {
+    pub charge_limit: u8,
+    pub ac_power: bool,
+}
+
+impl PowerState {
+    pub fn new(_supported: &SupportedFunctions, dbus: &RogDbusClientBlocking) -> Result<Self> {
+        Ok(Self {
+            charge_limit: dbus.proxies().charge().charge_control_end_threshold()?,
+            ac_power: dbus.proxies().charge().mains_online()?,
+        })
+    }
+}
+
 pub struct PageDataStates {
     pub keyboard_layout: KeyLayout,
-    pub notifs_enabled: Arc<AtomicBool>,
-    pub was_notified: Arc<AtomicBool>,
+    pub enabled_notifications: Arc<Mutex<EnabledNotifications>>,
     /// Because much of the app state here is the same as `RogBiosSupportedFunctions`
     /// we can re-use that structure.
     pub bios: BiosState,
@@ -258,86 +257,59 @@ pub struct PageDataStates {
     pub anime: AnimeState,
     pub profiles: ProfilesState,
     pub fan_curves: FanCurvesState,
-    pub charge_limit: i16,
+    pub gfx_state: GfxState,
+    pub power_state: PowerState,
     pub error: Option<String>,
+    /// Specific field for the tray only so that we can know when it does need update.
+    /// The tray should set this to false when done.
+    pub tray_should_update: bool,
+    pub app_should_update: bool,
+    pub asus_dbus: RogDbusClientBlocking<'static>,
+    pub gfx_dbus: GfxProxyBlocking<'static>,
 }
 
 impl PageDataStates {
+    /// Creates self, including the relevant dbus connections and proixies for internal use
     pub fn new(
         keyboard_layout: KeyLayout,
-        notifs_enabled: Arc<AtomicBool>,
-        charge_notified: Arc<AtomicBool>,
-        bios_notified: Arc<AtomicBool>,
-        aura_notified: Arc<AtomicBool>,
-        anime_notified: Arc<AtomicBool>,
-        profiles_notified: Arc<AtomicBool>,
-        fans_notified: Arc<AtomicBool>,
+        enabled_notifications: Arc<Mutex<EnabledNotifications>>,
         supported: &SupportedFunctions,
-        dbus: &RogDbusClientBlocking,
     ) -> Result<Self> {
+        let (asus_dbus, conn) = RogDbusClientBlocking::new().unwrap();
+        let gfx_dbus = GfxProxyBlocking::new(&conn).unwrap();
         Ok(Self {
             keyboard_layout,
-            notifs_enabled,
-            was_notified: charge_notified,
-            charge_limit: dbus.proxies().charge().limit()?,
-            bios: BiosState::new(bios_notified, supported, dbus)?,
-            aura: AuraState::new(aura_notified, supported, dbus)?,
-            anime: AnimeState::new(anime_notified, supported, dbus)?,
-            profiles: ProfilesState::new(profiles_notified, supported, dbus)?,
-            fan_curves: FanCurvesState::new(fans_notified, supported, dbus)?,
+            enabled_notifications,
+            power_state: PowerState::new(supported, &asus_dbus)?,
+            bios: BiosState::new(supported, &asus_dbus)?,
+            aura: AuraState::new(supported, &asus_dbus)?,
+            anime: AnimeState::new(supported, &asus_dbus)?,
+            profiles: ProfilesState::new(supported, &asus_dbus)?,
+            fan_curves: FanCurvesState::new(supported, &asus_dbus)?,
+            gfx_state: GfxState::new(supported, &gfx_dbus)?,
             error: None,
+            tray_should_update: true,
+            app_should_update: true,
+            asus_dbus,
+            gfx_dbus,
         })
     }
 
-    pub fn refresh_if_notfied(
-        &mut self,
-        supported: &SupportedFunctions,
-        dbus: &RogDbusClientBlocking,
-    ) -> Result<bool> {
-        let mut notified = false;
-        if self.was_notified.load(Ordering::SeqCst) {
-            self.charge_limit = dbus.proxies().charge().limit()?;
-            self.was_notified.store(false, Ordering::SeqCst);
-            notified = true;
-        }
-
-        if self.aura.was_notified.load(Ordering::SeqCst) {
-            self.aura = AuraState::new(self.aura.was_notified.clone(), supported, dbus)?;
-            self.aura.was_notified.store(false, Ordering::SeqCst);
-            notified = true;
-        }
-
-        if self.bios.was_notified.load(Ordering::SeqCst) {
-            self.bios = BiosState::new(self.bios.was_notified.clone(), supported, dbus)?;
-            self.bios.was_notified.store(false, Ordering::SeqCst);
-            notified = true;
-        }
-
-        if self.profiles.was_notified.load(Ordering::SeqCst) {
-            self.profiles =
-                ProfilesState::new(self.profiles.was_notified.clone(), supported, dbus)?;
-            self.profiles.was_notified.store(false, Ordering::SeqCst);
-            notified = true;
-        }
-
-        if self.fan_curves.was_notified.load(Ordering::SeqCst) {
-            self.fan_curves =
-                FanCurvesState::new(self.fan_curves.was_notified.clone(), supported, dbus)?;
-            self.fan_curves.was_notified.store(false, Ordering::SeqCst);
-            notified = true;
-        }
-        Ok(notified)
+    pub fn set_notified(&mut self) {
+        self.tray_should_update = true;
+        self.app_should_update = true;
     }
 }
 
 impl Default for PageDataStates {
     fn default() -> Self {
+        let (asus_dbus, conn) = RogDbusClientBlocking::new().unwrap();
+        let gfx_dbus = GfxProxyBlocking::new(&conn).unwrap();
+
         Self {
             keyboard_layout: KeyLayout::ga401_layout(),
-            notifs_enabled: Default::default(),
-            was_notified: Default::default(),
+            enabled_notifications: Default::default(),
             bios: BiosState {
-                was_notified: Default::default(),
                 post_sound: Default::default(),
                 dedicated_gfx: GpuMode::NotSupported,
                 panel_overdrive: Default::default(),
@@ -345,7 +317,6 @@ impl Default for PageDataStates {
                 egpu_enable: Default::default(),
             },
             aura: AuraState {
-                was_notified: Default::default(),
                 current_mode: AuraModeNum::Static,
                 modes: Default::default(),
                 enabled: AuraPowerDev {
@@ -359,27 +330,35 @@ impl Default for PageDataStates {
                 wave_blue: Default::default(),
             },
             anime: AnimeState {
-                was_notified: Default::default(),
                 bright: Default::default(),
                 boot: Default::default(),
                 awake: Default::default(),
                 sleep: Default::default(),
             },
             profiles: ProfilesState {
-                was_notified: Default::default(),
                 list: Default::default(),
                 current: Default::default(),
             },
             fan_curves: FanCurvesState {
-                was_notified: Default::default(),
                 show_curve: Default::default(),
                 show_graph: Default::default(),
                 enabled: Default::default(),
                 curves: Default::default(),
                 drag_delta: Default::default(),
             },
-            charge_limit: Default::default(),
+            gfx_state: GfxState {
+                mode: GfxMode::None,
+                power_status: GfxPower::Unknown,
+            },
+            power_state: PowerState {
+                charge_limit: 99,
+                ac_power: false,
+            },
             error: Default::default(),
+            tray_should_update: true,
+            app_should_update: true,
+            asus_dbus,
+            gfx_dbus,
         }
     }
 }

rog-control-center/src/pages/anime_page.rs

@@ -1,6 +1,6 @@
 use crate::RogApp;
 
-impl<'a> RogApp<'a> {
+impl RogApp {
     pub fn anime_page(&mut self, ctx: &egui::Context) {
         egui::CentralPanel::default().show(ctx, |ui| {
             ui.label("In progress");

rog-control-center/src/pages/aura_page.rs

@@ -4,16 +4,15 @@ use egui::Color32;
 use rog_aura::{AuraEffect, AuraModeNum};
 
 use crate::{
+    page_states::PageDataStates,
     widgets::{aura_modes_group, keyboard},
     RogApp,
 };
 
-impl<'a> RogApp<'a> {
-    pub fn aura_page(&mut self, ctx: &egui::Context) {
+impl RogApp {
+    pub fn aura_page(&mut self, states: &mut PageDataStates, ctx: &egui::Context) {
         let Self {
             supported,
-            states,
-            asus_dbus: dbus,
             oscillator1,
             oscillator2,
             oscillator3,
@@ -26,7 +25,6 @@ impl<'a> RogApp<'a> {
         let blue = oscillator3.load(Ordering::SeqCst) as u32;
         states.aura.nudge_wave(red as u8, green as u8, blue as u8);
         // let osc = c.0 * 255 / osc;
-        // dbg!(osc);
         let c1 = states
             .aura
             .modes
@@ -72,7 +70,7 @@ impl<'a> RogApp<'a> {
 
         // TODO: animation of colour changes/periods/blending
         egui::CentralPanel::default().show(ctx, |ui| {
-            aura_modes_group(supported, states, oscillator_freq, dbus, ui);
+            aura_modes_group(supported, states, oscillator_freq, ui);
 
             keyboard(ui, &states.keyboard_layout, &mut states.aura, colour);
         });

rog-control-center/src/pages/fan_curve_page.rs

@@ -1,5 +1,5 @@
 use crate::{
-    page_states::{FanCurvesState, ProfilesState},
+    page_states::{FanCurvesState, PageDataStates, ProfilesState},
     widgets::fan_graphs,
     RogApp, RogDbusClientBlocking,
 };
@@ -7,14 +7,9 @@ use egui::Ui;
 use rog_platform::supported::SupportedFunctions;
 use rog_profiles::Profile;
 
-impl<'a> RogApp<'a> {
-    pub fn fan_curve_page(&mut self, ctx: &egui::Context) {
-        let Self {
-            supported,
-            states,
-            asus_dbus: dbus,
-            ..
-        } = self;
+impl RogApp {
+    pub fn fan_curve_page(&mut self, states: &mut PageDataStates, ctx: &egui::Context) {
+        let Self { supported, .. } = self;
 
         egui::CentralPanel::default().show(ctx, |ui| {
             ui.heading("Custom fan curves");
@@ -23,11 +18,11 @@ impl<'a> RogApp<'a> {
                 supported,
                 &mut states.profiles,
                 &mut states.fan_curves,
-                dbus, &mut states.error,
+                &states.asus_dbus, &mut states.error,
                 ui,
             );
 
-            fan_graphs(supported, &mut states.profiles, &mut states.fan_curves, dbus, &mut states.error, ui);
+            fan_graphs(supported, &mut states.profiles, &mut states.fan_curves, &states.asus_dbus, &mut states.error, ui);
         });
     }
 
@@ -76,8 +71,7 @@ impl<'a> RogApp<'a> {
             let selected_profile = curves.show_curve;
             let selected_pu = curves.show_graph;
 
-            let notif = curves.was_notified.clone();
-            match FanCurvesState::new(notif, supported, dbus) {
+            match FanCurvesState::new(supported, dbus) {
                 Ok(f) => *curves = f,
                 Err(e) => *do_error = Some(e.to_string()),
             }

rog-control-center/src/pages/system_page.rs

@@ -1,22 +1,19 @@
 use crate::{
+    page_states::PageDataStates,
     widgets::{
         anime_power_group, app_settings, aura_power_group, platform_profile, rog_bios_group,
     },
     RogApp,
 };
 
-impl<'a> RogApp<'a> {
-    pub fn system_page(&mut self, ctx: &egui::Context) {
+impl RogApp {
+    pub fn system_page(&mut self, states: &mut PageDataStates, ctx: &egui::Context) {
         let Self {
-            config,
-            supported,
-            states,
-            asus_dbus: dbus,
-            ..
+            config, supported, ..
         } = self;
 
         egui::CentralPanel::default().show(ctx, |ui| {
-            ui.heading("Experimental application for asusd");
+            ui.heading("Base settings");
 
             egui::ScrollArea::vertical().show(ui, |ui| {
                 ui.spacing_mut().item_spacing = egui::vec2(8.0, 10.0);
@@ -27,26 +24,24 @@ impl<'a> RogApp<'a> {
                         /******************************************************/
                         ui.vertical(|ui| {
                             ui.separator();
-                            app_settings(config, states, ui);
+                            if supported.platform_profile.platform_profile {
+                                platform_profile(states, ui);
+                            }
                         });
-
                         ui.vertical(|ui| {
                             ui.separator();
-                            if supported.platform_profile.platform_profile {
-                                platform_profile(states, dbus, ui);
-                            }
+                            aura_power_group(supported, states, ui);
                         });
                         ui.end_row();
 
                         /******************************************************/
                         ui.vertical(|ui| {
                             ui.separator();
-                            aura_power_group(supported, states, dbus, ui);
+                            app_settings(config, states, ui);
                         });
-
                         ui.vertical(|ui| {
                             ui.separator();
-                            rog_bios_group(supported, states, dbus, ui);
+                            rog_bios_group(supported, states, ui);
                         });
                         ui.end_row();
 
@@ -54,7 +49,7 @@ impl<'a> RogApp<'a> {
                         ui.vertical(|ui| {
                             ui.separator();
                             if supported.anime_ctrl.0 {
-                                anime_power_group(supported, states, dbus, ui);
+                                anime_power_group(supported, states, ui);
                             }
                         });
                         ui.vertical(|ui| {

rog-control-center/src/startup_error.rs

@@ -27,7 +27,7 @@ impl eframe::App for AppErrorShow {
                             .add(Button::new(RichText::new("Okay").size(20.0)))
                             .clicked()
                         {
-                            frame.quit();
+                            frame.close();
                         }
                     });
                 });

rog-control-center/src/tray.rs

@@ -0,0 +1,330 @@
+//! A seld-contained tray icon with menus. The control of app<->tray is done via
+//! commands over an MPSC channel.
+
+use std::{
+    io::Write,
+    sync::{
+        mpsc::{channel, Receiver},
+        Arc, Mutex,
+    },
+    time::Duration,
+};
+
+use gtk::{gio::Icon, prelude::*};
+use rog_dbus::zbus_platform::RogBiosProxyBlocking;
+use rog_platform::{platform::GpuMode, supported::SupportedFunctions};
+
+use crate::{error::Result, get_ipc_file, page_states::PageDataStates, SHOW_GUI};
+use libappindicator::{AppIndicator, AppIndicatorStatus};
+use supergfxctl::{
+    pci_device::{GfxMode, GfxPower},
+    zbus_proxy::DaemonProxyBlocking as GfxProxyBlocking,
+};
+
+use log::trace;
+
+const TRAY_APP_ICON: &str = "rog-control-center";
+const TRAY_LABEL: &str = "ROG Control Center";
+
+pub enum AppToTray {
+    DgpuStatus(GfxPower),
+}
+
+pub enum TrayToApp {
+    Open,
+    Quit,
+}
+
+pub struct RadioGroup(Vec<gtk::RadioMenuItem>);
+
+impl RadioGroup {
+    /// Add new radio menu item. `set_no_show_all()` is true until added to menu
+    /// to prevent teh callback from running
+    pub fn new<F>(first_label: &str, cb: F) -> Self
+    where
+        F: Fn(&gtk::RadioMenuItem) + Send + 'static,
+    {
+        let item = gtk::RadioMenuItem::with_label(first_label);
+        item.set_active(false);
+        item.set_no_show_all(true);
+        item.connect_activate(move |this| {
+            if this.is_active() && !this.is_no_show_all() {
+                cb(this);
+            }
+        });
+        Self(vec![item])
+    }
+
+    /// Add new radio menu item. `set_no_show_all()` is true until added to menu
+    /// to prevent teh callback from running
+    pub fn add<F>(&mut self, label: &str, cb: F)
+    where
+        F: Fn(&gtk::RadioMenuItem) + Send + 'static,
+    {
+        debug_assert!(!self.0.is_empty());
+        let group = self.0[0].group();
+
+        let item = gtk::RadioMenuItem::with_label_from_widget(&group[0], Some(label));
+        item.set_active(false);
+        item.set_no_show_all(true);
+        item.connect_activate(move |this| {
+            if this.is_active() && !this.is_no_show_all() {
+                cb(this);
+            }
+        });
+        self.0.push(item);
+    }
+}
+
+pub struct ROGTray {
+    tray: AppIndicator,
+    menu: gtk::Menu,
+    icon: &'static str,
+    bios_proxy: RogBiosProxyBlocking<'static>,
+    gfx_proxy: GfxProxyBlocking<'static>,
+}
+
+impl ROGTray {
+    pub fn new() -> Result<Self> {
+        let conn = zbus::blocking::Connection::system().unwrap();
+        let rog_tray = Self {
+            tray: AppIndicator::new(TRAY_LABEL, TRAY_APP_ICON),
+            menu: gtk::Menu::new(),
+            icon: TRAY_APP_ICON,
+            bios_proxy: RogBiosProxyBlocking::new(&conn).unwrap(),
+            gfx_proxy: GfxProxyBlocking::new(&conn).unwrap(),
+        };
+        Ok(rog_tray)
+    }
+
+    pub fn set_icon(&mut self, icon: &'static str) {
+        self.icon = icon;
+        self.tray.set_icon(self.icon);
+        self.tray.set_status(AppIndicatorStatus::Active);
+    }
+
+    /// Add a non-interactive label
+    fn add_inactive_label(&mut self, label: &str) {
+        let item = gtk::MenuItem::with_label(label);
+        item.set_sensitive(false);
+        self.menu.append(&item);
+        self.menu.show_all();
+    }
+
+    /// Add a separator
+    fn add_separator(&mut self) {
+        let item = gtk::SeparatorMenuItem::new();
+        item.set_sensitive(false);
+        self.menu.append(&item);
+        self.menu.show_all();
+    }
+
+    fn add_radio_sub_menu(&mut self, header_label: &str, active_label: &str, sub_menu: RadioGroup) {
+        let header_item = gtk::MenuItem::with_label(header_label);
+        header_item.show_all();
+        self.menu.add(&header_item);
+
+        let menu = gtk::Menu::new();
+        for item in sub_menu.0.iter() {
+            item.set_active(item.label().unwrap() == active_label);
+            item.set_no_show_all(false);
+            item.show_all();
+            menu.add(item);
+        }
+        menu.show_all();
+        header_item.set_submenu(Some(&menu));
+    }
+
+    fn add_menu_item<F>(&mut self, label: &str, cb: F)
+    where
+        F: Fn() + Send + 'static,
+    {
+        let item = gtk::MenuItem::with_label(label);
+        item.connect_activate(move |_| {
+            cb();
+        });
+        self.menu.append(&item);
+        self.menu.show_all();
+    }
+
+    fn add_check_menu_item<F>(&mut self, label: &str, is_active: bool, cb: F)
+    where
+        F: Fn(&gtk::CheckMenuItem) + Send + 'static,
+    {
+        let item = gtk::CheckMenuItem::with_label(label);
+        item.set_active(is_active);
+        item.connect_activate(move |this| {
+            cb(this);
+        });
+        self.menu.append(&item);
+        self.menu.show_all();
+    }
+
+    /// Add a menu item with an icon to the right
+    fn add_icon_menu_item<F>(&mut self, label: &str, icon: &str, cb: F)
+    where
+        F: Fn() + Send + 'static,
+    {
+        let g_box = gtk::Box::new(gtk::Orientation::Horizontal, 6);
+        let icon = gtk::Image::from_gicon(&Icon::for_string(icon).unwrap(), gtk::IconSize::Menu);
+        let label = gtk::Label::new(Some(label));
+        let item = gtk::MenuItem::new();
+        g_box.add(&icon);
+        g_box.add(&label);
+
+        item.add(&g_box);
+        item.show_all();
+
+        item.connect_activate(move |_| {
+            cb();
+        });
+        self.menu.append(&item);
+        self.menu.show_all();
+        self.tray.set_menu(&mut self.menu);
+    }
+
+    fn set_status(&mut self, status: AppIndicatorStatus) {
+        self.tray.set_status(status)
+    }
+
+    fn menu_add_base(&mut self) {
+        self.add_icon_menu_item("Open app", "asus_notif_red", move || {
+            get_ipc_file().unwrap().write_all(&[SHOW_GUI]).ok();
+        });
+
+        self.add_separator();
+    }
+
+    fn menu_add_charge_limit(&mut self, limit: u8) {
+        self.add_inactive_label(&format!("Charge limit: {limit}"));
+    }
+
+    fn menu_add_panel_od(&mut self, panel_od: bool) {
+        let bios = self.bios_proxy.clone();
+        self.add_check_menu_item("Panel Overdrive", panel_od, move |this| {
+            bios.set_panel_od(this.is_active()).unwrap();
+        });
+    }
+
+    fn menu_add_gpu(&mut self, supported: &SupportedFunctions, current_mode: GfxMode) {
+        let gfx_dbus = self.gfx_proxy.clone();
+        let mut gpu_menu = RadioGroup::new("Integrated", move |_| {
+            let mode = gfx_dbus.mode().unwrap();
+            if mode != GfxMode::Integrated {
+                gfx_dbus.set_mode(&GfxMode::Integrated).unwrap();
+            }
+        });
+
+        let gfx_dbus = self.gfx_proxy.clone();
+        gpu_menu.add("Hybrid", move |_| {
+            let mode = gfx_dbus.mode().unwrap();
+            if mode != GfxMode::Hybrid {
+                gfx_dbus.set_mode(&GfxMode::Hybrid).unwrap();
+            }
+        });
+        if supported.rog_bios_ctrl.gpu_mux {
+            let gfx_dbus = self.bios_proxy.clone();
+            gpu_menu.add("Ultimate (Reboot required)", move |_| {
+                let mode = gfx_dbus.gpu_mux_mode().unwrap();
+                if mode != GpuMode::Discrete {
+                    gfx_dbus.set_gpu_mux_mode(GpuMode::Discrete).unwrap();
+                }
+            });
+        }
+        if supported.rog_bios_ctrl.egpu_enable {
+            let gfx_dbus = self.gfx_proxy.clone();
+            gpu_menu.add("eGPU", move |_| {
+                let mode = gfx_dbus.mode().unwrap();
+                if mode != GfxMode::Egpu {
+                    gfx_dbus.set_mode(&GfxMode::Egpu).unwrap();
+                }
+            });
+        }
+
+        let active = match current_mode {
+            GfxMode::AsusMuxDiscreet => "Discreet".to_string(),
+            _ => current_mode.to_string(),
+        };
+        self.add_radio_sub_menu(
+            &format!("GPU Mode: {current_mode}"),
+            active.as_str(),
+            gpu_menu,
+        );
+    }
+
+    fn menu_clear(&mut self) {
+        self.menu = gtk::Menu::new();
+    }
+
+    /// Reset GTK menu to internal state, this can be called after clearing and rebuilding the menu too.
+    fn menu_update(&mut self) {
+        self.tray.set_menu(&mut self.menu);
+        self.set_icon(self.icon);
+    }
+
+    /// Do a flush, build, and update of the tray menu
+    fn rebuild_and_update(
+        &mut self,
+        supported: &SupportedFunctions,
+        current_gfx_mode: GfxMode,
+        charge_limit: u8,
+        panel_od: bool,
+    ) {
+        self.menu_clear();
+        self.menu_add_base();
+        self.menu_add_charge_limit(charge_limit);
+        self.menu_add_panel_od(panel_od);
+        self.menu_add_gpu(supported, current_gfx_mode);
+        self.menu_update();
+    }
+}
+
+pub fn init_tray(
+    supported: SupportedFunctions,
+    states: Arc<Mutex<PageDataStates>>,
+) -> Receiver<TrayToApp> {
+    let (send, recv) = channel();
+    let _send = Arc::new(Mutex::new(send));
+
+    std::thread::spawn(move || {
+        gtk::init().unwrap(); // Make this the main thread for gtk
+
+        let mut tray = ROGTray::new().unwrap();
+        tray.rebuild_and_update(&supported, GfxMode::Hybrid, 100, false);
+        tray.set_icon(TRAY_APP_ICON);
+
+        loop {
+            if let Ok(mut lock) = states.lock() {
+                if lock.tray_should_update {
+                    tray.rebuild_and_update(
+                        &supported,
+                        lock.gfx_state.mode,
+                        lock.power_state.charge_limit,
+                        lock.bios.panel_overdrive,
+                    );
+                    lock.tray_should_update = false;
+
+                    match lock.gfx_state.power_status {
+                        GfxPower::Active => tray.set_icon("asus_notif_red"),
+                        GfxPower::Suspended => tray.set_icon("asus_notif_blue"),
+                        GfxPower::Off => tray.set_icon("asus_notif_green"),
+                        GfxPower::AsusDisabled => tray.set_icon("asus_notif_white"),
+                        GfxPower::AsusMuxDiscreet => tray.set_icon("asus_notif_red"),
+                        GfxPower::Unknown => tray.set_icon("gpu-integrated"),
+                    };
+                }
+            }
+
+            if gtk::events_pending() {
+                // This is blocking until any events are available
+                gtk::main_iteration();
+                continue;
+            }
+            // Don't spool at max speed if no gtk events
+            std::thread::sleep(Duration::from_millis(300));
+            trace!("Tray loop ticked");
+        }
+    });
+
+    recv
+}

rog-control-center/src/widgets/anime_power.rs

@@ -1,12 +1,11 @@
 use egui::{RichText, Ui};
 use rog_platform::supported::SupportedFunctions;
 
-use crate::{page_states::PageDataStates, RogDbusClientBlocking};
+use crate::page_states::PageDataStates;
 
 pub fn anime_power_group(
     _supported: &SupportedFunctions,
     states: &mut PageDataStates,
-    dbus: &mut RogDbusClientBlocking,
     ui: &mut Ui,
 ) {
     ui.heading("AniMe Matrix Settings");
@@ -43,7 +42,9 @@ pub fn anime_power_group(
             });
             ui.horizontal_wrapped(|ui| {
                 if ui.checkbox(&mut states.anime.boot, "Enable").changed() {
-                    dbus.proxies()
+                    states
+                        .asus_dbus
+                        .proxies()
                         .anime()
                         .set_boot_on_off(states.anime.boot)
                         .map_err(|err| {
@@ -54,7 +55,9 @@ pub fn anime_power_group(
             });
             ui.horizontal_wrapped(|ui| {
                 if ui.checkbox(&mut states.anime.awake, "Enable").changed() {
-                    dbus.proxies()
+                    states
+                        .asus_dbus
+                        .proxies()
                         .anime()
                         .set_on_off(states.anime.awake)
                         .map_err(|err| {

rog-control-center/src/widgets/app_settings.rs

@@ -1,5 +1,3 @@
-use std::sync::atomic::Ordering;
-
 use egui::Ui;
 
 use crate::{config::Config, page_states::PageDataStates};
@@ -8,6 +6,12 @@ pub fn app_settings(config: &mut Config, states: &mut PageDataStates, ui: &mut U
     ui.heading("ROG GUI Settings");
     // ui.label("Options are incomplete. Awake + Boot should work");
 
+    let mut enabled_notifications = if let Ok(lock) = states.enabled_notifications.lock() {
+        lock.clone()
+    } else {
+        Default::default()
+    };
+
     if ui
         .checkbox(&mut config.run_in_background, "Run in Background")
         .clicked()
@@ -15,17 +19,70 @@ pub fn app_settings(config: &mut Config, states: &mut PageDataStates, ui: &mut U
             .checkbox(&mut config.startup_in_background, "Startup Hidden")
             .clicked()
         || ui
-            .checkbox(&mut config.enable_notifications, "Enable Notifications")
+            .checkbox(
+                &mut enabled_notifications.all_enabled,
+                "Enable Notifications",
+            )
+            .clicked()
+        || ui
+            .checkbox(
+                &mut enabled_notifications.receive_notify_gfx_status,
+                "Enable dGPU status notification",
+            )
+            .clicked()
+        || ui
+            .checkbox(
+                &mut enabled_notifications.receive_notify_dgpu_disable,
+                "Enable dGPU disablement notification",
+            )
+            .clicked()
+        || ui
+            .checkbox(
+                &mut enabled_notifications.receive_notify_egpu_enable,
+                "Enable eGPU enablement notification",
+            )
+            .clicked()
+        || ui
+            .checkbox(
+                &mut enabled_notifications.receive_notify_mains_online,
+                "Enable mains (AC) power notification",
+            )
+            .clicked()
+        || ui
+            .checkbox(
+                &mut enabled_notifications.receive_notify_charge_control_end_threshold,
+                "Enable charge threshold notification",
+            )
+            .clicked()
+        || ui
+            .checkbox(
+                &mut enabled_notifications.receive_notify_profile,
+                "Enable profile change notification",
+            )
+            .clicked()
+        || ui
+            .checkbox(
+                &mut enabled_notifications.receive_notify_panel_od,
+                "Enable panel overdrive notification",
+            )
+            .clicked()
+        || ui
+            .checkbox(
+                &mut enabled_notifications.receive_notify_post_boot_sound,
+                "Enable BIOS post sound notification",
+            )
             .clicked()
     {
-        states
-            .notifs_enabled
-            .store(config.enable_notifications, Ordering::SeqCst);
-        config
-            .save()
-            .map_err(|err| {
-                states.error = Some(err.to_string());
-            })
-            .ok();
+        if let Ok(mut lock) = states.enabled_notifications.lock() {
+            // Replace inner content before save
+            *lock = enabled_notifications;
+
+            config
+                .save(&lock)
+                .map_err(|err| {
+                    states.error = Some(err.to_string());
+                })
+                .ok();
+        }
     }
 }

rog-control-center/src/widgets/aura_modes.rs

@@ -7,16 +7,12 @@ use egui::{RichText, Ui};
 use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour, Speed};
 use rog_platform::supported::SupportedFunctions;
 
-use crate::{
-    page_states::{AuraState, PageDataStates},
-    RogDbusClientBlocking,
-};
+use crate::page_states::{AuraState, PageDataStates};
 
 pub fn aura_modes_group(
     supported: &SupportedFunctions,
     states: &mut PageDataStates,
     freq: &mut Arc<AtomicU8>,
-    dbus: &mut RogDbusClientBlocking,
     ui: &mut Ui,
 ) {
     let mut changed = false;
@@ -172,8 +168,7 @@ pub fn aura_modes_group(
     ui.separator();
     ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
         if ui.add(egui::Button::new("Cancel")).clicked() {
-            let notif = states.aura.was_notified.clone();
-            match AuraState::new(notif, supported, dbus) {
+            match AuraState::new(supported, &states.asus_dbus) {
                 Ok(a) => states.aura.modes = a.modes,
                 Err(e) => states.error = Some(e.to_string()),
             }
@@ -202,7 +197,9 @@ pub fn aura_modes_group(
     if changed {
         states.aura.current_mode = selected;
 
-        dbus.proxies()
+        states
+            .asus_dbus
+            .proxies()
             .led()
             .set_led_mode(states.aura.modes.get(&selected).unwrap())
             .map_err(|err| {

rog-control-center/src/widgets/aura_power.rs

@@ -5,32 +5,22 @@ use rog_aura::{
 };
 use rog_platform::supported::SupportedFunctions;
 
-use crate::{page_states::PageDataStates, RogDbusClientBlocking};
+use crate::page_states::PageDataStates;
 
-pub fn aura_power_group(
-    supported: &SupportedFunctions,
-    states: &mut PageDataStates,
-    dbus: &mut RogDbusClientBlocking,
-    ui: &mut Ui,
-) {
+pub fn aura_power_group(supported: &SupportedFunctions, states: &mut PageDataStates, ui: &mut Ui) {
     ui.heading("LED settings");
 
     match supported.keyboard_led.prod_id {
         AuraDevice::X1854 | AuraDevice::X1869 | AuraDevice::X1866 => {
-            aura_power1(supported, states, dbus, ui)
+            aura_power1(supported, states, ui)
         }
-        AuraDevice::X19B6 => aura_power2(supported, states, dbus, ui),
-        AuraDevice::Tuf => aura_power1(supported, states, dbus, ui),
+        AuraDevice::X19B6 => aura_power2(supported, states, ui),
+        AuraDevice::Tuf => aura_power1(supported, states, ui),
         AuraDevice::Unknown => {}
     }
 }
 
-fn aura_power1(
-    supported: &SupportedFunctions,
-    states: &mut PageDataStates,
-    dbus: &mut RogDbusClientBlocking,
-    ui: &mut Ui,
-) {
+fn aura_power1(supported: &SupportedFunctions, states: &mut PageDataStates, ui: &mut Ui) {
     let enabled_states = &mut states.aura.enabled;
     let mut boot = enabled_states.x1866.contains(&AuraDev1866::Boot);
     let mut sleep = enabled_states.x1866.contains(&AuraDev1866::Sleep);
@@ -73,10 +63,10 @@ fn aura_power1(
                 if ui.toggle_value(&mut keyboard, "Keyboard").changed() {
                     changed = true;
                 }
-                if !supported.keyboard_led.multizone_led_mode.is_empty() {
-                    if ui.toggle_value(&mut lightbar, "Lightbar").changed() {
-                        changed = true;
-                    }
+                if !supported.keyboard_led.multizone_led_mode.is_empty()
+                    && ui.toggle_value(&mut lightbar, "Lightbar").changed()
+                {
+                    changed = true;
                 }
             });
             ui.horizontal_wrapped(|ui| {
@@ -144,7 +134,9 @@ fn aura_power1(
                     x19b6: vec![],
                 };
                 // build data to send
-                dbus.proxies()
+                states
+                    .asus_dbus
+                    .proxies()
                     .led()
                     .set_leds_power(options, enable)
                     .map_err(|err| {
@@ -193,7 +185,9 @@ fn aura_power1(
                     x19b6: vec![],
                 };
                 // build data to send
-                dbus.proxies()
+                states
+                    .asus_dbus
+                    .proxies()
                     .led()
                     .set_leds_power(options, enable)
                     .map_err(|err| {
@@ -207,12 +201,7 @@ fn aura_power1(
     }
 }
 
-fn aura_power2(
-    supported: &SupportedFunctions,
-    states: &mut PageDataStates,
-    dbus: &mut RogDbusClientBlocking,
-    ui: &mut Ui,
-) {
+fn aura_power2(supported: &SupportedFunctions, states: &mut PageDataStates, ui: &mut Ui) {
     let enabled_states = &mut states.aura.enabled;
     let has_logo = supported
         .keyboard_led
@@ -331,7 +320,9 @@ fn aura_power2(
                 x19b6: data,
             };
             // build data to send
-            dbus.proxies()
+            states
+                .asus_dbus
+                .proxies()
                 .led()
                 .set_leds_power(options, enable)
                 .map_err(|err| {

rog-control-center/src/widgets/fan_graph.rs

@@ -136,8 +136,7 @@ pub fn fan_graphs(
             })
             .ok();
 
-        let notif = curves.was_notified.clone();
-        match FanCurvesState::new(notif, supported, dbus) {
+        match FanCurvesState::new(supported, dbus) {
             Ok(f) => *curves = f,
             Err(e) => *do_error = Some(e.to_string()),
         }

rog-control-center/src/widgets/rog_bios.rs

@@ -1,9 +1,9 @@
-use crate::{page_states::PageDataStates, RogDbusClientBlocking};
+use crate::page_states::PageDataStates;
 use egui::Ui;
 use rog_platform::{platform::GpuMode, supported::SupportedFunctions};
 use rog_profiles::Profile;
 
-pub fn platform_profile(states: &mut PageDataStates, dbus: &RogDbusClientBlocking, ui: &mut Ui) {
+pub fn platform_profile(states: &mut PageDataStates, ui: &mut Ui) {
     ui.heading("Platform profile");
 
     let mut changed = false;
@@ -23,7 +23,9 @@ pub fn platform_profile(states: &mut PageDataStates, dbus: &RogDbusClientBlockin
     });
 
     if changed {
-        dbus.proxies()
+        states
+            .asus_dbus
+            .proxies()
             .profile()
             .set_active_profile(states.profiles.current)
             .map_err(|err| {
@@ -33,68 +35,68 @@ pub fn platform_profile(states: &mut PageDataStates, dbus: &RogDbusClientBlockin
     };
 }
 
-pub fn rog_bios_group(
-    supported: &SupportedFunctions,
-    states: &mut PageDataStates,
-    dbus: &mut RogDbusClientBlocking,
-    ui: &mut Ui,
-) {
+pub fn rog_bios_group(supported: &SupportedFunctions, states: &mut PageDataStates, ui: &mut Ui) {
     ui.heading("Bios options");
 
-    let slider = egui::Slider::new(&mut states.charge_limit, 20..=100)
+    let slider = egui::Slider::new(&mut states.power_state.charge_limit, 20..=100)
         .text("Charging limit")
         .step_by(1.0);
     if ui.add(slider).drag_released() {
-        dbus.proxies()
+        states
+            .asus_dbus
+            .proxies()
             .charge()
-            .set_limit(states.charge_limit as u8)
+            .set_charge_control_end_threshold(states.power_state.charge_limit as u8)
             .map_err(|err| {
                 states.error = Some(err.to_string());
             })
             .ok();
     }
 
-    if supported.rog_bios_ctrl.post_sound {
-        if ui
+    if supported.rog_bios_ctrl.post_sound
+        && ui
             .add(egui::Checkbox::new(
                 &mut states.bios.post_sound,
                 "POST sound",
             ))
             .changed()
-        {
-            dbus.proxies()
-                .rog_bios()
-                .set_post_boot_sound(states.bios.post_sound)
-                .map_err(|err| {
-                    states.error = Some(err.to_string());
-                })
-                .ok();
-        }
+    {
+        states
+            .asus_dbus
+            .proxies()
+            .rog_bios()
+            .set_post_boot_sound(states.bios.post_sound)
+            .map_err(|err| {
+                states.error = Some(err.to_string());
+            })
+            .ok();
     }
 
-    if supported.rog_bios_ctrl.post_sound {
-        if ui
+    if supported.rog_bios_ctrl.post_sound
+        && ui
             .add(egui::Checkbox::new(
                 &mut states.bios.panel_overdrive,
                 "Panel overdrive",
             ))
             .changed()
-        {
-            dbus.proxies()
-                .rog_bios()
-                .set_panel_overdrive(states.bios.panel_overdrive)
-                .map_err(|err| {
-                    states.error = Some(err.to_string());
-                })
-                .ok();
-        }
+    {
+        states
+            .asus_dbus
+            .proxies()
+            .rog_bios()
+            .set_panel_od(states.bios.panel_overdrive)
+            .map_err(|err| {
+                states.error = Some(err.to_string());
+            })
+            .ok();
     }
 
     if supported.rog_bios_ctrl.gpu_mux {
         let mut changed = false;
         ui.group(|ui| {
             ui.vertical(|ui| {
-                ui.horizontal_wrapped(|ui| ui.label("GPU MUX mode (reboot required)"));
+                ui.horizontal_wrapped(|ui| ui.label("GPU MUX mode"));
+                ui.horizontal_wrapped(|ui| ui.label("NOTE: Value does not change until rebooted"));
                 ui.horizontal_wrapped(|ui| {
                     changed = ui
                         .selectable_value(
@@ -115,7 +117,9 @@ pub fn rog_bios_group(
         });
 
         if changed {
-            dbus.proxies()
+            states
+                .asus_dbus
+                .proxies()
                 .rog_bios()
                 .set_gpu_mux_mode(states.bios.dedicated_gfx)
                 .map_err(|err| {

rog-control-center/src/widgets/side_panel.rs

@@ -1,6 +1,6 @@
 use crate::{Page, RogApp};
 
-impl<'a> RogApp<'a> {
+impl RogApp {
     pub fn side_panel(&mut self, ctx: &egui::Context) {
         egui::SidePanel::left("side_panel")
             .resizable(false)

rog-control-center/src/widgets/top_bar.rs

@@ -1,8 +1,8 @@
-use egui::{vec2, Align2, Button, FontId, Id, Rect, RichText, Sense, Vec2};
+use egui::{vec2, Align2, FontId, Id, Sense};
 
 use crate::{RogApp, VERSION};
 
-impl<'a> RogApp<'a> {
+impl RogApp {
     pub fn top_bar(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
         egui::TopBottomPanel::top("top_panel").show(ctx, |ui| {
             // The top panel is often a good place for a menu bar:
@@ -27,20 +27,20 @@ impl<'a> RogApp<'a> {
                 let height = titlebar_rect.height();
                 // Paint the title:
                 ui.painter().text(
-                    titlebar_rect.center_top() + vec2(0.0, height / 2.0),
-                    Align2::CENTER_CENTER,
-                    format!("ROG Control Center v{}", VERSION),
+                    titlebar_rect.right_top() + vec2(0.0, height / 2.0),
+                    Align2::RIGHT_CENTER,
+                    format!("v{}", VERSION),
                     FontId::proportional(height - 2.0),
                     text_color,
                 );
-                // Add the close button:
-                let close_response = ui.put(
-                    Rect::from_min_size(titlebar_rect.right_top(), Vec2::splat(height)),
-                    Button::new(RichText::new("❌").size(height - 4.0)).frame(false),
-                );
-                if close_response.clicked() {
-                    frame.quit();
-                }
+                // // Add the close button:
+                // let close_response = ui.put(
+                //     Rect::from_min_size(titlebar_rect.right_top(), Vec2::splat(height)),
+                //     Button::new(RichText::new("❌").size(height - 4.0)).frame(false),
+                // );
+                // if close_response.clicked() {
+                //     frame.close();
+                // }
             });
         });
     }

rog-dbus/Cargo.toml

@@ -1,19 +1,19 @@
 [package]
 name = "rog_dbus"
-version = "4.4.0"
+version.workspace = true
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
 repository = "https://gitlab.com/asus-linux/asus-nb-ctrl"
 homepage = "https://gitlab.com/asus-linux/asus-nb-ctrl"
 description = "dbus interface methods for asusctl"
-edition = "2018"
+edition = "2021"
 
 [dependencies]
 rog_anime = { path = "../rog-anime" }
 rog_aura = { path = "../rog-aura" }
 rog_profiles = { path = "../rog-profiles" }
 rog_platform = { path = "../rog-platform" }
-zbus = "^2.2"
-zbus_macros = "^2.0"
-zvariant = "^3.0"
+zbus.workspace = true
+zbus_macros.workspace = true
+zvariant.workspace = true

rog-dbus/src/lib.rs

@@ -3,9 +3,9 @@ pub static DBUS_PATH: &str = "/org/asuslinux/Daemon";
 pub static DBUS_IFACE: &str = "org.asuslinux.Daemon";
 
 pub mod zbus_anime;
-pub mod zbus_charge;
 pub mod zbus_led;
 pub mod zbus_platform;
+pub mod zbus_power;
 pub mod zbus_profile;
 pub mod zbus_supported;
 
@@ -19,7 +19,7 @@ pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 
 pub struct DbusProxiesBlocking<'a> {
     anime: zbus_anime::AnimeProxyBlocking<'a>,
-    charge: zbus_charge::ChargeProxyBlocking<'a>,
+    charge: zbus_power::PowerProxyBlocking<'a>,
     led: zbus_led::LedProxyBlocking<'a>,
     profile: zbus_profile::ProfileProxyBlocking<'a>,
     rog_bios: zbus_platform::RogBiosProxyBlocking<'a>,
@@ -35,7 +35,7 @@ impl<'a> DbusProxiesBlocking<'a> {
             DbusProxiesBlocking {
                 anime: zbus_anime::AnimeProxyBlocking::new(&conn)?,
                 led: zbus_led::LedProxyBlocking::new(&conn)?,
-                charge: zbus_charge::ChargeProxyBlocking::new(&conn)?,
+                charge: zbus_power::PowerProxyBlocking::new(&conn)?,
                 profile: zbus_profile::ProfileProxyBlocking::new(&conn)?,
                 rog_bios: zbus_platform::RogBiosProxyBlocking::new(&conn)?,
                 supported: zbus_supported::SupportedProxyBlocking::new(&conn)?,
@@ -48,7 +48,7 @@ impl<'a> DbusProxiesBlocking<'a> {
         &self.anime
     }
 
-    pub fn charge(&self) -> &zbus_charge::ChargeProxyBlocking<'a> {
+    pub fn charge(&self) -> &zbus_power::PowerProxyBlocking<'a> {
         &self.charge
     }
 
@@ -88,7 +88,7 @@ impl<'a> RogDbusClientBlocking<'a> {
 
 pub struct DbusProxies<'a> {
     anime: zbus_anime::AnimeProxy<'a>,
-    charge: zbus_charge::ChargeProxy<'a>,
+    charge: zbus_power::PowerProxy<'a>,
     led: zbus_led::LedProxy<'a>,
     profile: zbus_profile::ProfileProxy<'a>,
     rog_bios: zbus_platform::RogBiosProxy<'a>,
@@ -104,7 +104,7 @@ impl<'a> DbusProxies<'a> {
             DbusProxies {
                 anime: zbus_anime::AnimeProxy::new(&conn).await?,
                 led: zbus_led::LedProxy::new(&conn).await?,
-                charge: zbus_charge::ChargeProxy::new(&conn).await?,
+                charge: zbus_power::PowerProxy::new(&conn).await?,
                 profile: zbus_profile::ProfileProxy::new(&conn).await?,
                 rog_bios: zbus_platform::RogBiosProxy::new(&conn).await?,
                 supported: zbus_supported::SupportedProxy::new(&conn).await?,
@@ -117,7 +117,7 @@ impl<'a> DbusProxies<'a> {
         &self.anime
     }
 
-    pub fn charge(&self) -> &zbus_charge::ChargeProxy<'a> {
+    pub fn charge(&self) -> &zbus_power::PowerProxy<'a> {
         &self.charge
     }
 

rog-dbus/src/zbus_anime.rs

@@ -7,26 +7,33 @@ use zbus_macros::dbus_proxy;
 )]
 trait Anime {
     /// Set whether the AniMe will show boot, suspend, or off animations
+    #[inline]
     fn set_boot_on_off(&self, status: bool) -> zbus::Result<()>;
 
     /// Set the global AniMe brightness
+    #[inline]
     fn set_brightness(&self, bright: f32) -> zbus::Result<()>;
 
     /// Set whether the AniMe is displaying images/data
+    #[inline]
     fn set_on_off(&self, status: bool) -> zbus::Result<()>;
 
     /// Writes a data stream of length. Will force system thread to exit until it is restarted
+    #[inline]
     fn write(&self, input: AnimeDataBuffer) -> zbus::Result<()>;
 
     /// Get status of if the AniMe LEDs are on
+    #[inline]
     #[dbus_proxy(property)]
     fn awake_enabled(&self) -> zbus::Result<bool>;
 
     /// Get the status of if factory system-status animations are enabled
+    #[inline]
     #[dbus_proxy(property)]
     fn boot_enabled(&self) -> zbus::Result<bool>;
 
     /// Notify listeners of the status of AniMe LED power and factory system-status animations
+    #[inline]
     #[dbus_proxy(signal)]
     fn power_states(&self, data: AnimePowerStates) -> zbus::Result<()>;
 }

rog-dbus/src/zbus_led.rs

@@ -34,46 +34,60 @@ const BLOCKING_TIME: u64 = 40; // 100ms = 10 FPS, max 50ms = 20 FPS, 40ms = 25 F
 )]
 trait Led {
     /// NextLedMode method
+    #[inline]
     fn next_led_mode(&self) -> zbus::Result<()>;
 
     /// PrevLedMode method
+    #[inline]
     fn prev_led_mode(&self) -> zbus::Result<()>;
 
     /// Toggle to next led brightness
+    #[inline]
     fn next_led_brightness(&self) -> zbus::Result<()>;
 
     /// Toggle to previous led brightness
+    #[inline]
     fn prev_led_brightness(&self) -> zbus::Result<()>;
 
     /// SetBrightness method
+    #[inline]
     fn set_brightness(&self, brightness: LedBrightness) -> zbus::Result<()>;
 
     /// SetLedMode method
+    #[inline]
     fn set_led_mode(&self, effect: &AuraEffect) -> zbus::Result<()>;
 
+    #[inline]
     fn set_leds_power(&self, options: AuraPowerDev, enabled: bool) -> zbus::Result<()>;
 
+    #[inline]
     fn per_key_raw(&self, data: PerKeyRaw) -> zbus::fdo::Result<()>;
 
     /// NotifyLed signal
+    #[inline]
     #[dbus_proxy(signal)]
     fn notify_led(&self, data: AuraEffect) -> zbus::Result<()>;
 
     #[dbus_proxy(signal)]
+    #[inline]
     fn notify_power_states(&self, data: AuraPowerDev) -> zbus::Result<()>;
 
     /// LedBrightness property
+    #[inline]
     #[dbus_proxy(property)]
     fn led_brightness(&self) -> zbus::Result<i16>;
 
     /// LedMode property
+    #[inline]
     fn led_mode(&self) -> zbus::Result<AuraModeNum>;
 
     /// LedModes property
+    #[inline]
     fn led_modes(&self) -> zbus::Result<BTreeMap<AuraModeNum, AuraEffect>>;
 
     // As property doesn't work for AuraPowerDev (complexity of serialization?)
     // #[dbus_proxy(property)]
+    #[inline]
     fn leds_enabled(&self) -> zbus::Result<AuraPowerDev>;
 }
 

rog-dbus/src/zbus_platform.rs

@@ -27,33 +27,68 @@ use zbus_macros::dbus_proxy;
     default_path = "/org/asuslinux/Platform"
 )]
 trait RogBios {
-    /// DedicatedGraphicMode method
+    /// DgpuDisable method
+    #[inline]
+    fn dgpu_disable(&self) -> zbus::Result<bool>;
+
+    /// EgpuEnable method
+    #[inline]
+    fn egpu_enable(&self) -> zbus::Result<bool>;
+
+    /// GpuMuxMode method
+    #[inline]
     fn gpu_mux_mode(&self) -> zbus::Result<GpuMode>;
 
+    /// PanelOd method
+    #[inline]
+    fn panel_od(&self) -> zbus::Result<bool>;
+
     /// PostBootSound method
+    #[inline]
     fn post_boot_sound(&self) -> zbus::Result<i16>;
 
-    /// SetDedicatedGraphicMode method
+    /// SetDgpuDisable method
+    #[inline]
+    fn set_dgpu_disable(&self, disable: bool) -> zbus::Result<()>;
+
+    /// SetEgpuEnable method
+    #[inline]
+    fn set_egpu_enable(&self, enable: bool) -> zbus::Result<()>;
+
+    /// SetGpuMuxMode method
+    #[inline]
     fn set_gpu_mux_mode(&self, mode: GpuMode) -> zbus::Result<()>;
 
+    /// SetPanelOd method
+    #[inline]
+    fn set_panel_od(&self, overdrive: bool) -> zbus::Result<()>;
+
     /// SetPostBootSound method
+    #[inline]
     fn set_post_boot_sound(&self, on: bool) -> zbus::Result<()>;
 
-    /// PanelOverdrive method
-    fn panel_overdrive(&self) -> zbus::Result<bool>;
+    /// NotifyDgpuDisable signal
+    #[inline]
+    #[dbus_proxy(signal)]
+    fn notify_dgpu_disable(&self, disable: bool) -> zbus::Result<()>;
 
-    /// SetPanelOverdrive method
-    fn set_panel_overdrive(&self, overdrive: bool) -> zbus::Result<()>;
+    /// NotifyEgpuEnable signal
+    #[inline]
+    #[dbus_proxy(signal)]
+    fn notify_egpu_enable(&self, enable: bool) -> zbus::Result<()>;
 
-    /// NotifyDedicatedGraphicMode signal
+    /// NotifyGpuMuxMode signal
+    #[inline]
     #[dbus_proxy(signal)]
     fn notify_gpu_mux_mode(&self, mode: GpuMode) -> zbus::Result<()>;
 
-    /// NotifyPostBootSound signal
+    /// NotifyPanelOd signal
+    #[inline]
     #[dbus_proxy(signal)]
-    fn notify_post_boot_sound(&self, sound: bool) -> zbus::Result<()>;
+    fn notify_panel_od(&self, overdrive: bool) -> zbus::Result<()>;
 
-    /// NotifyPanelOverdrive signal
+    /// NotifyPostBootSound signal
+    #[inline]
     #[dbus_proxy(signal)]
-    fn notify_panel_overdrive(&self, overdrive: bool) -> zbus::Result<()>;
+    fn notify_post_boot_sound(&self, on: bool) -> zbus::Result<()>;
 }

rog-dbus/src/zbus_power.rs

@@ -23,16 +23,28 @@ use zbus_macros::dbus_proxy;
 
 #[dbus_proxy(
     interface = "org.asuslinux.Daemon",
-    default_path = "/org/asuslinux/Charge"
+    default_path = "/org/asuslinux/Power"
 )]
-trait Charge {
-    /// Limit method
-    fn limit(&self) -> zbus::Result<i16>;
+trait Power {
+    /// charge_control_end_threshold method
+    #[inline]
+    fn charge_control_end_threshold(&self) -> zbus::Result<u8>;
 
-    /// SetLimit method
-    fn set_limit(&self, limit: u8) -> zbus::Result<()>;
+    /// MainsOnline method
+    #[inline]
+    fn mains_online(&self) -> zbus::Result<bool>;
+
+    /// set_charge_control_end_threshold method
+    #[inline]
+    fn set_charge_control_end_threshold(&self, limit: u8) -> zbus::Result<()>;
 
     /// NotifyCharge signal
+    #[inline]
     #[dbus_proxy(signal)]
-    fn notify_charge(&self, limit: u8) -> zbus::Result<u8>;
+    fn notify_charge_control_end_threshold(&self, limit: u8) -> zbus::Result<u8>;
+
+    /// NotifyMainsOnline signal
+    #[inline]
+    #[dbus_proxy(signal)]
+    fn notify_mains_online(&self, on: bool) -> zbus::Result<()>;
 }

rog-dbus/src/zbus_profile.rs

@@ -31,44 +31,55 @@ use zbus_macros::dbus_proxy;
 )]
 trait Profile {
     /// Get the fan-curve data for the currently active Profile
+    #[inline]
     fn fan_curve_data(&self, profile: Profile) -> zbus::Result<FanCurveSet>;
 
     /// Fetch the active profile name
+    #[inline]
     fn active_profile(&self) -> zbus::Result<Profile>;
 
     /// Get a list of profiles that have fan-curves enabled.
+    #[inline]
     fn enabled_fan_profiles(&self) -> zbus::Result<Vec<Profile>>;
 
     /// Toggle to next platform_profile. Names provided by `Profiles`.
     /// If fan-curves are supported will also activate a fan curve for profile.
+    #[inline]
     fn next_profile(&self) -> zbus::Result<()>;
 
     /// Fetch profile names
+    #[inline]
     fn profiles(&self) -> zbus::Result<Vec<Profile>>;
 
     /// Set this platform_profile name as active
+    #[inline]
     fn set_active_profile(&self, profile: Profile) -> zbus::Result<()>;
 
     /// Set a profile fan curve enabled status. Will also activate a fan curve.
+    #[inline]
     fn set_fan_curve_enabled(&self, profile: Profile, enabled: bool) -> zbus::Result<()>;
 
     /// Set the fan curve for the specified profile, or the profile the user is
     /// currently in if profile == None. Will also activate the fan curve.
+    #[inline]
     fn set_fan_curve(&self, profile: Profile, curve: CurveData) -> zbus::Result<()>;
 
     /// Reset the stored (self) and device curve to the defaults of the platform.
     ///
     /// Each platform_profile has a different default and the defualt can be read
     /// only for the currently active profile.
+    #[inline]
     fn set_active_curve_to_defaults(&self) -> zbus::Result<()>;
 
     /// Reset the stored (self) and device curve to the defaults of the platform.
     ///
     /// Each platform_profile has a different default and the defualt can be read
     /// only for the currently active profile.
+    #[inline]
     fn reset_profile_curves(&self, profile: Profile) -> zbus::fdo::Result<()>;
 
     /// NotifyProfile signal
+    #[inline]
     #[dbus_proxy(signal)]
-    fn notify_profile(&self, profile: Profile) -> zbus::Result<Profile>;
+    async fn notify_profile(&self, profile: Profile) -> zbus::Result<Profile>;
 }

rog-dbus/src/zbus_supported.rs

@@ -28,5 +28,6 @@ use zbus_macros::dbus_proxy;
 )]
 trait Supported {
     /// SupportedFunctions method
+    #[inline]
     fn supported_functions(&self) -> zbus::Result<SupportedFunctions>;
 }

rog-platform/Cargo.toml

@@ -1,22 +1,18 @@
 [package]
 name = "rog_platform"
-version = "0.1.1"
+version.workspace = true
 edition = "2021"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
-log = "*"
-
+log.workspace = true
 rog_aura = { path = "../rog-aura" }
-serde = "^1.0"
-serde_derive = "^1.0"
-zvariant = "^3.0"
-zvariant_derive = "^3.0"
+serde.workspace = true
+serde_derive.workspace = true
+zvariant.workspace = true
+zvariant_derive.workspace = true
+sysfs-class.workspace = true
+concat-idents.workspace = true
+udev.workspace = true
+inotify.workspace = true
 
-udev = "^0.6"
-rusb = "^0.9"
-sysfs-class = "^0.1"
-inotify = "^0.10.0"
-
-concat-idents = "1.1.3"
+rusb.workspace = true

rog-platform/src/error.rs

@@ -15,7 +15,8 @@ pub enum PlatformError {
     AttrNotFound(String),
     MissingFunction(String),
     MissingLedBrightNode(String, std::io::Error),
-    Io(String, std::io::Error),
+    IoPath(String, std::io::Error),
+    Io(std::io::Error),
     NoAuraKeyboard,
     NoAuraNode,
 }
@@ -33,9 +34,10 @@ impl fmt::Display for PlatformError {
             PlatformError::Write(path, error) => write!(f, "Write {}: {}", path, error),
             PlatformError::NotSupported => write!(f, "Not supported"),
             PlatformError::AttrNotFound(deets) => write!(f, "Attribute not found: {}", deets),
+            PlatformError::Io(deets) => write!(f, "std::io error: {}", deets),
             PlatformError::MissingFunction(deets) => write!(f, "Missing functionality: {}", deets),
             PlatformError::MissingLedBrightNode(path, error) => write!(f, "Led node at {} is missing, please check you have the required patch or dkms module installed: {}", path, error),
-            PlatformError::Io(path, detail) => write!(f, "std::io error: {} {}", path, detail),
+            PlatformError::IoPath(path, detail) => write!(f, "{} {}", path, detail),
             PlatformError::NoAuraKeyboard => write!(f, "No supported Aura keyboard"),
             PlatformError::NoAuraNode => write!(f, "No Aura keyboard node found"),
         }
@@ -49,3 +51,9 @@ impl From<rusb::Error> for PlatformError {
         PlatformError::USB(err)
     }
 }
+
+impl From<std::io::Error> for PlatformError {
+    fn from(err: std::io::Error) -> Self {
+        PlatformError::Io(err)
+    }
+}

rog-platform/src/hid_raw.rs

@@ -4,7 +4,7 @@ use log::{info, warn};
 
 use crate::error::{PlatformError, Result};
 
-#[derive(Debug, PartialEq, PartialOrd, Clone)]
+#[derive(Debug, PartialEq, Eq, PartialOrd, Clone)]
 pub struct HidRaw(PathBuf);
 
 impl HidRaw {
@@ -21,11 +21,13 @@ impl HidRaw {
 
         for device in enumerator
             .scan_devices()
-            .map_err(|e| PlatformError::Io("enumerator".to_owned(), e))?
+            .map_err(|e| PlatformError::IoPath("enumerator".to_owned(), e))?
         {
             if let Some(parent) = device
                 .parent_with_subsystem_devtype("usb", "usb_device")
-                .map_err(|e| PlatformError::Io(device.devpath().to_string_lossy().to_string(), e))?
+                .map_err(|e| {
+                    PlatformError::IoPath(device.devpath().to_string_lossy().to_string(), e)
+                })?
             {
                 if let Some(parent) = parent.attribute_value("idProduct") {
                     if parent == id_product {
@@ -47,9 +49,9 @@ impl HidRaw {
         let mut file = OpenOptions::new()
             .write(true)
             .open(&self.0)
-            .map_err(|e| PlatformError::Io(self.0.to_string_lossy().to_string(), e))?;
+            .map_err(|e| PlatformError::IoPath(self.0.to_string_lossy().to_string(), e))?;
         // println!("write: {:02x?}", &message);
         file.write_all(message)
-            .map_err(|e| PlatformError::Io(self.0.to_string_lossy().to_string(), e))
+            .map_err(|e| PlatformError::IoPath(self.0.to_string_lossy().to_string(), e))
     }
 }

rog-platform/src/keyboard_led.rs

@@ -8,7 +8,7 @@ use crate::{
     has_attr, set_attr_u8_array, to_device,
 };
 
-#[derive(Debug, Default, PartialEq, PartialOrd, Clone)]
+#[derive(Debug, Default, PartialEq, Eq, PartialOrd, Clone)]
 pub struct KeyboardLed {
     path: PathBuf,
 }
@@ -32,10 +32,12 @@ impl KeyboardLed {
                 PlatformError::Udev("match_subsystem failed".into(), err)
             })?;
 
-        for device in enumerator.scan_devices().map_err(|err| {
+        if let Some(device) = (enumerator.scan_devices().map_err(|err| {
             warn!("{}", err);
             PlatformError::Udev("scan_devices failed".into(), err)
-        })? {
+        })?)
+        .next()
+        {
             info!("Found keyboard LED controls at {:?}", device.sysname());
             return Ok(Self {
                 path: device.syspath().to_owned(),

rog-platform/src/lib.rs

@@ -45,13 +45,13 @@ pub fn read_attr_bool(device: &Device, attr_name: &str) -> Result<bool> {
 pub fn write_attr_bool(device: &mut Device, attr: &str, value: bool) -> Result<()> {
     device
         .set_attribute_value(attr, &(value as u8).to_string())
-        .map_err(|e| PlatformError::Io(attr.into(), e))
+        .map_err(|e| PlatformError::IoPath(attr.into(), e))
 }
 
 pub fn read_attr_u8(device: &Device, attr_name: &str) -> Result<u8> {
     if let Some(value) = device.attribute_value(attr_name) {
         let tmp = value.to_string_lossy();
-        return Ok(tmp.parse::<u8>().map_err(|_| PlatformError::ParseNum)?);
+        return tmp.parse::<u8>().map_err(|_| PlatformError::ParseNum);
     }
     Err(PlatformError::AttrNotFound(attr_name.to_string()))
 }
@@ -59,7 +59,7 @@ pub fn read_attr_u8(device: &Device, attr_name: &str) -> Result<u8> {
 pub fn write_attr_u8(device: &mut Device, attr: &str, value: u8) -> Result<()> {
     device
         .set_attribute_value(attr, &(value).to_string())
-        .map_err(|e| PlatformError::Io(attr.into(), e))
+        .map_err(|e| PlatformError::IoPath(attr.into(), e))
 }
 
 pub fn read_attr_u8_array(device: &Device, attr_name: &str) -> Result<Vec<u8>> {
@@ -67,7 +67,7 @@ pub fn read_attr_u8_array(device: &Device, attr_name: &str) -> Result<Vec<u8>> {
         let tmp = value.to_string_lossy();
         let tmp = tmp
             .split(' ')
-            .map(|v| u8::from_str_radix(v, 10).unwrap_or(0))
+            .map(|v| v.parse::<u8>().unwrap_or(0))
             .collect();
         return Ok(tmp);
     }
@@ -78,8 +78,8 @@ pub fn write_attr_u8_array(device: &mut Device, attr: &str, values: &[u8]) -> Re
     let tmp: String = values.iter().map(|v| format!("{} ", v)).collect();
     let tmp = tmp.trim();
     device
-        .set_attribute_value(attr, &tmp)
-        .map_err(|e| PlatformError::Io(attr.into(), e))
+        .set_attribute_value(attr, tmp)
+        .map_err(|e| PlatformError::IoPath(attr.into(), e))
 }
 
 #[cfg(test)]
@@ -94,7 +94,7 @@ mod tests {
 
         let tmp: Vec<u8> = tmp
             .split(' ')
-            .map(|v| u8::from_str_radix(v, 10).unwrap_or(0))
+            .map(|v| v.parse::<u8>().unwrap_or(0))
             .collect();
         assert_eq!(tmp, &[1, 2, 3, 4, 5]);
     }

rog-platform/src/macros.rs

@@ -5,7 +5,7 @@ macro_rules! has_attr {
             $(#[$doc_comment])*
             pub fn fn_name(&self) -> bool {
                 match to_device(&self.$item) {
-                    Ok(p) => crate::has_attr(&p, $attr_name),
+                    Ok(p) => $crate::has_attr(&p, $attr_name),
                     Err(_) => false,
                 }
             }
@@ -21,9 +21,19 @@ macro_rules! watch_attr {
             pub fn fn_name(&self) -> Result<inotify::Inotify> {
                 let mut path = self.$item.clone();
                 path.push($attr_name);
-                let mut inotify = inotify::Inotify::init().unwrap();
-                inotify.add_watch(path.to_str().unwrap(), inotify::WatchMask::MODIFY).unwrap();
-                Ok(inotify)
+                if let Some(path) = path.to_str() {
+                    let mut inotify = inotify::Inotify::init()?;
+                    inotify.add_watch(path, inotify::WatchMask::CLOSE_WRITE)
+                        .map_err(|e| {
+                            if e.kind() == std::io::ErrorKind::NotFound {
+                                PlatformError::AttrNotFound(format!("{}", $attr_name))
+                            } else {
+                                PlatformError::IoPath(format!("{}", path), e)
+                            }
+                        })?;
+                    return Ok(inotify);
+                }
+                Err(PlatformError::AttrNotFound(format!("{}", $attr_name)))
             }
         });
     };
@@ -35,7 +45,7 @@ macro_rules! get_attr_bool {
         concat_idents::concat_idents!(fn_name = get_, $attr_name {
             $(#[$doc_comment])*
             pub fn fn_name(&self) -> Result<bool> {
-                crate::read_attr_bool(&to_device(&self.$item)?, $attr_name)
+                $crate::read_attr_bool(&to_device(&self.$item)?, $attr_name)
             }
         });
     };
@@ -47,7 +57,7 @@ macro_rules! set_attr_bool {
         concat_idents::concat_idents!(fn_name = set_, $attr_name {
             $(#[$doc_comment])*
             pub fn fn_name(&self, value: bool) -> Result<()> {
-                crate::write_attr_bool(&mut to_device(&self.$item)?, $attr_name, value)
+                $crate::write_attr_bool(&mut to_device(&self.$item)?, $attr_name, value)
             }
         });
     };
@@ -56,10 +66,10 @@ macro_rules! set_attr_bool {
 #[macro_export]
 macro_rules! attr_bool {
     ($attr_name:literal, $item:ident) => {
-        crate::has_attr!($attr_name $item);
-        crate::get_attr_bool!( $attr_name $item);
-        crate::set_attr_bool!($attr_name $item);
-        crate::watch_attr!($attr_name $item);
+        $crate::has_attr!($attr_name $item);
+        $crate::get_attr_bool!( $attr_name $item);
+        $crate::set_attr_bool!($attr_name $item);
+        $crate::watch_attr!($attr_name $item);
     };
 }
 
@@ -69,19 +79,20 @@ macro_rules! get_attr_u8 {
         concat_idents::concat_idents!(fn_name = get_, $attr_name {
             $(#[$doc_comment])*
             pub fn fn_name(&self) -> Result<u8> {
-                crate::read_attr_u8(&to_device(&self.$item)?, $attr_name)
+                $crate::read_attr_u8(&to_device(&self.$item)?, $attr_name)
             }
         });
     };
 }
 
+/// Most attributes expect `u8` as a char, so `1` should be written as `b'1'`.
 #[macro_export]
 macro_rules! set_attr_u8 {
     ($(#[$doc_comment:meta])? $attr_name:literal $item:ident) => {
         concat_idents::concat_idents!(fn_name = set_, $attr_name {
             $(#[$doc_comment])*
             pub fn fn_name(&self, value: u8) -> Result<()> {
-                crate::write_attr_u8(&mut to_device(&self.$item)?, $attr_name, value)
+                $crate::write_attr_u8(&mut to_device(&self.$item)?, $attr_name, value)
             }
         });
     };
@@ -90,10 +101,10 @@ macro_rules! set_attr_u8 {
 #[macro_export]
 macro_rules! attr_u8 {
     ($attr_name:literal, $item:ident) => {
-        crate::has_attr!($attr_name $item);
-        crate::get_attr_u8!($attr_name $item);
-        crate::set_attr_u8!($attr_name $item);
-        crate::watch_attr!($attr_name $item);
+        $crate::has_attr!($attr_name $item);
+        $crate::get_attr_u8!($attr_name $item);
+        $crate::set_attr_u8!($attr_name $item);
+        $crate::watch_attr!($attr_name $item);
     };
 }
 
@@ -103,7 +114,7 @@ macro_rules! get_attr_u8_array {
         concat_idents::concat_idents!(fn_name = get_, $attr_name {
             $(#[$doc_comment])*
             pub fn fn_name(&self) -> Result<Vec<u8>> {
-                crate::read_attr_u8_array(&to_device(&self.$item)?, $attr_name)
+                $crate::read_attr_u8_array(&to_device(&self.$item)?, $attr_name)
             }
         });
     };
@@ -115,7 +126,7 @@ macro_rules! set_attr_u8_array {
         concat_idents::concat_idents!(fn_name = set_, $attr_name {
             $(#[$doc_comment])*
             pub fn fn_name(&self, values: &[u8]) -> Result<()> {
-                crate::write_attr_u8_array(&mut to_device(&self.$item)?, $attr_name, values)
+                $crate::write_attr_u8_array(&mut to_device(&self.$item)?, $attr_name, values)
             }
         });
     };
@@ -124,8 +135,9 @@ macro_rules! set_attr_u8_array {
 #[macro_export]
 macro_rules! attr_u8_array {
     ($attr_name:literal, $item:ident) => {
-        crate::has_attr!($attr_name $item);
-        crate::get_attr_u8_array!($attr_name $item);
-        crate::set_attr_u8_array!($attr_name $item);
+        $crate::has_attr!($attr_name $item);
+        $crate::get_attr_u8_array!($attr_name $item);
+        $crate::set_attr_u8_array!($attr_name $item);
+        $crate::watch_attr!($attr_name $item);
     };
 }

rog-platform/src/platform.rs

@@ -1,4 +1,4 @@
-use std::path::PathBuf;
+use std::{fmt::Display, path::PathBuf, str::FromStr};
 
 use log::{info, warn};
 use serde::{Deserialize, Serialize};
@@ -17,9 +17,10 @@ use crate::{
 /// - gpu_mux
 /// - keyboard_mode, set keyboard RGB mode and speed
 /// - keyboard_state, set keyboard power states
-#[derive(Debug, PartialEq, PartialOrd, Clone)]
+#[derive(Debug, PartialEq, Eq, PartialOrd, Clone)]
 pub struct AsusPlatform {
     path: PathBuf,
+    pp_path: PathBuf,
 }
 
 impl AsusPlatform {
@@ -37,13 +38,16 @@ impl AsusPlatform {
             PlatformError::Udev("match_subsystem failed".into(), err)
         })?;
 
-        for device in enumerator.scan_devices().map_err(|err| {
+        if let Some(device) = (enumerator.scan_devices().map_err(|err| {
             warn!("{}", err);
             PlatformError::Udev("scan_devices failed".into(), err)
-        })? {
+        })?)
+        .next()
+        {
             info!("Found platform support at {:?}", device.sysname());
             return Ok(Self {
                 path: device.syspath().to_owned(),
+                pp_path: PathBuf::from_str("/sys/firmware/acpi").unwrap(),
             });
         }
         Err(PlatformError::MissingFunction(
@@ -54,10 +58,14 @@ impl AsusPlatform {
     attr_bool!("dgpu_disable", path);
     attr_bool!("egpu_enable", path);
     attr_bool!("panel_od", path);
-    attr_u8!("gpu_mux_mode", path);
+    attr_bool!("gpu_mux_mode", path);
+    // This is technically the same as `platform_profile` since both are tied in-kernel
+    attr_u8!("throttle_thermal_policy", path);
+    // The acpi platform_profile support
+    attr_u8!("platform_profile", pp_path);
 }
 
-#[derive(Serialize, Deserialize, Type, Debug, PartialEq, Clone, Copy)]
+#[derive(Serialize, Deserialize, Type, Debug, PartialEq, Eq, Clone, Copy)]
 pub enum GpuMode {
     Discrete,
     Optimus,
@@ -68,21 +76,22 @@ pub enum GpuMode {
 }
 
 impl GpuMode {
-    pub fn to_mux(&self) -> u8 {
+    /// For writing to `gpu_mux_mode` attribute
+    pub fn to_mux_attr(&self) -> bool {
         if *self == Self::Discrete {
-            return 0;
+            return false;
         }
-        1
+        true
     }
 
-    pub fn to_dgpu(&self) -> u8 {
+    pub fn to_dgpu_attr(&self) -> u8 {
         if *self == Self::Integrated {
             return 1;
         }
         0
     }
 
-    pub fn to_egpu(&self) -> u8 {
+    pub fn to_egpu_attr(&self) -> u8 {
         if *self == Self::Egpu {
             return 1;
         }
@@ -112,3 +121,16 @@ impl GpuMode {
         Self::Optimus
     }
 }
+
+impl Display for GpuMode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            GpuMode::Discrete => write!(f, "Discrete"),
+            GpuMode::Optimus => write!(f, "Optimus"),
+            GpuMode::Integrated => write!(f, "Integrated"),
+            GpuMode::Egpu => write!(f, "eGPU"),
+            GpuMode::Error => write!(f, "Error"),
+            GpuMode::NotSupported => write!(f, "Not Supported"),
+        }
+    }
+}

rog-platform/src/power.rs

@@ -15,7 +15,7 @@ use crate::{
 /// - gpu_mux
 /// - keyboard_mode, set keyboard RGB mode and speed
 /// - keyboard_state, set keyboard power states
-#[derive(Debug, PartialEq, PartialOrd, Clone)]
+#[derive(Debug, PartialEq, Eq, PartialOrd, Clone)]
 pub struct AsusPower {
     mains: PathBuf,
     battery: PathBuf,
@@ -102,4 +102,5 @@ impl AsusPower {
     }
 
     attr_u8!("charge_control_end_threshold", battery);
+    attr_u8!("online", mains);
 }

rog-platform/src/usb_raw.rs

@@ -3,7 +3,7 @@ use std::time::Duration;
 
 use crate::error::{PlatformError, Result};
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 pub struct USBRaw(DeviceHandle<rusb::GlobalContext>);
 
 impl USBRaw {
@@ -43,6 +43,6 @@ impl USBRaw {
                 message,
                 Duration::from_millis(200),
             )
-            .map_err(|e| PlatformError::USB(e))
+            .map_err(PlatformError::USB)
     }
 }

rog-profiles/Cargo.toml

@@ -1,17 +1,17 @@
 [package]
 name = "rog_profiles"
-version = "1.1.3"
+version.workspace = true
 authors = ["Luke D. Jones <luke@ljones.dev>"]
-edition = "2018"
+edition = "2021"
 
 [features]
 default = ["dbus"]
 dbus = ["zvariant", "zvariant_derive"]
 
 [dependencies]
-udev = "^0.6"
-serde = "^1.0"
-serde_derive = "^1.0"
+udev.workspace = true
+serde.workspace = true
+serde_derive.workspace = true
 
-zvariant = { version = "^3.0", optional = true }
-zvariant_derive = { version = "^3.0", optional = true }
+zvariant = { workspace = true, optional = true }
+zvariant_derive = { workspace = true, optional = true }

rog-profiles/src/lib.rs

@@ -2,6 +2,7 @@ pub mod error;
 pub mod fan_curve_set;
 
 use std::{
+    fmt::Display,
     fs::OpenOptions,
     io::{Read, Write},
     path::Path,
@@ -113,8 +114,14 @@ impl std::str::FromStr for Profile {
     }
 }
 
+impl Display for Profile {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
 #[cfg_attr(feature = "dbus", derive(Type))]
-#[derive(Deserialize, Serialize, Debug, PartialEq, Clone, Copy)]
+#[derive(Deserialize, Serialize, Debug, PartialEq, Eq, Clone, Copy)]
 pub enum FanCurvePU {
     CPU,
     GPU,