Prep 4.5.6 release

Closes #293

.gitignore

@@ -2,6 +2,7 @@
 vendor.tar.xz
 cargo-config
 .idea
+vendor
 vendor-*
 vendor_*
 .vscode-ctags

.gitlab-ci.yml

@@ -17,7 +17,7 @@ cache:
       - target/release/.cargo-lock
 
 before_script:
-  - apt-get update -qq && apt-get install -y -qq libudev-dev libgtk-3-dev
+  - apt-get update -qq && apt-get install -y -qq libudev-dev libgtk-3-dev grep
 
 stages:
     - format
@@ -26,13 +26,16 @@ stages:
     - release
 
 format:
-  image: rust:latest
+  except:
+    - tags
   script:
     - echo "nightly" > rust-toolchain
     - rustup component add rustfmt
     - cargo fmt --check
 
 check:
+  except:
+    - tags
   script:
     - rustup component add clippy
     - cargo check
@@ -41,6 +44,8 @@ check:
     - cargo install cargo-cranky && cargo cranky
 
 test:
+  except:
+    - tags
   script:
     - cargo test
 

CHANGELOG.md

@@ -5,6 +5,32 @@ 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]
+## [v4.5.6]
+### Changed
+- Fix tasks not always running correctly on boot/sleep/wake/shutdown by finishing the move to async
+- Change how the profile/fan change task monitors changes due to TUF laptops behaving slightly different
+- ROGCC: Better handle the use of GPU MUX without supergfxd
+- ROGCC: Track if reboot required when not using supergfxd
+- Add env var for logging levels to daemon and gui (`RUST_LOG=<error|warn|info|debug|trace>`)
+- ROGCC: Very basic support for running a command on AC/Battery switching, this is in config at `~/.config/rog/rog-control-center.cfg`, and for now must be edited by hand and ROGCC restarted (run ROGCC in BG to use effectively)
+  + Run ROGCC from terminal to see errors of the AC/Battery command
+  + Support for editing via ROGCC GUI will come in future
+  + This is ideal for userspace tasks
+- asusd: Very basic support for running a command on AC/Battery switching, this is in config at `/etc/asusd/asusd.conf`. A restart of asusd is not required if edited.
+  + This is ideal for tasks that require root access (BE SAFE!)
+- The above AC/Battery commands are probably best set to run a script for more complex tasks
+- asusd: check if nvidia-powerd enabled before toggling
+        
+## [v4.5.5]
+### Changed
+- remove an unwrap() causing panic on main ROGCC thread
+
+## [v4.5.4]
+### Changed
+- ROGCC:: Allow ROGCC to run without supergfxd
+- ROGCC: Tray/notifs now reads dGPU status directly via supergfx crate (supergfxd not required)
+- Add rust-toolchain to force minimum rust version
+
 ## [v4.5.3]
 ### Changed
 - Adjust how fan graph in ROGCC works, deny incorrect graphs

Cargo.lock

@@ -149,7 +149,7 @@ checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
 
 [[package]]
 name = "asusctl"
-version = "4.5.3"
+version = "4.5.6"
 dependencies = [
  "daemon",
  "gif",
@@ -727,7 +727,7 @@ checksum = "b365fabc795046672053e29c954733ec3b05e4be654ab130fe8f1f94d7051f35"
 
 [[package]]
 name = "daemon"
-version = "4.5.3"
+version = "4.5.6"
 dependencies = [
  "async-trait",
  "concat-idents",
@@ -750,7 +750,7 @@ dependencies = [
 
 [[package]]
 name = "daemon-user"
-version = "4.5.3"
+version = "4.5.6"
 dependencies = [
  "dirs",
  "rog_anime",
@@ -930,10 +930,18 @@ dependencies = [
  "wio",
 ]
 
+[[package]]
+name = "ecolor"
+version = "0.20.0"
+source = "git+https://github.com/flukejones/egui?branch=wayland_dark_theme#056fd4bd1ed8c48c035e6b75111cfa8087634934"
+dependencies = [
+ "bytemuck",
+]
+
 [[package]]
 name = "eframe"
-version = "0.19.0"
-source = "git+https://github.com/flukejones/egui?branch=wayland_dark_theme#bb2cb764e48829f865312c5934efdab2169737ae"
+version = "0.20.0"
+source = "git+https://github.com/flukejones/egui?branch=wayland_dark_theme#056fd4bd1ed8c48c035e6b75111cfa8087634934"
 dependencies = [
  "bytemuck",
  "egui",
@@ -953,8 +961,8 @@ dependencies = [
 
 [[package]]
 name = "egui"
-version = "0.19.0"
-source = "git+https://github.com/flukejones/egui?branch=wayland_dark_theme#bb2cb764e48829f865312c5934efdab2169737ae"
+version = "0.20.0"
+source = "git+https://github.com/flukejones/egui?branch=wayland_dark_theme#056fd4bd1ed8c48c035e6b75111cfa8087634934"
 dependencies = [
  "accesskit",
  "ahash",
@@ -965,8 +973,8 @@ dependencies = [
 
 [[package]]
 name = "egui-winit"
-version = "0.19.0"
-source = "git+https://github.com/flukejones/egui?branch=wayland_dark_theme#bb2cb764e48829f865312c5934efdab2169737ae"
+version = "0.20.0"
+source = "git+https://github.com/flukejones/egui?branch=wayland_dark_theme#056fd4bd1ed8c48c035e6b75111cfa8087634934"
 dependencies = [
  "accesskit_winit",
  "arboard",
@@ -980,8 +988,8 @@ dependencies = [
 
 [[package]]
 name = "egui_glow"
-version = "0.19.0"
-source = "git+https://github.com/flukejones/egui?branch=wayland_dark_theme#bb2cb764e48829f865312c5934efdab2169737ae"
+version = "0.20.0"
+source = "git+https://github.com/flukejones/egui?branch=wayland_dark_theme#056fd4bd1ed8c48c035e6b75111cfa8087634934"
 dependencies = [
  "bytemuck",
  "egui",
@@ -994,8 +1002,8 @@ dependencies = [
 
 [[package]]
 name = "emath"
-version = "0.19.0"
-source = "git+https://github.com/flukejones/egui?branch=wayland_dark_theme#bb2cb764e48829f865312c5934efdab2169737ae"
+version = "0.20.0"
+source = "git+https://github.com/flukejones/egui?branch=wayland_dark_theme#056fd4bd1ed8c48c035e6b75111cfa8087634934"
 dependencies = [
  "bytemuck",
 ]
@@ -1080,13 +1088,14 @@ dependencies = [
 
 [[package]]
 name = "epaint"
-version = "0.19.0"
-source = "git+https://github.com/flukejones/egui?branch=wayland_dark_theme#bb2cb764e48829f865312c5934efdab2169737ae"
+version = "0.20.0"
+source = "git+https://github.com/flukejones/egui?branch=wayland_dark_theme#056fd4bd1ed8c48c035e6b75111cfa8087634934"
 dependencies = [
  "ab_glyph",
  "ahash",
  "atomic_refcell",
  "bytemuck",
+ "ecolor",
  "emath",
  "nohash-hasher",
  "parking_lot",
@@ -1538,9 +1547,9 @@ dependencies = [
 
 [[package]]
 name = "glutin"
-version = "0.30.2"
+version = "0.30.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0282c380a3adb52ae095e5847cc575c6bf79d296dcbf333e00be4a3fca07235e"
+checksum = "524d807cd49a0c56a53ef9a6738cd15e7c8c4e9d37a3b7fdb3c250c1cd5bf7a3"
 dependencies = [
  "bitflags",
  "cfg_aliases",
@@ -1554,7 +1563,7 @@ dependencies = [
  "objc",
  "once_cell",
  "raw-window-handle 0.5.0",
- "wayland-sys 0.30.0",
+ "wayland-sys 0.30.1",
  "windows-sys 0.36.1",
  "x11-dl",
 ]
@@ -2593,7 +2602,7 @@ dependencies = [
 
 [[package]]
 name = "rog-control-center"
-version = "4.5.3"
+version = "4.5.6"
 dependencies = [
  "daemon",
  "dirs",
@@ -2605,7 +2614,6 @@ dependencies = [
  "log",
  "nix 0.26.1",
  "notify-rust",
- "once_cell",
  "png_pong",
  "rog_anime",
  "rog_aura",
@@ -2624,7 +2632,7 @@ dependencies = [
 
 [[package]]
 name = "rog_anime"
-version = "4.5.3"
+version = "4.5.6"
 dependencies = [
  "gif",
  "glam",
@@ -2639,7 +2647,7 @@ dependencies = [
 
 [[package]]
 name = "rog_aura"
-version = "4.5.3"
+version = "4.5.6"
 dependencies = [
  "serde",
  "serde_derive",
@@ -2650,7 +2658,7 @@ dependencies = [
 
 [[package]]
 name = "rog_dbus"
-version = "4.5.3"
+version = "4.5.6"
 dependencies = [
  "rog_anime",
  "rog_aura",
@@ -2661,7 +2669,7 @@ dependencies = [
 
 [[package]]
 name = "rog_platform"
-version = "4.5.3"
+version = "4.5.6"
 dependencies = [
  "concat-idents",
  "inotify",
@@ -2677,7 +2685,7 @@ dependencies = [
 
 [[package]]
 name = "rog_profiles"
-version = "4.5.3"
+version = "4.5.6"
 dependencies = [
  "serde",
  "serde_derive",
@@ -2999,7 +3007,7 @@ dependencies = [
 [[package]]
 name = "supergfxctl"
 version = "5.0.2"
-source = "git+https://gitlab.com/asus-linux/supergfxctl.git#fa022efb54b752a3672a64c640bd7aebeb842e05"
+source = "git+https://gitlab.com/asus-linux/supergfxctl.git#387e115a0f338662be313627308201405039d116"
 dependencies = [
  "log",
  "logind-zbus",
@@ -3509,9 +3517,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-sys"
-version = "0.30.0"
+version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bcdbc325d8a78a9f49dcb77b39e92656e93b3f69eb4d60245f2116ec4bb0a97"
+checksum = "96b2a02ac608e07132978689a6f9bf4214949c85998c247abadd4f4129b1aa06"
 dependencies = [
  "dlib",
  "lazy_static",
@@ -3868,9 +3876,9 @@ checksum = "d2d7d3948613f75c98fd9328cfdcc45acc4d360655289d0a7d4ec931392200a3"
 
 [[package]]
 name = "zbus"
-version = "3.6.1"
+version = "3.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbaaf011914a4f69a9ec6361225d8440be69673bda9c888275da99c6e8aad03f"
+checksum = "938ea6da98c75c2c37a86007bd17fd8e208cbec24e086108c87ece98e9edec0d"
 dependencies = [
  "async-broadcast",
  "async-channel",
@@ -3907,9 +3915,9 @@ dependencies = [
 
 [[package]]
 name = "zbus_macros"
-version = "3.6.1"
+version = "3.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a64de32c103d3a845f37adf0f46397d6346c8d48028e218db44dcde981733880"
+checksum = "45066039ebf3330820e495e854f8b312abb68f0a39e97972d092bd72e8bb3e8e"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",

Cargo.toml

@@ -2,7 +2,7 @@
 members = ["asusctl", "daemon", "daemon-user", "rog-platform", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles", "rog-control-center"]
 
 [workspace.package]
-version = "4.5.3"
+version = "4.5.6"
 
 [workspace.dependencies]
 async-trait = "^0.1"

daemon/src/config.rs

@@ -7,11 +7,12 @@ use std::path::PathBuf;
 pub static CONFIG_PATH: &str = "/etc/asusd/asusd.conf";
 
 #[derive(Deserialize, Serialize, Default)]
-#[serde(default)]
 pub struct Config {
     /// Save charge limit for restoring on boot
     pub bat_charge_limit: u8,
     pub panel_od: bool,
+    pub ac_command: String,
+    pub bat_command: String,
 }
 
 impl Config {
@@ -19,6 +20,8 @@ impl Config {
         Config {
             bat_charge_limit: 100,
             panel_od: false,
+            ac_command: String::new(),
+            bat_command: String::new(),
         }
     }
 
@@ -37,6 +40,8 @@ impl Config {
                 config = Self::new();
             } else if let Ok(data) = serde_json::from_str(&buf) {
                 config = data;
+            } else if let Ok(data) = serde_json::from_str::<Config455>(&buf) {
+                config = data.into();
             } else {
                 warn!(
                     "Could not deserialise {}.\nWill rename to {}-old and recreate config",
@@ -81,3 +86,22 @@ impl Config {
             .unwrap_or_else(|err| error!("Could not write config: {}", err));
     }
 }
+
+#[derive(Deserialize, Serialize, Default)]
+#[serde(default)]
+pub struct Config455 {
+    /// Save charge limit for restoring on boot
+    pub bat_charge_limit: u8,
+    pub panel_od: bool,
+}
+
+impl From<Config455> for Config {
+    fn from(c: Config455) -> Self {
+        Self {
+            bat_charge_limit: c.bat_charge_limit,
+            panel_od: c.panel_od,
+            ac_command: String::new(),
+            bat_command: String::new(),
+        }
+    }
+}

daemon/src/ctrl_anime/trait_impls.rs

@@ -166,28 +166,32 @@ impl crate::CtrlTask for CtrlAnimeZbus {
         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() {
+            move || {
+                let inner1 = inner1.clone();
+                async move {
+                    let lock = inner1.lock().await;
                     run_action(true, lock, inner1.clone());
-                    break;
                 }
             },
-            move || loop {
-                if let Some(lock) = inner2.try_lock() {
-                    run_action(false, lock, inner2.clone());
-                    break;
+            move || {
+                let inner2 = inner2.clone();
+                async move {
+                    let lock = inner2.lock().await;
+                    run_action(true, lock, inner2.clone());
                 }
             },
-            move || loop {
-                if let Some(lock) = inner3.try_lock() {
+            move || {
+                let inner3 = inner3.clone();
+                async move {
+                    let lock = inner3.lock().await;
                     run_action(true, lock, inner3.clone());
-                    break;
                 }
             },
-            move || loop {
-                if let Some(lock) = inner4.try_lock() {
-                    run_action(false, lock, inner4.clone());
-                    break;
+            move || {
+                let inner4 = inner4.clone();
+                async move {
+                    let lock = inner4.lock().await;
+                    run_action(true, lock, inner4.clone());
                 }
             },
         )

daemon/src/ctrl_aura/trait_impls.rs

@@ -262,28 +262,32 @@ impl CtrlTask for CtrlKbdLedZbus {
         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() {
+            move || {
+                let inner1 = inner1.clone();
+                async move {
+                    let lock = inner1.lock().await;
                     load_save(true, lock);
-                    break;
                 }
             },
-            move || loop {
-                if let Some(lock) = inner2.try_lock() {
+            move || {
+                let inner2 = inner2.clone();
+                async move {
+                    let lock = inner2.lock().await;
                     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() {
+            move || {
+                let inner3 = inner3.clone();
+                async move {
+                    let lock = inner3.lock().await;
+                    load_save(false, lock);
+                }
+            },
+            move || {
+                let inner4 = inner4.clone();
+                async move {
+                    let lock = inner4.lock().await;
                     load_save(false, lock);
-                    break;
                 }
             },
         )

daemon/src/ctrl_platform.rs

@@ -319,7 +319,8 @@ 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);
+    // NOTE: see note further below
+    //task_watch_item!(gpu_mux_mode platform);
 }
 
 #[async_trait]
@@ -332,10 +333,12 @@ impl CtrlTask for CtrlPlatform {
         let platform1 = self.clone();
         let platform2 = self.clone();
         self.create_sys_event_tasks(
-            move || {},
+            move || async { {} },
             move || {
-                info!("CtrlRogBios reloading panel_od");
-                if let Some(lock) = platform1.config.try_lock() {
+                let platform1 = platform1.clone();
+                async move {
+                    info!("CtrlRogBios reloading panel_od");
+                    let lock = platform1.config.lock().await;
                     if platform1.platform.has_panel_od() {
                         platform1
                             .set_panel_overdrive(lock.panel_od)
@@ -347,10 +350,12 @@ impl CtrlTask for CtrlPlatform {
                     }
                 }
             },
-            move || {},
+            move || async { {} },
             move || {
-                info!("CtrlRogBios reloading panel_od");
-                if let Some(lock) = platform2.config.try_lock() {
+                let platform2 = platform2.clone();
+                async move {
+                    info!("CtrlRogBios reloading panel_od");
+                    let lock = platform2.config.lock().await;
                     if platform2.platform.has_panel_od() {
                         platform2
                             .set_panel_overdrive(lock.panel_od)
@@ -368,7 +373,9 @@ impl CtrlTask for CtrlPlatform {
         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?;
+        // NOTE: Can't have this as a watch because on a write to it, it reverts back to booted-with value
+        //  as it does not actually change until reboot.
+        //self.watch_gpu_mux_mode(signal_ctxt.clone()).await?;
 
         Ok(())
     }

daemon/src/ctrl_power.rs

@@ -1,10 +1,13 @@
-use crate::systemd::{do_systemd_unit_action, SystemdUnitAction};
+use crate::systemd::{
+    do_systemd_unit_action, is_systemd_unit_enabled, SystemdUnitAction, SystemdUnitState,
+};
 use crate::{config::Config, error::RogError, GetSupported};
 use crate::{task_watch_item, CtrlTask};
 use async_trait::async_trait;
-use log::{info, warn};
+use log::{error, info, warn};
 use rog_platform::power::AsusPower;
 use rog_platform::supported::ChargeSupportedFunctions;
+use std::process::Command;
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::time::sleep;
@@ -155,10 +158,12 @@ impl CtrlTask for CtrlPower {
         let power1 = self.clone();
         let power2 = self.clone();
         self.create_sys_event_tasks(
-            move || {},
+            move || async {},
             move || {
-                info!("CtrlCharge reloading charge limit");
-                if let Some(lock) = power1.config.try_lock() {
+                let power1 = power1.clone();
+                async move {
+                    info!("CtrlCharge reloading charge limit");
+                    let lock = power1.config.lock().await;
                     power1
                         .set(lock.bat_charge_limit)
                         .map_err(|err| {
@@ -166,22 +171,18 @@ impl CtrlTask for CtrlPower {
                             err
                         })
                         .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}");
+
+                    if let Ok(value) = power1.power.get_online() {
+                        do_nvidia_powerd_action(value == 1);
                     }
                 }
             },
-            move || {},
+            move || async {},
             move || {
-                info!("CtrlCharge reloading charge limit");
-                if let Some(lock) = power2.config.try_lock() {
+                let power2 = power2.clone();
+                async move {
+                    info!("CtrlCharge reloading charge limit");
+                    let lock = power2.config.lock().await;
                     power2
                         .set(lock.bat_charge_limit)
                         .map_err(|err| {
@@ -189,21 +190,16 @@ impl CtrlTask for CtrlPower {
                             err
                         })
                         .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}");
+
+                    if let Ok(value) = power2.power.get_online() {
+                        do_nvidia_powerd_action(value == 1);
                     }
                 }
             },
         )
         .await;
 
+        let config = self.config.clone();
         self.watch_charge_control_end_threshold(signal_ctxt.clone())
             .await?;
 
@@ -214,18 +210,36 @@ impl CtrlTask for CtrlPower {
                 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}");
-                        }
+                        do_nvidia_powerd_action(value == 1);
 
                         Self::notify_mains_online(&signal_ctxt, value == 1)
                             .await
                             .unwrap();
+
+                        let mut config = config.lock().await;
+                        config.read();
+                        let mut prog: Vec<&str> = Vec::new();
+                        if value == 1 {
+                            // AC ONLINE
+                            prog = config.ac_command.split_whitespace().collect();
+                        } else if value == 0 {
+                            // BATTERY
+                            prog = config.bat_command.split_whitespace().collect();
+                        }
+
+                        if prog.len() > 1 {
+                            let mut cmd = Command::new(prog[0]);
+                            for arg in prog.iter().skip(1) {
+                                cmd.arg(*arg);
+                            }
+                            if let Err(e) = cmd.spawn() {
+                                if value == 1 {
+                                    error!("AC power command error: {e}");
+                                } else {
+                                    error!("Battery power command error: {e}");
+                                }
+                            }
+                        }
                     }
                 }
                 // The inotify doesn't pick up events when the kernel changes internal value
@@ -237,3 +251,17 @@ impl CtrlTask for CtrlPower {
         Ok(())
     }
 }
+
+fn do_nvidia_powerd_action(ac_on: bool) {
+    let action = if ac_on {
+        SystemdUnitAction::Restart
+    } else {
+        SystemdUnitAction::Stop
+    };
+
+    if let Ok(res) = is_systemd_unit_enabled(SystemdUnitState::Enabled, NVIDIA_POWERD) {
+        if res && do_systemd_unit_action(action, NVIDIA_POWERD).is_ok() {
+            info!("CtrlPower task: did {action:?} on {NVIDIA_POWERD}");
+        }
+    }
+}

daemon/src/ctrl_profiles/trait_impls.rs

@@ -200,8 +200,36 @@ impl CtrlTask for ProfileZbus {
     }
 
     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()?;
+        // let sig_ctx = signal_ctxt.clone();
+        // 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(&sig_ctx, lock.config.active_profile)
+        //                 .await
+        //                 .ok();
+        //         })
+        //         .await;
+        // });
+
         let ctrl = self.0.clone();
-        let mut watch = self.0.lock().await.platform.monitor_platform_profile()?;
+        let mut watch = self
+            .0
+            .lock()
+            .await
+            .platform
+            .monitor_throttle_thermal_policy()?;
 
         tokio::spawn(async move {
             let mut buffer = [0; 32];
@@ -210,13 +238,15 @@ impl CtrlTask for ProfileZbus {
                 .unwrap()
                 .for_each(|_| async {
                     let mut lock = ctrl.lock().await;
-                    let new_profile = Profile::get_active_profile().unwrap();
+                    let new_thermal = lock.platform.get_throttle_thermal_policy().unwrap();
+                    let new_profile = Profile::from_throttle_thermal_policy(new_thermal);
                     if new_profile != lock.config.active_profile {
                         lock.config.active_profile = new_profile;
                         lock.write_profile_curve_to_platform().unwrap();
                         lock.save_config();
+                        Profile::set_profile(lock.config.active_profile).unwrap();
                     }
-                    Self::notify_profile(&signal_ctxt.clone(), lock.config.active_profile)
+                    Self::notify_profile(&signal_ctxt, lock.config.active_profile)
                         .await
                         .ok();
                 })

daemon/src/daemon.rs

@@ -7,7 +7,6 @@ use std::time::Duration;
 use ::zbus::export::futures_util::lock::Mutex;
 use ::zbus::Connection;
 use daemon::ctrl_anime::CtrlAnime;
-use log::LevelFilter;
 use log::{error, info, warn};
 use tokio::time::sleep;
 use zbus::SignalContext;
@@ -33,9 +32,9 @@ static PROFILE_CONFIG_PATH: &str = "/etc/asusd/profile.conf";
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut logger = env_logger::Builder::new();
     logger
+        .parse_default_env()
         .target(env_logger::Target::Stdout)
         .format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()))
-        .filter(None, LevelFilter::Info)
         .init();
 
     let is_service = match env::var_os("IS_SERVICE") {

daemon/src/lib.rs

@@ -21,9 +21,11 @@ pub mod ctrl_supported;
 
 pub mod error;
 
+use std::future::Future;
+
 use crate::error::RogError;
 use async_trait::async_trait;
-use log::warn;
+use log::{debug, warn};
 use logind_zbus::manager::ManagerProxy;
 use zbus::{export::futures_util::StreamExt, zvariant::ObjectPath, Connection, SignalContext};
 
@@ -134,13 +136,31 @@ pub trait CtrlTask {
     ///
     /// The closures can potentially block, so execution time should be the minimal possible
     /// such as save a variable.
-    async fn create_sys_event_tasks(
+    async fn create_sys_event_tasks<
+        Fut1,
+        Fut2,
+        Fut3,
+        Fut4,
+        F1: Send + 'static,
+        F2: Send + 'static,
+        F3: Send + 'static,
+        F4: Send + 'static,
+    >(
         &self,
-        mut on_sleep: impl FnMut() + Send + 'static,
-        mut on_wake: impl FnMut() + Send + 'static,
-        mut on_shutdown: impl FnMut() + Send + 'static,
-        mut on_boot: impl FnMut() + Send + 'static,
-    ) {
+        mut on_sleep: F1,
+        mut on_wake: F2,
+        mut on_shutdown: F3,
+        mut on_boot: F4,
+    ) where
+        F1: FnMut() -> Fut1,
+        F2: FnMut() -> Fut2,
+        F3: FnMut() -> Fut3,
+        F4: FnMut() -> Fut4,
+        Fut1: Future<Output = ()> + Send,
+        Fut2: Future<Output = ()> + Send,
+        Fut3: Future<Output = ()> + Send,
+        Fut4: Future<Output = ()> + Send,
+    {
         let connection = Connection::system()
             .await
             .expect("Controller could not create dbus connection");
@@ -154,9 +174,11 @@ pub trait CtrlTask {
                 while let Some(event) = notif.next().await {
                     if let Ok(args) = event.args() {
                         if args.start {
-                            on_sleep();
+                            debug!("Doing on_sleep()");
+                            on_sleep().await;
                         } else if !args.start() {
-                            on_wake();
+                            debug!("Doing on_wake()");
+                            on_wake().await;
                         }
                     }
                 }
@@ -172,9 +194,11 @@ pub trait CtrlTask {
                 while let Some(event) = notif.next().await {
                     if let Ok(args) = event.args() {
                         if args.start {
-                            on_shutdown();
+                            debug!("Doing on_shutdown()");
+                            on_shutdown().await;
                         } else if !args.start() {
-                            on_boot();
+                            debug!("Doing on_boot()");
+                            on_boot().await;
                         }
                     }
                 }

daemon/src/systemd.rs

@@ -24,6 +24,9 @@ impl From<SystemdUnitAction> for &str {
 pub enum SystemdUnitState {
     Active,
     Inactive,
+    Masked,
+    Disabled,
+    Enabled,
 }
 
 impl From<SystemdUnitState> for &str {
@@ -31,6 +34,9 @@ impl From<SystemdUnitState> for &str {
         match s {
             SystemdUnitState::Active => "active",
             SystemdUnitState::Inactive => "inactive",
+            SystemdUnitState::Masked => "masked",
+            SystemdUnitState::Disabled => "disabled",
+            SystemdUnitState::Enabled => "enabled",
         }
     }
 }
@@ -66,6 +72,21 @@ pub fn is_systemd_unit_state(state: SystemdUnitState, unit: &str) -> Result<bool
     Ok(false)
 }
 
+/// Get systemd unit state. Blocks while command is run.
+pub fn is_systemd_unit_enabled(state: SystemdUnitState, unit: &str) -> Result<bool, RogError> {
+    let mut cmd = Command::new("systemctl");
+    cmd.arg("is-enabled");
+    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");

data/asusd-ledmodes.toml

@@ -1,3 +1,10 @@
+[[led_data]]
+prod_family = "ASUS TUF Gaming F15"
+board_names = ["FX506HC"]
+standard = ["Static", "Breathe", "Strobe", "Pulse"]
+multizone = []
+per_key = false
+
 [[led_data]]
 prod_family = "TUF"
 board_names = ["FA507"]

data/asusd.service

@@ -6,6 +6,7 @@ Before=multi-user.target
 
 [Service]
 Environment=IS_SERVICE=1
+Environment=RUST_LOG="info"
 ExecStartPre=/bin/sleep 2
 ExecStart=/usr/bin/asusd
 Restart=on-failure

rog-control-center/Cargo.toml

@@ -10,8 +10,7 @@ mocking = []
 
 [dependencies]
 egui = { git = "https://github.com/flukejones/egui", branch = "wayland_dark_theme" }
-eframe= { git = "https://github.com/flukejones/egui", branch = "wayland_dark_theme" }
-#eframe= { git = "https://github.com/emilk/egui", default-features = false, features = ["dark-light", "default_fonts", "wgpu"] }
+eframe = { git = "https://github.com/flukejones/egui", branch = "wayland_dark_theme" }
 
 libappindicator = "0.7" # Tray icon
 gtk = "0.15.5"
@@ -23,7 +22,6 @@ rog_aura = { path = "../rog-aura" }
 rog_profiles = { path = "../rog-profiles" }
 rog_platform = { path = "../rog-platform" }
 supergfxctl = { git = "https://gitlab.com/asus-linux/supergfxctl.git", default-features = false }
-#supergfxctl = { path = "../../supergfxctl", default-features = false }
 
 log.workspace = true
 env_logger.workspace = true
@@ -41,5 +39,3 @@ png_pong.workspace = true
 
 nix = "^0.26.1"
 tempfile = "3.3.0"
-
-once_cell = "1.10.0"

rog-control-center/src/config.rs

@@ -4,19 +4,20 @@ use std::{
     fs::{create_dir, OpenOptions},
     io::{Read, Write},
 };
-//use log::{error, info, warn};
 
-use crate::{error::Error, notify::EnabledNotifications};
+use crate::{error::Error, update_and_notify::EnabledNotifications};
 
 const CFG_DIR: &str = "rog";
 const CFG_FILE_NAME: &str = "rog-control-center.cfg";
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(default)]
 pub struct Config {
     pub run_in_background: bool,
     pub startup_in_background: bool,
+    pub ac_command: String,
+    pub bat_command: String,
     pub enable_notifications: bool,
+    // This field must be last
     pub enabled_notifications: EnabledNotifications,
 }
 
@@ -27,6 +28,8 @@ impl Default for Config {
             startup_in_background: false,
             enable_notifications: true,
             enabled_notifications: EnabledNotifications::default(),
+            ac_command: String::new(),
+            bat_command: String::new(),
         }
     }
 }
@@ -67,6 +70,9 @@ impl Config {
             } else if let Ok(data) = toml::from_str::<Config>(&buf) {
                 info!("Loaded config file {path:?}");
                 return Ok(data);
+            } else if let Ok(data) = toml::from_str::<Config455>(&buf) {
+                info!("Loaded old v4.5.5 config file {path:?}");
+                return Ok(data.into());
             }
         }
         Err(Error::ConfigLoadFail)
@@ -100,3 +106,24 @@ impl Config {
         Ok(())
     }
 }
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct Config455 {
+    pub run_in_background: bool,
+    pub startup_in_background: bool,
+    pub enable_notifications: bool,
+    pub enabled_notifications: EnabledNotifications,
+}
+
+impl From<Config455> for Config {
+    fn from(c: Config455) -> Self {
+        Self {
+            run_in_background: c.run_in_background,
+            startup_in_background: c.startup_in_background,
+            enable_notifications: c.enable_notifications,
+            enabled_notifications: c.enabled_notifications,
+            ac_command: String::new(),
+            bat_command: String::new(),
+        }
+    }
+}

rog-control-center/src/lib.rs

@@ -13,11 +13,11 @@ pub mod config;
 pub mod error;
 #[cfg(feature = "mocking")]
 pub mod mocking;
-pub mod notify;
 pub mod pages;
 pub mod startup_error;
 pub mod system_state;
 pub mod tray;
+pub mod update_and_notify;
 pub mod widgets;
 
 #[cfg(feature = "mocking")]

rog-control-center/src/main.rs

@@ -1,12 +1,12 @@
 use eframe::{IconData, NativeOptions};
-use log::{error, info, LevelFilter};
+use log::{error, info};
 use rog_aura::layouts::KeyLayout;
-use rog_control_center::notify::EnabledNotifications;
 use rog_control_center::tray::init_tray;
+use rog_control_center::update_and_notify::EnabledNotifications;
 use rog_control_center::{
-    config::Config, error::Result, get_ipc_file, notify::start_notifications, on_tmp_dir_exists,
-    print_versions, startup_error::AppErrorShow, system_state::SystemState, RogApp,
-    RogDbusClientBlocking, SHOWING_GUI, SHOW_GUI,
+    config::Config, error::Result, get_ipc_file, on_tmp_dir_exists, print_versions,
+    startup_error::AppErrorShow, system_state::SystemState, update_and_notify::start_notifications,
+    RogApp, RogDbusClientBlocking, SHOWING_GUI, SHOW_GUI,
 };
 use rog_platform::supported::SupportedFunctions;
 use std::sync::Mutex;
@@ -29,9 +29,9 @@ fn main() -> Result<()> {
     print_versions();
     let mut logger = env_logger::Builder::new();
     logger
+        .parse_default_env()
         .target(env_logger::Target::Stdout)
         .format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()))
-        .filter(None, LevelFilter::Info)
         .init();
 
     // start tokio
@@ -118,7 +118,7 @@ fn main() -> Result<()> {
         Err(_) => on_tmp_dir_exists().unwrap(),
     };
 
-    let states = setup_page_state_and_notifs(layout, enabled_notifications, &supported)?;
+    let states = setup_page_state_and_notifs(layout, enabled_notifications, &config, &supported)?;
 
     init_tray(supported, states.clone());
 
@@ -153,6 +153,7 @@ fn main() -> Result<()> {
 fn setup_page_state_and_notifs(
     keyboard_layout: KeyLayout,
     enabled_notifications: Arc<Mutex<EnabledNotifications>>,
+    config: &Config,
     supported: &SupportedFunctions,
 ) -> Result<Arc<Mutex<SystemState>>> {
     let page_states = Arc::new(Mutex::new(SystemState::new(
@@ -161,7 +162,7 @@ fn setup_page_state_and_notifs(
         supported,
     )?));
 
-    start_notifications(page_states.clone(), enabled_notifications)?;
+    start_notifications(config, page_states.clone(), enabled_notifications)?;
 
     Ok(page_states)
 }

rog-control-center/src/system_state.rs

@@ -12,7 +12,7 @@ use supergfxctl::{
     zbus_proxy::DaemonProxyBlocking as GfxProxyBlocking,
 };
 
-use crate::{error::Result, notify::EnabledNotifications, RogDbusClientBlocking};
+use crate::{error::Result, update_and_notify::EnabledNotifications, RogDbusClientBlocking};
 use log::error;
 
 #[derive(Clone, Debug, Default)]
@@ -219,6 +219,7 @@ impl AnimeState {
 
 #[derive(Clone, Debug)]
 pub struct GfxState {
+    pub has_supergfx: bool,
     pub mode: GfxMode,
     pub power_status: GfxPower,
 }
@@ -226,8 +227,9 @@ pub struct GfxState {
 impl GfxState {
     pub fn new(_supported: &SupportedFunctions, dbus: &GfxProxyBlocking<'_>) -> Result<Self> {
         Ok(Self {
-            mode: dbus.mode()?,
-            power_status: dbus.power()?,
+            has_supergfx: dbus.mode().is_ok(),
+            mode: dbus.mode().unwrap_or(GfxMode::None),
+            power_status: dbus.power().unwrap_or(GfxPower::Unknown),
         })
     }
 }
@@ -235,6 +237,7 @@ impl GfxState {
 impl Default for GfxState {
     fn default() -> Self {
         Self {
+            has_supergfx: false,
             mode: GfxMode::None,
             power_status: GfxPower::Unknown,
         }
@@ -401,6 +404,7 @@ impl Default for SystemState {
                 drag_delta: Default::default(),
             },
             gfx_state: GfxState {
+                has_supergfx: false,
                 mode: GfxMode::None,
                 power_status: GfxPower::Unknown,
             },

rog-control-center/src/tray.rs

@@ -4,6 +4,7 @@
 use std::{
     io::Write,
     sync::{
+        atomic::{AtomicBool, Ordering},
         mpsc::{channel, Receiver},
         Arc, Mutex,
     },
@@ -21,7 +22,7 @@ use supergfxctl::{
     zbus_proxy::DaemonProxyBlocking as GfxProxyBlocking,
 };
 
-use log::{debug, error, info, trace};
+use log::{debug, error, info, trace, warn};
 
 const TRAY_APP_ICON: &str = "rog-control-center";
 const TRAY_LABEL: &str = "ROG Control Center";
@@ -241,7 +242,10 @@ impl ROGTray {
     }
 
     fn menu_add_gpu(&mut self, supported: &SupportedFunctions, current_mode: GfxMode) {
+        let set_mux_off = Arc::new(AtomicBool::new(false));
+
         let gfx_dbus = self.gfx_proxy.clone();
+        let set_mux_off1 = set_mux_off.clone();
         let mut gpu_menu = RadioGroup::new("Integrated", move |_| {
             let mode = gfx_dbus
                 .mode()
@@ -259,9 +263,11 @@ impl ROGTray {
                     })
                     .ok();
             }
+            set_mux_off1.store(true, Ordering::Relaxed);
         });
 
         let gfx_dbus = self.gfx_proxy.clone();
+        let set_mux_off1 = set_mux_off.clone();
         gpu_menu.add("Hybrid", move |_| {
             let mode = gfx_dbus
                 .mode()
@@ -279,7 +285,33 @@ impl ROGTray {
                     })
                     .ok();
             }
+            set_mux_off1.store(true, Ordering::Relaxed);
         });
+        if supported.rog_bios_ctrl.egpu_enable {
+            let set_mux_off1 = set_mux_off.clone();
+            let gfx_dbus = self.gfx_proxy.clone();
+            gpu_menu.add("eGPU", move |_| {
+                let mode = gfx_dbus
+                    .mode()
+                    .map_err(|e| {
+                        error!("ROGTray: mode: {e}");
+                        e
+                    })
+                    .unwrap_or(GfxMode::None);
+                if mode != GfxMode::Egpu {
+                    gfx_dbus
+                        .set_mode(&GfxMode::Egpu)
+                        .map_err(|e| {
+                            error!("ROGTray: set_mode: {e}");
+                            e
+                        })
+                        .ok();
+                }
+                set_mux_off1.store(true, Ordering::Relaxed);
+            });
+        }
+
+        let mut reboot_required = false;
         if supported.rog_bios_ctrl.gpu_mux {
             let gfx_dbus = self.bios_proxy.clone();
             gpu_menu.add("Ultimate (Reboot required)", move |_| {
@@ -300,35 +332,95 @@ impl ROGTray {
                         .ok();
                 }
             });
-        }
-        if supported.rog_bios_ctrl.egpu_enable {
-            let gfx_dbus = self.gfx_proxy.clone();
-            gpu_menu.add("eGPU", move |_| {
-                let mode = gfx_dbus
-                    .mode()
+
+            if set_mux_off.load(Ordering::Relaxed) {
+                warn!("Selected non-dgpu mode, must set MUX to optimus");
+                self.bios_proxy
+                    .set_gpu_mux_mode(GpuMode::Optimus)
                     .map_err(|e| {
-                        error!("ROGTray: mode: {e}");
+                        error!("ROGTray: set_mode: {e}");
                         e
                     })
-                    .unwrap_or(GfxMode::None);
-                if mode != GfxMode::Egpu {
-                    gfx_dbus
-                        .set_mode(&GfxMode::Egpu)
-                        .map_err(|e| {
-                            error!("ROGTray: set_mode: {e}");
-                            e
-                        })
-                        .ok();
-                }
-            });
+                    .ok();
+            }
+
+            if let Ok(mode) = self.bios_proxy.gpu_mux_mode() {
+                let mode = match mode {
+                    GpuMode::Discrete => GfxMode::AsusMuxDiscreet,
+                    _ => GfxMode::Hybrid,
+                };
+                reboot_required = mode != current_mode;
+            }
         }
 
         let active = match current_mode {
             GfxMode::AsusMuxDiscreet => "Discreet".to_owned(),
             _ => current_mode.to_string(),
         };
+
+        let reboot_required = if reboot_required {
+            "(Reboot required)"
+        } else {
+            ""
+        };
+
         self.add_radio_sub_menu(
-            &format!("GPU Mode: {current_mode}"),
+            &format!("GPU Mode: {active} {reboot_required}"),
+            active.as_str(),
+            &gpu_menu,
+        );
+
+        debug!("ROGTray: appended gpu menu");
+    }
+
+    fn menu_add_mux(&mut self, current_mode: GfxMode) {
+        let gfx_dbus = self.bios_proxy.clone();
+
+        let mut reboot_required = false;
+        if let Ok(mode) = gfx_dbus.gpu_mux_mode() {
+            let mode = match mode {
+                GpuMode::Discrete => GfxMode::AsusMuxDiscreet,
+                _ => GfxMode::Hybrid,
+            };
+            reboot_required = mode != current_mode;
+        }
+
+        let mut gpu_menu = RadioGroup::new("Optimus", move |_| {
+            gfx_dbus
+                .set_gpu_mux_mode(GpuMode::Optimus)
+                .map_err(|e| {
+                    error!("ROGTray: set_mode: {e}");
+                    e
+                })
+                .ok();
+            debug!("Setting GPU mode: {}", GpuMode::Optimus);
+        });
+
+        let gfx_dbus = self.bios_proxy.clone();
+        gpu_menu.add("Ultimate", move |_| {
+            gfx_dbus
+                .set_gpu_mux_mode(GpuMode::Discrete)
+                .map_err(|e| {
+                    error!("ROGTray: set_mode: {e}");
+                    e
+                })
+                .ok();
+            debug!("Setting GPU mode: {}", GpuMode::Discrete);
+        });
+
+        let active = match current_mode {
+            GfxMode::AsusMuxDiscreet => "Ultimate".to_owned(),
+            GfxMode::Hybrid => "Optimus".to_owned(),
+            _ => current_mode.to_string(),
+        };
+        debug!("Current active GPU mode: {}", active);
+        let reboot_required = if reboot_required {
+            "(Reboot required)"
+        } else {
+            ""
+        };
+        self.add_radio_sub_menu(
+            &format!("GPU Mode: {active} {reboot_required}"),
             active.as_str(),
             &gpu_menu,
         );
@@ -351,6 +443,7 @@ impl ROGTray {
     fn rebuild_and_update(
         &mut self,
         supported: &SupportedFunctions,
+        has_supergfx: bool,
         current_gfx_mode: GfxMode,
         charge_limit: u8,
         panel_od: bool,
@@ -359,7 +452,11 @@ impl ROGTray {
         self.menu_add_base();
         self.menu_add_charge_limit(supported, charge_limit);
         self.menu_add_panel_od(supported, panel_od);
-        self.menu_add_gpu(supported, current_gfx_mode);
+        if has_supergfx {
+            self.menu_add_gpu(supported, current_gfx_mode);
+        } else if supported.rog_bios_ctrl.gpu_mux {
+            self.menu_add_mux(current_gfx_mode);
+        }
         self.menu_update();
     }
 }
@@ -371,6 +468,12 @@ pub fn init_tray(
     let (send, recv) = channel();
     let _send = Arc::new(Mutex::new(send));
 
+    let has_supergfx = if let Ok(lock) = states.try_lock() {
+        lock.gfx_state.has_supergfx
+    } else {
+        false
+    };
+
     std::thread::spawn(move || {
         if gtk::init()
             .map_err(|e| {
@@ -396,16 +499,26 @@ pub fn init_tray(
                 return;
             }
         };
-        tray.rebuild_and_update(&supported, GfxMode::Hybrid, 100, false);
+        tray.rebuild_and_update(&supported, has_supergfx, GfxMode::Hybrid, 100, false);
         tray.set_icon(TRAY_APP_ICON);
         info!("Started ROGTray");
 
         loop {
             if let Ok(mut lock) = states.lock() {
                 if lock.tray_should_update {
+                    // Supergfx ends up adding some complexity to handle if it isn't available
+                    let current_gpu_mode = if lock.gfx_state.has_supergfx {
+                        lock.gfx_state.mode
+                    } else {
+                        match lock.bios.dedicated_gfx {
+                            GpuMode::Discrete => GfxMode::AsusMuxDiscreet,
+                            _ => GfxMode::Hybrid,
+                        }
+                    };
                     tray.rebuild_and_update(
                         &supported,
-                        lock.gfx_state.mode,
+                        has_supergfx,
+                        current_gpu_mode,
                         lock.power_state.charge_limit,
                         lock.bios.panel_overdrive,
                     );
@@ -419,7 +532,13 @@ pub fn init_tray(
                         GfxPower::AsusMuxDiscreet | GfxPower::Active => {
                             tray.set_icon("asus_notif_red");
                         }
-                        GfxPower::Unknown => tray.set_icon("gpu-integrated"),
+                        GfxPower::Unknown => {
+                            if has_supergfx {
+                                tray.set_icon("gpu-integrated");
+                            } else {
+                                tray.set_icon("asus_notif_red");
+                            }
+                        }
                     };
                 }
             }

rog-control-center/src/update_and_notify.rs

@@ -1,5 +1,9 @@
+//! `update_and_notify` is responsible for both notifications *and* updating stored statuses
+//! about the system state. This is done through either direct, intoify, zbus notifications
+//! or similar methods.
+
 use crate::{config::Config, error::Result, system_state::SystemState};
-use log::{error, info, trace};
+use log::{error, info, trace, warn};
 use notify_rust::{Hint, Notification, NotificationHandle, Urgency};
 use rog_dbus::{
     zbus_anime::AnimeProxy, zbus_led::LedProxy, zbus_platform::RogBiosProxy,
@@ -12,12 +16,17 @@ use std::{
     fmt::Display,
     process::Command,
     sync::{Arc, Mutex},
+    time::Duration,
 };
 use supergfxctl::{pci_device::GfxPower, zbus_proxy::DaemonProxy as SuperProxy};
+use tokio::time::sleep;
 use zbus::export::futures_util::{future, StreamExt};
 
 const NOTIF_HEADER: &str = "ROG Control";
 
+static mut POWER_AC_CMD: Option<Command> = None;
+static mut POWER_BAT_CMD: Option<Command> = None;
+
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(default)]
 pub struct EnabledNotifications {
@@ -48,7 +57,7 @@ impl Default for EnabledNotifications {
             receive_notify_charge_control_end_threshold: true,
             receive_notify_mains_online: false,
             receive_notify_profile: true,
-            receive_notify_led: false,
+            receive_notify_led: true,
             receive_power_states: false,
             receive_notify_gfx: false,
             receive_notify_gfx_status: false,
@@ -125,11 +134,36 @@ macro_rules! recv_notif {
 type SharedHandle = Arc<Mutex<Option<NotificationHandle>>>;
 
 pub fn start_notifications(
+    config: &Config,
     page_states: Arc<Mutex<SystemState>>,
     enabled_notifications: Arc<Mutex<EnabledNotifications>>,
 ) -> Result<()> {
     let last_notification: SharedHandle = Arc::new(Mutex::new(None));
 
+    // Setup the AC/BAT commands that will run on poweer status change
+    unsafe {
+        let prog: Vec<&str> = config.ac_command.split_whitespace().collect();
+        if prog.len() > 1 {
+            let mut cmd = Command::new(prog[0]);
+
+            for arg in prog.iter().skip(1) {
+                cmd.arg(*arg);
+            }
+            POWER_AC_CMD = Some(cmd);
+        }
+    }
+    unsafe {
+        let prog: Vec<&str> = config.bat_command.split_whitespace().collect();
+        if prog.len() > 1 {
+            let mut cmd = Command::new(prog[0]);
+
+            for arg in prog.iter().skip(1) {
+                cmd.arg(*arg);
+            }
+            POWER_BAT_CMD = Some(cmd);
+        }
+    }
+
     // BIOS notif
     recv_notif!(
         RogBiosProxy,
@@ -179,18 +213,6 @@ pub fn start_notifications(
         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
     recv_notif!(
         PowerProxy,
@@ -271,104 +293,139 @@ pub fn start_notifications(
         };
     });
 
-    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
-    // );
-
+    let page_states1 = page_states.clone();
+    let last_notification1 = last_notification.clone();
     tokio::spawn(async move {
         let conn = zbus::Connection::system()
             .await
             .map_err(|e| {
-                error!("zbus signal: receive_notify_action: {e}");
+                error!("zbus signal: receive_notify_gpu_mux_mode: {e}");
                 e
             })
             .unwrap();
-        let proxy = SuperProxy::new(&conn)
+        let proxy = RogBiosProxy::new(&conn)
             .await
             .map_err(|e| {
-                error!("zbus signal: receive_notify_action: {e}");
+                error!("zbus signal: receive_notify_gpu_mux_mode: {e}");
                 e
             })
             .unwrap();
-        if let Ok(mut p) = proxy.receive_notify_action().await {
-            info!("Started zbus signal thread: receive_notify_action");
+        if let Ok(mut p) = proxy.receive_notify_gpu_mux_mode().await {
+            info!("Started zbus signal thread: receive_power_states");
             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:?}",))
-                        .map_err(|e| {
-                            error!("zbus signal: do_gfx_action_notif: {e}");
-                            e
-                        })
-                        .unwrap();
-                }
-            }
-        };
-    });
-
-    let notifs_enabled1 = enabled_notifications;
-    let last_notif = last_notification;
-    tokio::spawn(async move {
-        let conn = zbus::Connection::system()
-            .await
-            .map_err(|e| {
-                error!("zbus signal: receive_notify_gfx_status: {e}");
-                e
-            })
-            .unwrap();
-        let proxy = SuperProxy::new(&conn)
-            .await
-            .map_err(|e| {
-                error!("zbus signal: receive_notify_gfx_status: {e}");
-                e
-            })
-            .unwrap();
-        if let Ok(mut p) = proxy.receive_notify_gfx_status().await {
-            info!("Started zbus signal thread: receive_notify_gfx_status");
-            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
-                                    );
-                                }
-                            }
-                        }
-                        if let Ok(mut lock) = page_states.lock() {
-                            lock.gfx_state.power_status = status;
-                            lock.set_notified();
+                    if let Ok(mut lock) = page_states1.lock() {
+                        lock.bios.dedicated_gfx = out.mode;
+                        lock.set_notified();
+                    }
+                    if let Ok(ref mut lock) = last_notification1.lock() {
+                        if let Some(notif) = lock.take() {
+                            notif.close();
                         }
                     }
+                    do_mux_notification("Reboot required. BIOS GPU MUX mode set to", &out.mode)
+                        .ok();
                 }
             }
         };
     });
 
+    if let Ok(lock) = page_states.try_lock() {
+        use supergfxctl::pci_device::Device;
+        let dev = Device::find().unwrap_or_default();
+        let mut found_dgpu = false; // just for logging
+        for dev in dev {
+            if dev.is_dgpu() {
+                let notifs_enabled1 = enabled_notifications.clone();
+                let last_notif = last_notification.clone();
+                let page_states1 = page_states.clone();
+                // Plain old thread is perfectly fine since most of this is potentially blocking
+                tokio::spawn(async move {
+                    let mut last_status = GfxPower::Unknown;
+                    loop {
+                        if let Ok(status) = dev.get_runtime_status() {
+                            if status != GfxPower::Unknown && status != last_status {
+                                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
+                                            );
+                                        }
+                                    }
+                                }
+                                if let Ok(mut lock) = page_states1.lock() {
+                                    lock.gfx_state.power_status = status;
+                                    lock.set_notified();
+                                }
+                                last_status = status;
+                            }
+                        }
+                        sleep(Duration::from_millis(500)).await;
+                    }
+                });
+                found_dgpu = true;
+                break;
+            }
+        }
+        if !found_dgpu {
+            warn!("Did not find a dGPU on this system, dGPU status won't be avilable");
+        }
+
+        if lock.gfx_state.has_supergfx {
+            recv_notif!(
+                SuperProxy,
+                receive_notify_gfx,
+                last_notification,
+                enabled_notifications,
+                page_states,
+                (gfx_state.mode),
+                (mode),
+                "Gfx mode changed to",
+                do_notification
+            );
+
+            tokio::spawn(async move {
+                let conn = zbus::Connection::system()
+                    .await
+                    .map_err(|e| {
+                        error!("zbus signal: receive_notify_action: {e}");
+                        e
+                    })
+                    .unwrap();
+                let proxy = SuperProxy::new(&conn)
+                    .await
+                    .map_err(|e| {
+                        error!("zbus signal: receive_notify_action: {e}");
+                        e
+                    })
+                    .unwrap();
+                if let Ok(mut p) = proxy.receive_notify_action().await {
+                    info!("Started zbus signal thread: receive_notify_action");
+                    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:?}",),
+                            )
+                            .map_err(|e| {
+                                error!("zbus signal: do_gfx_action_notif: {e}");
+                                e
+                            })
+                            .unwrap();
+                        }
+                    }
+                };
+            });
+        }
+    }
+
     Ok(())
 }
 
@@ -397,8 +454,22 @@ where
 
 fn ac_power_notification(message: &str, on: &bool) -> Result<NotificationHandle> {
     let data = if *on {
+        unsafe {
+            if let Some(cmd) = POWER_AC_CMD.as_mut() {
+                if let Err(e) = cmd.spawn() {
+                    error!("AC power command error: {e}");
+                }
+            }
+        }
         "plugged".to_owned()
     } else {
+        unsafe {
+            if let Some(cmd) = POWER_BAT_CMD.as_mut() {
+                if let Err(e) = cmd.spawn() {
+                    error!("Battery power command error: {e}");
+                }
+            }
+        }
         "unplugged".to_owned()
     };
     Ok(base_notification(message, &data).show()?)
@@ -452,10 +523,24 @@ where
 }
 
 /// 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, &"");
+fn do_mux_notification(message: &str, m: &GpuMode) -> Result<()> {
+    let mut notif = base_notification(message, &m.to_string());
+    notif.action("gnome-session-quit", "Reboot");
     notif.urgency(Urgency::Critical);
     notif.icon("system-reboot-symbolic");
     notif.hint(Hint::Transient(true));
-    Ok(notif.show()?)
+    let handle = notif.show()?;
+
+    std::thread::spawn(|| {
+        handle.wait_for_action(|id| {
+            if id == "gnome-session-quit" {
+                let mut cmd = Command::new("gnome-session-quit");
+                cmd.arg("--reboot");
+                cmd.spawn().ok();
+            } else if id == "__closed" {
+                // TODO: cancel the switching
+            }
+        })
+    });
+    Ok(())
 }

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

@@ -12,7 +12,8 @@ pub fn app_settings(config: &mut Config, states: &mut SystemState, ui: &mut Ui)
         Default::default()
     };
 
-    if ui
+    ui.label("Application settings");
+    let app_changed = ui
         .checkbox(&mut config.run_in_background, "Run in Background")
         .clicked()
         || ui
@@ -23,11 +24,19 @@ pub fn app_settings(config: &mut Config, states: &mut SystemState, ui: &mut Ui)
                 &mut enabled_notifications.all_enabled,
                 "Enable Notifications",
             )
-            .clicked()
+            .clicked();
+
+    ui.label("Notification settings");
+    let notif_changed = ui
+        .checkbox(
+            &mut enabled_notifications.receive_notify_gfx_status,
+            "Enable dGPU status notification",
+        )
+        .clicked()
         || ui
             .checkbox(
-                &mut enabled_notifications.receive_notify_gfx_status,
-                "Enable dGPU status notification",
+                &mut enabled_notifications.receive_notify_led,
+                "Enable LED mode change notification",
             )
             .clicked()
         || ui
@@ -71,8 +80,9 @@ pub fn app_settings(config: &mut Config, states: &mut SystemState, ui: &mut Ui)
                 &mut enabled_notifications.receive_notify_post_boot_sound,
                 "Enable BIOS post sound notification",
             )
-            .clicked()
-    {
+            .clicked();
+
+    if app_changed || notif_changed {
         if let Ok(mut lock) = states.enabled_notifications.lock() {
             // Replace inner content before save
             *lock = enabled_notifications;

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

@@ -93,6 +93,13 @@ pub fn rog_bios_group(supported: &SupportedFunctions, states: &mut SystemState,
 
     if supported.rog_bios_ctrl.gpu_mux {
         let mut changed = false;
+        let mut dedicated_gfx = states.bios.dedicated_gfx;
+
+        let mut reboot_required = false;
+        if let Ok(mode) = states.asus_dbus.proxies().rog_bios().gpu_mux_mode() {
+            reboot_required = mode != states.bios.dedicated_gfx;
+        }
+
         ui.group(|ui| {
             ui.vertical(|ui| {
                 ui.horizontal_wrapped(|ui| ui.label("GPU MUX mode"));
@@ -100,19 +107,23 @@ pub fn rog_bios_group(supported: &SupportedFunctions, states: &mut SystemState,
                 ui.horizontal_wrapped(|ui| {
                     changed = ui
                         .selectable_value(
-                            &mut states.bios.dedicated_gfx,
+                            &mut dedicated_gfx,
                             GpuMode::Discrete,
                             "Dedicated (Ultimate)",
                         )
                         .clicked()
                         || ui
                             .selectable_value(
-                                &mut states.bios.dedicated_gfx,
+                                &mut dedicated_gfx,
                                 GpuMode::Optimus,
                                 "Optimus (Hybrid)",
                             )
                             .clicked();
                 });
+
+                if reboot_required {
+                    ui.horizontal_wrapped(|ui| ui.heading("REBOOT REQUIRED"));
+                }
             });
         });
 
@@ -121,7 +132,7 @@ pub fn rog_bios_group(supported: &SupportedFunctions, states: &mut SystemState,
                 .asus_dbus
                 .proxies()
                 .rog_bios()
-                .set_gpu_mux_mode(states.bios.dedicated_gfx)
+                .set_gpu_mux_mode(dedicated_gfx)
                 .map_err(|err| {
                     states.error = Some(err.to_string());
                 })

rog-profiles/src/lib.rs

@@ -72,6 +72,14 @@ impl Profile {
         file.write_all(<&str>::from(profile).as_bytes())?;
         Ok(())
     }
+
+    pub fn from_throttle_thermal_policy(num: u8) -> Self {
+        match num {
+            1 => Self::Performance,
+            2 => Self::Quiet,
+            _ => Self::Balanced,
+        }
+    }
 }
 
 impl Default for Profile {

rust-toolchain

@@ -0,0 +1,9 @@
+# If you see this, run "rustup self update" to get rustup 1.23 or newer.
+
+# NOTE: above comment is for older `rustup` (before TOML support was added),
+# which will treat the first line as the toolchain name, and therefore show it
+# to the user in the error, instead of "error: invalid channel name '[toolchain]'".
+
+[toolchain]
+channel = "1.65.0"
+components = [ "rustfmt", "clippy" ]