Fixes to RCC

Closes #423

.gitignore

@@ -15,6 +15,7 @@ node-modules
 bindings/ts/*.d.ts
 bindings/ts/*.js.map
 desktop-extensions/gnome*/dist
+desktop-extensions/gnome*/@types/gir-generated
 desktop-extensions/gnome*/node_modules
 desktop-extensions/gnome*/schemas/gschemas.compiled
 desktop-extensions/gnome*/*.zip

.gitlab-ci.yml

@@ -59,6 +59,7 @@ release:
     - tags
   <<: *rust_cache
   script:
+    - cargo install cargo-vendor-filterer
     - make && make vendor
   artifacts:
     paths:

.gitlab/issue_templates/default.md

@@ -0,0 +1,24 @@
+## Issue description
+
+(Summarize the bug encountered)
+
+## Steps to reproduce
+
+(How can the issue be reproduced)
+
+## What is the current bug behavior?
+
+(What actually happens)
+
+## What is the expected correct behavior?
+
+(What you should see instead)
+
+## Relevant logs and/or screenshots
+
+(run `journalctl -b -u supergfxd > ~/supergfxd.log` and attach `~/supergfxd.log`)
+
+(Paste any relevant logs - use code blocks (```) to format console output, logs, and code, as
+it's very hard to read otherwise.)
+
+/label ~bug ~reproducable ~needs-investigation

CHANGELOG.md

@@ -5,6 +5,76 @@ 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]
+
+## [v5.0.7]
+### Changed
+- Fix to suspend process in anime thread to let custom anims run on wake.
+- Fix to reload the fan curves correctly on boot.
+- Add new config option `platform_policy_linked_epp` to set if energy_performance_preference should be paired with platform_profile/throttle_thermal_policy
+- Small fixes to rog-control-center
+
+## [v5.0.6]
+- Revert egui update due to a lot of issues arising from window closing.
+
+## [v5.0.5]
+- Resync. A release was made that was missing some commits.
+
+## [v5.0.4]
+### Changed
+- Added G834JZ led config
+- Fix in ROGCC to apply the actual effect changed
+- Re-enable all fan curves (available) in ROGCC
+- Update smithay-client-toolkit
+
+## [v5.0.3]
+### Changed
+- Fix and error in platform ppt value gets
+- Fix to asusctl CLI where an incorrect enum variant was used in throttle check
+- Turn some error messages in to warning or info to prevent confusion
+- Re-add the keyboard power settings in rogcc
+- Add two new aura dbus properties for providing some basic info on aura modes/power
+
+## [v5.0.2]
+### Changed
+- Fan-curves: nuke a few async deadlocks
+- Anime: force power/wakeup disabled to prevent idiotic random wakes
+
+## [v5.0.1]
+### Changed
+- Fix setting next fan profile
+- Fix the assud.service
+- Fix dbus signature of some power setting types for some keyboards
+
+## [v5.0.0]
+### Added
+- Gnome 45 plugin
+- Support for G513RW LED modes
+- Support Rog Ally LED modes (basic)
+- Add on_lid_closed and on_external_power_changed events for running certain tasks
+- Anime dbus: add:
+  - SetOffWhenUnplugged, also add asusctl CLI option
+  - SetOffWhenSuspended, also add asusctl CLI option
+  - SetOffWhenLidClosed, also add asusctl CLI option
+- Anime: add brightness_on_battery config option
+- Platform: add `post_animation_sound`, kernel 6.7+ requires patch
+- Add changing of CPU energy perfromance preference in relation to throttle_thermal_policy. This means that the CPU correctly behaves according to throttle_thermal_policy (and platform profile use is *removed*)
+- Add setting of throttle_thermal_policy on power plug/unplug
+
+### Changed
+- asusd: remove set_image_brightness for anime
+- asusd: refactor how certain things like display enable/builtins are toggled
+- Refactor sleep/shutdown tasks
+- rog-control-center: ensure brightness slider works correctly
+- Update `smithay-client-toolkit` for fix to issue #407
+- Remove the "sleep" animations from Anime to stop preventing the display-off
+- Anime:
+  - Ensure display is off when lid is closed and option is set
+  - Ensure display is off when on battery and option is set
+  - Ensure builtin animations run instead of custom animations if option is set
+
+### Breaking
+- DBUS stuff. Again. All of it.
+
 ## [v4.7.2]
 ### Added
 - Support for G733PZ LED modes

Cargo.toml

@@ -1,14 +1,14 @@
 [workspace]
-members = ["asusctl", "asusd", "asusd-user", "config-traits", "rog-platform", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles", "rog-control-center", "simulators"]
-default-members = ["asusctl", "asusd", "asusd-user", "rog-control-center"]
+members = ["asusctl", "asusd", "asusd-user", "config-traits", "cpuctl", "dmi-id", "rog-platform", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles", "rog-control-center", "simulators"]
+default-members = ["asusctl", "asusd", "asusd-user", "cpuctl", "rog-control-center"]
 resolver = "2"
 
 [workspace.package]
-version = "4.7.2"
+version = "5.0.7"
 
 [workspace.dependencies]
 async-trait = "^0.1"
-tokio = { version = "^1.23.0", features = ["macros", "rt-multi-thread", "time", "sync"]}
+tokio = { version = "^1.23.0", default-features = false, features = ["macros", "sync"]}
 concat-idents = "^1.1"
 dirs = "^4.0"
 smol = "^1.3"
@@ -30,7 +30,6 @@ glam = { version = "^0.22", features = ["serde"] }
 gumdrop = "^0.8"
 udev = "^0.7"
 rusb = "^0.9"
-sysfs-class = "^0.1.3"
 inotify = "^0.10.0"
 
 png_pong = "^0.8"

Makefile

@@ -112,6 +112,8 @@ vendor:
 	echo 'directory = "vendor"' >> .cargo/config
 	mv .cargo/config ./cargo-config
 	rm -rf .cargo
+	rm -rf vendor
+	cargo vendor-filterer --platform x86_64-unknown-linux-gnu vendor
 	tar pcfJ vendor_asusctl_$(VERSION).tar.xz vendor
 	rm -rf vendor
 
@@ -122,18 +124,17 @@ bindings:
 	typeshare ./rog-platform/src/ --lang=typescript --output-file=bindings/ts/platform.ts
 
 introspect:
+	gdbus introspect --system -d org.asuslinux.Daemon -o /org/asuslinux/Platform -x > bindings/dbus-xml/org-asuslinux-platform-4.xml
 	gdbus introspect --system -d org.asuslinux.Daemon -o /org/asuslinux/Aura -x > bindings/dbus-xml/org-asuslinux-aura-4.xml
 	gdbus introspect --system -d org.asuslinux.Daemon -o /org/asuslinux/Anime -x > bindings/dbus-xml/org-asuslinux-anime-4.xml
-	gdbus introspect --system -d org.asuslinux.Daemon -o /org/asuslinux/Platform -x > bindings/dbus-xml/org-asuslinux-platform-4.xml
-	gdbus introspect --system -d org.asuslinux.Daemon -o /org/asuslinux/Power -x > bindings/dbus-xml/org-asuslinux-power-4.xml
-	gdbus introspect --system -d org.asuslinux.Daemon -o /org/asuslinux/Profile -x > bindings/dbus-xml/org-asuslinux-profile-4.xml
-	gdbus introspect --system -d org.asuslinux.Daemon -o /org/asuslinux/Supported -x > bindings/dbus-xml/org-asuslinux-supported-4.xml
+	gdbus introspect --system -d org.asuslinux.Daemon -o /org/asuslinux/FanCurves -x > bindings/dbus-xml/org-asuslinux-fan-curves-4.xml
 	xmlstarlet ed -L -O -d '//interface[@name="org.freedesktop.DBus.Introspectable"]' bindings/dbus-xml/org-asuslinux-*
 	xmlstarlet ed -L -O -d '//interface[@name="org.freedesktop.DBus.Properties"]' bindings/dbus-xml/org-asuslinux-*
 	xmlstarlet ed -L -O -d '//interface[@name="org.freedesktop.DBus.Peer"]' bindings/dbus-xml/org-asuslinux-*
 
 build:
 ifeq ($(VENDORED),1)
+	cargo vendor
 	@echo "version = $(VERSION)"
 	tar pxf vendor_asusctl_$(VERSION).tar.xz
 endif

README.md

@@ -2,7 +2,7 @@
 
 [Become a Patron!](https://www.patreon.com/bePatron?u=7602281) - [Asus Linux Website](https://asus-linux.org/)
 
-**WARNING:** Many features are developed in tandem with kernel patches. If you see a feature is missing you either need a patched kernel, or v6.1 which has all my work merged upstream.
+**WARNING:** Many features are developed in tandem with kernel patches. If you see a feature is missing you either need a patched kernel or latest release.
 
 `asusd` is a utility for Linux to control many aspects of various ASUS laptops
 but can also be used with non-asus laptops with reduced features.
@@ -11,23 +11,23 @@ Now includes a GUI, `rog-control-center`.
 
 ## Kernel support
 
-**The minimum supported kernel version is 5.17**
-
-**For TUF laptops, the minimum supported kernel version is 6.1**
+**The minimum supported kernel version is 6.6**
 
 ## Goals
 
-1. To provide an interface for rootless control of some system functions most users wish to control such as fan speeds, keyboard LEDs, graphics modes.
-2. Enable third-party apps to use the above with dbus methods
-3. To make the above as easy as possible for new users
-4. Respect the users resources: be small, light, and fast
+The main goal of this work is to provide a safe and easy to use abstraction over various laptop features via DBUS, and to provide some helpful defaults and other behaviour such as toggling throttle/profile on AC/battery change.
 
-Point 3 means that the list of supported distros is very narrow - fedora is explicitly
-supported. All other distros are *not* supported (while asusd might still run fine on them).
-For best support use fedora 36+ Workstation.
+1. Provide safe dbus interface
+2. Respect the users resources: be small, light, and fast
 
 Point 4? asusd currently uses a tiny fraction of cpu time, and less than 1Mb of ram, the way
-a system-level daemon should.
+a system-level daemon should. Languages such as JS and python should never be used for system level daemons (please stop).
+
+## Keyboard LEDs
+
+The level of support for laptops is dependent on folks submitting data to include in [`./rog-aura/data/layouts/aura_support.ron`](./rog-aura/data/layouts/aura_support.ron), typically installed in `/usr/share/asusd/aura_support.ron`. This is because the controller used for keyboards and LEDs is used across many years and many laptop models, all with different firmware configurations - the only way to track this is with the file mentioned above. Why not just enable all by default? Because it confuses people.
+
+See the [rog-aura readme](./rog-aura/README.md) for more details.
 
 ## Discord
 
@@ -41,6 +41,10 @@ to this:
 ```
 Bus 001 Device 002: ID 0b05:1866 ASUSTek Computer, Inc. N-KEY Device
 ```
+or
+```
+Bus 003 Device 002: ID 0b05:19b6 ASUSTek Computer, Inc. [unknown]
+```
 
 then it may work without tweaks. Technically all other functions except the LED
 and AniMe parts should work regardless of your latop make.

asusctl/Cargo.toml

@@ -12,10 +12,10 @@ rog_dbus = { path = "../rog-dbus" }
 rog_profiles = { path = "../rog-profiles" }
 rog_platform = { path = "../rog-platform" }
 asusd = { path = "../asusd" }
+dmi_id = { path = "../dmi-id" }
 
 gumdrop.workspace = true
 toml.workspace = true
-sysfs-class.workspace = true
 
 [dev-dependencies]
 gif.workspace = true

asusctl/examples/anime-diag-png.rs

@@ -10,7 +10,7 @@ use rog_dbus::RogDbusClientBlocking;
 fn main() -> Result<(), Box<dyn Error>> {
     let (client, _) = RogDbusClientBlocking::new().unwrap();
 
-    let args: Vec<String> = env::args().into_iter().collect();
+    let args: Vec<String> = env::args().collect();
     if args.len() != 3 {
         println!("Usage: <filepath> <brightness>");
         println!("e.g, asusctl/examples/doom_large.png 0.8");

asusctl/examples/anime-diag.rs

@@ -15,13 +15,13 @@ fn main() {
 
     for step in (2..50).rev() {
         let mut matrix = AnimeDiagonal::new(AnimeType::GA401, None);
-        for c in (0..60).into_iter().step_by(step) {
+        for c in (0..60).step_by(step) {
             for i in matrix.get_mut().iter_mut() {
                 i[c] = 50;
             }
         }
 
-        for c in (0..35).into_iter().step_by(step) {
+        for c in (0..35).step_by(step) {
             for i in &mut matrix.get_mut()[c] {
                 *i = 50;
             }

asusctl/examples/anime-gif.rs

@@ -9,7 +9,7 @@ use rog_dbus::RogDbusClientBlocking;
 fn main() {
     let (client, _) = RogDbusClientBlocking::new().unwrap();
 
-    let args: Vec<String> = env::args().into_iter().collect();
+    let args: Vec<String> = env::args().collect();
     if args.len() != 3 {
         println!("Please supply filepath and brightness");
         return;

asusctl/examples/anime-png.rs

@@ -11,7 +11,7 @@ use rog_dbus::RogDbusClientBlocking;
 fn main() -> Result<(), Box<dyn Error>> {
     let (client, _) = RogDbusClientBlocking::new().unwrap();
 
-    let args: Vec<String> = env::args().into_iter().collect();
+    let args: Vec<String> = env::args().collect();
     if args.len() != 7 {
         println!("Usage: <filepath> <scale> <angle> <x pos> <y pos> <brightness>");
         println!("e.g, asusctl/examples/doom_large.png 0.9 0.4 0.0 0.0 0.8");

asusctl/examples/anime-spinning.rs

@@ -14,7 +14,7 @@ use rog_dbus::RogDbusClientBlocking;
 fn main() -> Result<(), Box<dyn Error>> {
     let (client, _) = RogDbusClientBlocking::new().unwrap();
 
-    let args: Vec<String> = env::args().into_iter().collect();
+    let args: Vec<String> = env::args().collect();
     if args.len() != 7 {
         println!("Usage: <filepath> <scale> <angle> <x pos> <y pos> <brightness>");
         println!("e.g, asusctl/examples/doom_large.png 0.9 0.4 0.0 0.0 0.8");

asusctl/examples/aura-zoned-breathe.rs

@@ -62,7 +62,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         seq.next_state(&layout);
         let packets = seq.create_packets();
 
-        client.proxies().led().direct_addressing_raw(packets)?;
+        client.proxies().aura().direct_addressing_raw(packets)?;
         std::thread::sleep(std::time::Duration::from_millis(33));
     }
 }

asusctl/src/anime_cli.rs

@@ -17,10 +17,28 @@ pub struct AnimeCommand {
         help = "set global base brightness value <Off, Low, Med, High>"
     )]
     pub brightness: Option<Brightness>,
-    #[options(meta = "", help = "set global (image) brightness value")]
-    pub image_brightness: Option<f32>,
     #[options(help = "clear the display")]
     pub clear: bool,
+    #[options(
+        no_short,
+        meta = "",
+        help = "turn the anime off when external power is unplugged"
+    )]
+    pub off_when_unplugged: Option<bool>,
+    #[options(
+        no_short,
+        meta = "",
+        help = "turn the anime off when the laptop suspends"
+    )]
+    pub off_when_suspended: Option<bool>,
+    #[options(
+        no_short,
+        meta = "",
+        help = "turn the anime off when the lid is closed"
+    )]
+    pub off_when_lid_closed: Option<bool>,
+    #[options(no_short, meta = "", help = "Off with his head!!!")]
+    pub off_with_his_head: Option<bool>,
     #[options(command)]
     pub command: Option<AnimeActions>,
 }

asusctl/src/aura_cli.rs

@@ -59,14 +59,14 @@ pub struct AuraPowerStates {
 
 #[derive(Options)]
 pub struct LedBrightness {
-    level: Option<u32>,
+    level: Option<u8>,
 }
 impl LedBrightness {
-    pub fn new(level: Option<u32>) -> Self {
+    pub fn new(level: Option<u8>) -> Self {
         LedBrightness { level }
     }
 
-    pub fn level(&self) -> Option<u32> {
+    pub fn level(&self) -> Option<u8> {
         self.level
     }
 }

asusctl/src/cli_opts.rs

@@ -1,8 +1,9 @@
 use gumdrop::Options;
+use rog_platform::platform::PlatformPolicy;
 
 use crate::anime_cli::AnimeCommand;
 use crate::aura_cli::{LedBrightness, LedPowerCommand1, LedPowerCommand2, SetAuraBuiltin};
-use crate::profiles_cli::{FanCurveCommand, ProfileCommand};
+use crate::fan_curve_cli::FanCurveCommand;
 
 #[derive(Default, Options)]
 pub struct CliStart {
@@ -44,6 +45,24 @@ pub enum CliCommand {
     Bios(BiosCommand),
 }
 
+#[derive(Debug, Clone, Options)]
+pub struct ProfileCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+
+    #[options(help = "toggle to next profile in list")]
+    pub next: bool,
+
+    #[options(help = "list available profiles")]
+    pub list: bool,
+
+    #[options(help = "get profile")]
+    pub profile_get: bool,
+
+    #[options(meta = "", help = "set the active profile")]
+    pub profile_set: Option<PlatformPolicy>,
+}
+
 #[derive(Options)]
 pub struct LedModeCommand {
     #[options(help = "print help message")]

asusctl/src/fan_curve_cli.rs

@@ -1,24 +1,7 @@
 use gumdrop::Options;
+use rog_platform::platform::PlatformPolicy;
 use rog_profiles::fan_curve_set::CurveData;
-use rog_profiles::{FanCurvePU, Profile};
-
-#[derive(Debug, Clone, Options)]
-pub struct ProfileCommand {
-    #[options(help = "print help message")]
-    pub help: bool,
-
-    #[options(help = "toggle to next profile in list")]
-    pub next: bool,
-
-    #[options(help = "list available profiles")]
-    pub list: bool,
-
-    #[options(help = "get profile")]
-    pub profile_get: bool,
-
-    #[options(meta = "", help = "set the active profile")]
-    pub profile_set: Option<Profile>,
-}
+use rog_profiles::FanCurvePU;
 
 #[derive(Debug, Clone, Options)]
 pub struct FanCurveCommand {
@@ -35,7 +18,7 @@ pub struct FanCurveCommand {
         meta = "",
         help = "profile to modify fan-curve for. Shows data if no options provided"
     )]
-    pub mod_profile: Option<Profile>,
+    pub mod_profile: Option<PlatformPolicy>,
 
     #[options(
         meta = "",

asusctl/src/main.rs

@@ -5,17 +5,20 @@ use std::process::Command;
 use std::thread::sleep;
 
 use anime_cli::{AnimeActions, AnimeCommand};
+use asusd::ctrl_aura::trait_impls::AURA_ZBUS_NAME;
+use asusd::ctrl_fancurves::FAN_CURVE_ZBUS_NAME;
 use aura_cli::{LedPowerCommand1, LedPowerCommand2};
+use dmi_id::DMIID;
+use fan_curve_cli::FanCurveCommand;
 use gumdrop::{Opt, Options};
-use profiles_cli::{FanCurveCommand, ProfileCommand};
 use rog_anime::usb::get_anime_type;
 use rog_anime::{AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, AnimeType, Vec2};
 use rog_aura::power::KbAuraPowerState;
-use rog_aura::usb::{AuraDevRog1, AuraDevTuf, AuraDevice, AuraPowerDev};
+use rog_aura::usb::{AuraDevRog1, AuraDevTuf, AuraPowerDev};
 use rog_aura::{self, AuraEffect};
 use rog_dbus::RogDbusClientBlocking;
-use rog_platform::platform::GpuMode;
-use rog_platform::supported::*;
+use rog_platform::error::PlatformError;
+use rog_platform::platform::{GpuMode, PlatformPolicy, Properties};
 use rog_profiles::error::ProfileError;
 
 use crate::aura_cli::{AuraPowerStates, LedBrightness};
@@ -24,7 +27,7 @@ use crate::cli_opts::*;
 mod anime_cli;
 mod aura_cli;
 mod cli_opts;
-mod profiles_cli;
+mod fan_curve_cli;
 
 fn main() {
     let args: Vec<String> = args().skip(1).collect();
@@ -43,43 +46,42 @@ fn main() {
     };
 
     if let Ok((dbus, _)) = RogDbusClientBlocking::new().map_err(|e| {
-        print_error_help(&e, None);
+        check_service("asusd");
+        println!("\nError: {e}\n");
+        print_info();
     }) {
-        if let Ok(supported) = dbus
-            .proxies()
-            .supported()
-            .supported_functions()
-            .map_err(|e| {
-                print_error_help(&e, None);
-            })
-        {
-            if parsed.version {
-                println!("asusctl v{}", env!("CARGO_PKG_VERSION"));
-                println!();
-                print_info();
-            }
+        let supported_properties = dbus.proxies().platform().supported_properties().unwrap();
+        let supported_interfaces = dbus.proxies().platform().supported_interfaces().unwrap();
 
-            if let Err(err) = do_parsed(&parsed, &supported, &dbus) {
-                print_error_help(&*err, Some(&supported));
-            }
+        if parsed.version {
+            println!("asusctl v{}", env!("CARGO_PKG_VERSION"));
+            println!();
+            print_info();
+        }
+
+        if let Err(err) = do_parsed(&parsed, &supported_interfaces, &supported_properties, &dbus) {
+            print_error_help(&*err, &supported_interfaces, &supported_properties);
         }
     }
 }
 
-fn print_error_help(err: &dyn std::error::Error, supported: Option<&SupportedFunctions>) {
+fn print_error_help(
+    err: &dyn std::error::Error,
+    supported_interfaces: &[String],
+    supported_properties: &[Properties],
+) {
     check_service("asusd");
     println!("\nError: {}\n", err);
     print_info();
-    if let Some(supported) = supported {
-        println!();
-        println!("Supported laptop functions:\n\n{}", supported);
-    }
+    println!();
+    println!("Supported interfaces:\n\n{:#?}\n", supported_interfaces);
+    println!("Supported properties:\n\n{:#?}\n", supported_properties);
 }
 
 fn print_info() {
-    let dmi = sysfs_class::DmiId::default();
-    let board_name = dmi.board_name().expect("Could not get board_name");
-    let prod_family = dmi.product_family().expect("Could not get product_family");
+    let dmi = DMIID::new().unwrap_or_default();
+    let board_name = dmi.board_name;
+    let prod_family = dmi.product_family;
     println!("asusctl version: {}", env!("CARGO_PKG_VERSION"));
     println!(" Product family: {}", prod_family.trim());
     println!("     Board name: {}", board_name.trim());
@@ -104,20 +106,21 @@ fn check_service(name: &str) -> bool {
 
 fn do_parsed(
     parsed: &CliStart,
-    supported: &SupportedFunctions,
+    supported_interfaces: &[String],
+    supported_properties: &[Properties],
     dbus: &RogDbusClientBlocking<'_>,
 ) -> Result<(), Box<dyn std::error::Error>> {
     match &parsed.command {
-        Some(CliCommand::LedMode(mode)) => handle_led_mode(dbus, &supported.keyboard_led, mode)?,
-        Some(CliCommand::LedPow1(pow)) => handle_led_power1(dbus, &supported.keyboard_led, pow)?,
-        Some(CliCommand::LedPow2(pow)) => handle_led_power2(dbus, &supported.keyboard_led, pow)?,
-        Some(CliCommand::Profile(cmd)) => handle_profile(dbus, &supported.platform_profile, cmd)?,
+        Some(CliCommand::LedMode(mode)) => handle_led_mode(dbus, supported_interfaces, mode)?,
+        Some(CliCommand::LedPow1(pow)) => handle_led_power1(dbus, supported_interfaces, pow)?,
+        Some(CliCommand::LedPow2(pow)) => handle_led_power2(dbus, supported_interfaces, pow)?,
+        Some(CliCommand::Profile(cmd)) => handle_throttle_profile(dbus, supported_properties, cmd)?,
         Some(CliCommand::FanCurve(cmd)) => {
-            handle_fan_curve(dbus, &supported.platform_profile, cmd)?;
+            handle_fan_curve(dbus, supported_interfaces, cmd)?;
         }
         Some(CliCommand::Graphics(_)) => do_gfx(),
-        Some(CliCommand::Anime(cmd)) => handle_anime(dbus, &supported.anime_ctrl, cmd)?,
-        Some(CliCommand::Bios(cmd)) => handle_bios_option(dbus, &supported.rog_bios_ctrl, cmd)?,
+        Some(CliCommand::Anime(cmd)) => handle_anime(dbus, cmd)?,
+        Some(CliCommand::Bios(cmd)) => handle_platform_properties(dbus, supported_properties, cmd)?,
         None => {
             if (!parsed.show_supported
                 && parsed.kbd_bright.is_none()
@@ -129,21 +132,16 @@ fn do_parsed(
                 println!("{}", CliStart::usage());
                 println!();
                 if let Some(cmdlist) = CliStart::command_list() {
+                    let dev_type = dbus.proxies().aura().device_type()?;
                     let commands: Vec<String> = cmdlist.lines().map(|s| s.to_owned()).collect();
                     for command in commands.iter().filter(|command| {
-                        if !matches!(
-                            supported.keyboard_led.dev_id,
-                            AuraDevice::X1854
-                                | AuraDevice::X1869
-                                | AuraDevice::X1866
-                                | AuraDevice::Tuf
-                        ) && command.trim().starts_with("led-pow-1")
+                        if !dev_type.is_old_style()
+                            && !dev_type.is_tuf_style()
+                            && command.trim().starts_with("led-pow-1")
                         {
                             return false;
                         }
-                        if supported.keyboard_led.dev_id != AuraDevice::X19b6
-                            && command.trim().starts_with("led-pow-2")
-                        {
+                        if !dev_type.is_new_style() && command.trim().starts_with("led-pow-2") {
                             return false;
                         }
                         true
@@ -162,31 +160,34 @@ fn do_parsed(
     if let Some(brightness) = &parsed.kbd_bright {
         match brightness.level() {
             None => {
-                let level = dbus.proxies().led().led_brightness()?;
-                println!("Current keyboard led brightness: {}", level);
+                let level = dbus.proxies().aura().brightness()?;
+                println!("Current keyboard led brightness: {level:?}");
             }
             Some(level) => dbus
                 .proxies()
-                .led()
-                .set_brightness(<rog_aura::LedBrightness>::from(level))?,
+                .aura()
+                .set_brightness(rog_aura::LedBrightness::from(level))?,
         }
     }
 
     if parsed.next_kbd_bright {
-        dbus.proxies().led().next_led_brightness()?;
+        let brightness = dbus.proxies().aura().brightness()?;
+        dbus.proxies().aura().set_brightness(brightness.next())?;
     }
 
     if parsed.prev_kbd_bright {
-        dbus.proxies().led().prev_led_brightness()?;
+        let brightness = dbus.proxies().aura().brightness()?;
+        dbus.proxies().aura().set_brightness(brightness.prev())?;
     }
 
-    if parsed.show_supported {
-        println!("Supported laptop functions:\n\n{}", supported);
-    }
+    // TODO:
+    // if parsed.show_supported {
+    //     println!("Supported laptop functions:\n\n{}", supported);
+    // }
 
     if let Some(chg_limit) = parsed.chg_limit {
         dbus.proxies()
-            .charge()
+            .platform()
             .set_charge_control_end_threshold(chg_limit)?;
     }
 
@@ -203,14 +204,16 @@ fn do_gfx() {
 
 fn handle_anime(
     dbus: &RogDbusClientBlocking<'_>,
-    _supported: &AnimeSupportedFunctions,
     cmd: &AnimeCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
     if (cmd.command.is_none()
         && cmd.enable_display.is_none()
         && cmd.enable_powersave_anim.is_none()
         && cmd.brightness.is_none()
-        && cmd.image_brightness.is_none()
+        && cmd.off_when_lid_closed.is_none()
+        && cmd.off_when_suspended.is_none()
+        && cmd.off_when_unplugged.is_none()
+        && cmd.off_with_his_head.is_none()
         && !cmd.clear)
         || cmd.help
     {
@@ -228,9 +231,17 @@ fn handle_anime(
     if let Some(bright) = cmd.brightness {
         dbus.proxies().anime().set_brightness(bright)?;
     }
-    if let Some(bright) = cmd.image_brightness {
-        verify_brightness(bright);
-        dbus.proxies().anime().set_image_brightness(bright)?;
+    if let Some(enable) = cmd.off_when_lid_closed {
+        dbus.proxies().anime().set_off_when_lid_closed(enable)?;
+    }
+    if let Some(enable) = cmd.off_when_suspended {
+        dbus.proxies().anime().set_off_when_suspended(enable)?;
+    }
+    if let Some(enable) = cmd.off_when_unplugged {
+        dbus.proxies().anime().set_off_when_unplugged(enable)?;
+    }
+    if cmd.off_with_his_head.is_some() {
+        println!("Did Alice _really_ make it back from Wonderland?");
     }
 
     let mut anime_type = get_anime_type()?;
@@ -367,12 +378,14 @@ fn handle_anime(
                     return Ok(());
                 }
 
-                dbus.proxies().anime().set_builtin_animations(
-                    builtins.boot,
-                    builtins.awake,
-                    builtins.sleep,
-                    builtins.shutdown,
-                )?;
+                dbus.proxies()
+                    .anime()
+                    .set_builtin_animations(rog_anime::Animations {
+                        boot: builtins.boot,
+                        awake: builtins.awake,
+                        sleep: builtins.sleep,
+                        shutdown: builtins.shutdown,
+                    })?;
             }
         }
     }
@@ -390,9 +403,14 @@ fn verify_brightness(brightness: f32) {
 
 fn handle_led_mode(
     dbus: &RogDbusClientBlocking<'_>,
-    supported: &LedSupportedFunctions,
+    supported: &[String],
     mode: &LedModeCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
+    if !supported.contains(&AURA_ZBUS_NAME.to_string()) {
+        println!("This laptop does not support power options");
+        return Err(PlatformError::NotSupported.into());
+    }
+
     if mode.command.is_none() && !mode.prev_mode && !mode.next_mode {
         if !mode.help {
             println!("Missing arg or command\n");
@@ -402,8 +420,9 @@ fn handle_led_mode(
 
         if let Some(cmdlist) = LedModeCommand::command_list() {
             let commands: Vec<String> = cmdlist.lines().map(|s| s.to_owned()).collect();
+            let modes = dbus.proxies().aura().supported_basic_modes()?;
             for command in commands.iter().filter(|command| {
-                for mode in &supported.basic_modes {
+                for mode in &modes {
                     if command
                         .trim()
                         .starts_with(&<&str>::from(mode).to_lowercase())
@@ -411,9 +430,10 @@ fn handle_led_mode(
                         return true;
                     }
                 }
-                if !supported.basic_zones.is_empty() && command.trim().starts_with("multi") {
-                    return true;
-                }
+                // TODO
+                // if !supported.basic_zones.is_empty() && command.trim().starts_with("multi") {
+                //     return true;
+                // }
                 false
             }) {
                 println!("{}", command);
@@ -429,17 +449,31 @@ fn handle_led_mode(
         return Ok(());
     }
     if mode.next_mode {
-        dbus.proxies().led().next_led_mode()?;
+        let mode = dbus.proxies().aura().led_mode()?;
+        let modes = dbus.proxies().aura().supported_basic_modes()?;
+        let mut pos = modes.iter().position(|m| *m == mode).unwrap() + 1;
+        if pos >= modes.len() {
+            pos = 0;
+        }
+        dbus.proxies().aura().set_led_mode(modes[pos])?;
     } else if mode.prev_mode {
-        dbus.proxies().led().prev_led_mode()?;
+        let mode = dbus.proxies().aura().led_mode()?;
+        let modes = dbus.proxies().aura().supported_basic_modes()?;
+        let mut pos = modes.iter().position(|m| *m == mode).unwrap();
+        if pos == 0 {
+            pos = modes.len() - 1;
+        } else {
+            pos -= 1;
+        }
+        dbus.proxies().aura().set_led_mode(modes[pos])?;
     } else if let Some(mode) = mode.command.as_ref() {
         if mode.help_requested() {
             println!("{}", mode.self_usage());
             return Ok(());
         }
         dbus.proxies()
-            .led()
-            .set_led_mode(&<AuraEffect>::from(mode))?;
+            .aura()
+            .set_led_mode_data(<AuraEffect>::from(mode))?;
     }
 
     Ok(())
@@ -447,9 +481,18 @@ fn handle_led_mode(
 
 fn handle_led_power1(
     dbus: &RogDbusClientBlocking<'_>,
-    supported: &LedSupportedFunctions,
+    supported: &[String],
     power: &LedPowerCommand1,
 ) -> Result<(), Box<dyn std::error::Error>> {
+    if !supported.contains(&AURA_ZBUS_NAME.to_string()) {
+        println!("This laptop does not support power options");
+        return Err(PlatformError::NotSupported.into());
+    }
+    let dev_type = dbus.proxies().aura().device_type()?;
+    if !dev_type.is_old_style() && !dev_type.is_tuf_style() {
+        println!("This option applies only to keyboards 2021+");
+    }
+
     if power.awake.is_none()
         && power.sleep.is_none()
         && power.boot.is_none()
@@ -463,15 +506,12 @@ fn handle_led_power1(
         return Ok(());
     }
 
-    if matches!(
-        supported.dev_id,
-        AuraDevice::X1854 | AuraDevice::X1869 | AuraDevice::X1866
-    ) {
+    if dev_type.is_old_style() {
         handle_led_power_1_do_1866(dbus, power)?;
         return Ok(());
     }
 
-    if matches!(supported.dev_id, AuraDevice::Tuf) {
+    if dev_type.is_tuf_style() {
         handle_led_power_1_do_tuf(dbus, power)?;
         return Ok(());
     }
@@ -507,13 +547,13 @@ fn handle_led_power_1_do_1866(
         old_rog: enabled,
         ..Default::default()
     };
-    dbus.proxies().led().set_led_power(data, true)?;
+    dbus.proxies().aura().set_led_power((data, true))?;
 
     let data = AuraPowerDev {
         old_rog: disabled,
         ..Default::default()
     };
-    dbus.proxies().led().set_led_power(data, false)?;
+    dbus.proxies().aura().set_led_power((data, false))?;
 
     Ok(())
 }
@@ -544,22 +584,31 @@ fn handle_led_power_1_do_tuf(
         tuf: enabled,
         ..Default::default()
     };
-    dbus.proxies().led().set_led_power(data, true)?;
+    dbus.proxies().aura().set_led_power((data, true))?;
 
     let data = AuraPowerDev {
         tuf: disabled,
         ..Default::default()
     };
-    dbus.proxies().led().set_led_power(data, false)?;
+    dbus.proxies().aura().set_led_power((data, false))?;
 
     Ok(())
 }
 
 fn handle_led_power2(
     dbus: &RogDbusClientBlocking<'_>,
-    supported: &LedSupportedFunctions,
+    supported: &[String],
     power: &LedPowerCommand2,
 ) -> Result<(), Box<dyn std::error::Error>> {
+    if !supported.contains(&AURA_ZBUS_NAME.to_string()) {
+        println!("This laptop does not support power options");
+        return Err(PlatformError::NotSupported.into());
+    }
+    let dev_type = dbus.proxies().aura().device_type()?;
+    if !dev_type.is_new_style() {
+        println!("This option applies only to keyboards 2021+");
+    }
+
     if power.command().is_none() {
         if !power.help {
             println!("Missing arg or command\n");
@@ -584,10 +633,6 @@ fn handle_led_power2(
             return Ok(());
         }
 
-        if supported.dev_id != AuraDevice::X19b6 {
-            println!("This option applies only to keyboards with product ID 0x19b6");
-        }
-
         let set = |power: &mut KbAuraPowerState, set_to: &AuraPowerStates| {
             power.boot = set_to.boot;
             power.awake = set_to.awake;
@@ -595,7 +640,7 @@ fn handle_led_power2(
             power.shutdown = set_to.shutdown;
         };
 
-        let mut enabled = dbus.proxies().led().led_power()?;
+        let mut enabled = dbus.proxies().aura().led_power()?;
         if let Some(cmd) = &power.command {
             match cmd {
                 aura_cli::SetAuraZoneEnabled::Keyboard(k) => set(&mut enabled.rog.keyboard, k),
@@ -606,18 +651,18 @@ fn handle_led_power2(
             }
         }
 
-        dbus.proxies().led().set_led_power(enabled, true)?;
+        dbus.proxies().aura().set_led_power((enabled, true))?;
     }
 
     Ok(())
 }
 
-fn handle_profile(
+fn handle_throttle_profile(
     dbus: &RogDbusClientBlocking<'_>,
-    supported: &PlatformProfileFunctions,
+    supported: &[Properties],
     cmd: &ProfileCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    if !supported.platform_profile {
+    if !supported.contains(&Properties::PlatformPolicy) {
         println!("Profiles not supported by either this kernel or by the laptop.");
         return Err(ProfileError::NotSupported.into());
     }
@@ -633,23 +678,27 @@ fn handle_profile(
         }
         return Ok(());
     }
+    let current = dbus.proxies().platform().throttle_thermal_policy()?;
 
     if cmd.next {
-        dbus.proxies().profile().next_profile()?;
+        dbus.proxies()
+            .platform()
+            .set_throttle_thermal_policy(current.next())?;
     } else if let Some(profile) = cmd.profile_set {
-        dbus.proxies().profile().set_active_profile(profile)?;
+        dbus.proxies()
+            .platform()
+            .set_throttle_thermal_policy(profile)?;
     }
 
     if cmd.list {
-        let res = dbus.proxies().profile().profiles()?;
+        let res = PlatformPolicy::list();
         for p in &res {
             println!("{:?}", p);
         }
     }
 
     if cmd.profile_get {
-        let res = dbus.proxies().profile().active_profile()?;
-        println!("Active profile is {:?}", res);
+        println!("Active profile is {current:?}");
     }
 
     Ok(())
@@ -657,12 +706,11 @@ fn handle_profile(
 
 fn handle_fan_curve(
     dbus: &RogDbusClientBlocking<'_>,
-    supported: &PlatformProfileFunctions,
+    supported: &[String],
     cmd: &FanCurveCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    if supported.fans.is_empty() {
+    if !supported.contains(&FAN_CURVE_ZBUS_NAME.to_string()) {
         println!("Fan-curves not supported by either this kernel or by the laptop.");
-        println!("This requires kernel 5.17 or the fan curve patch listed in the readme.");
         return Err(ProfileError::NotSupported.into());
     }
 
@@ -689,34 +737,34 @@ fn handle_fan_curve(
     }
 
     if cmd.get_enabled {
-        let profile = dbus.proxies().profile().active_profile()?;
-        let curves = dbus.proxies().profile().fan_curve_data(profile)?;
+        let profile = dbus.proxies().platform().throttle_thermal_policy()?;
+        let curves = dbus.proxies().fan_curves().fan_curve_data(profile)?;
         for curve in curves.iter() {
             println!("{}", String::from(curve));
         }
     }
 
     if cmd.default {
-        dbus.proxies().profile().set_active_curve_to_defaults()?;
+        dbus.proxies().fan_curves().set_active_curve_to_defaults()?;
     }
 
     if let Some(profile) = cmd.mod_profile {
         if cmd.enable_fan_curves.is_none() && cmd.data.is_none() {
-            let data = dbus.proxies().profile().fan_curve_data(profile)?;
+            let data = dbus.proxies().fan_curves().fan_curve_data(profile)?;
             let data = toml::to_string(&data)?;
             println!("\nFan curves for {:?}\n\n{}", profile, data);
         }
 
         if let Some(enabled) = cmd.enable_fan_curves {
             dbus.proxies()
-                .profile()
+                .fan_curves()
                 .set_fan_curves_enabled(profile, enabled)?;
         }
 
         if let Some(enabled) = cmd.enable_fan_curve {
             if let Some(fan) = cmd.fan {
                 dbus.proxies()
-                    .profile()
+                    .fan_curves()
                     .set_profile_fan_curve_enabled(profile, fan, enabled)?;
             } else {
                 println!(
@@ -729,16 +777,16 @@ fn handle_fan_curve(
         if let Some(mut curve) = cmd.data.clone() {
             let fan = cmd.fan.unwrap_or_default();
             curve.set_fan(fan);
-            dbus.proxies().profile().set_fan_curve(profile, curve)?;
+            dbus.proxies().fan_curves().set_fan_curve(profile, curve)?;
         }
     }
 
     Ok(())
 }
 
-fn handle_bios_option(
+fn handle_platform_properties(
     dbus: &RogDbusClientBlocking<'_>,
-    supported: &RogBiosSupportedFunctions,
+    supported: &[Properties],
     cmd: &BiosCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
     {
@@ -755,26 +803,26 @@ fn handle_bios_option(
             let usage: Vec<String> = BiosCommand::usage().lines().map(|s| s.to_owned()).collect();
 
             for line in usage.iter().filter(|line| {
-                line.contains("sound") && supported.post_sound
-                    || line.contains("GPU") && supported.gpu_mux
-                    || line.contains("panel") && supported.panel_overdrive
+                line.contains("sound") && supported.contains(&Properties::PostAnimationSound)
+                    || line.contains("GPU") && supported.contains(&Properties::GpuMuxMode)
+                    || line.contains("panel") && supported.contains(&Properties::PanelOd)
             }) {
                 println!("{}", line);
             }
         }
 
         if let Some(opt) = cmd.post_sound_set {
-            dbus.proxies().rog_bios().set_post_boot_sound(opt)?;
+            dbus.proxies().platform().set_post_animation_sound(opt)?;
         }
         if cmd.post_sound_get {
-            let res = dbus.proxies().rog_bios().post_boot_sound()? == 1;
+            let res = dbus.proxies().platform().post_animation_sound()?;
             println!("Bios POST sound on: {}", res);
         }
 
         if let Some(opt) = cmd.gpu_mux_mode_set {
             println!("Rebuilding initrd to include drivers");
             dbus.proxies()
-                .rog_bios()
+                .platform()
                 .set_gpu_mux_mode(GpuMode::from_mux(opt))?;
             println!(
                 "The mode change is not active until you reboot, on boot the bios will make the \
@@ -782,15 +830,15 @@ fn handle_bios_option(
             );
         }
         if cmd.gpu_mux_mode_get {
-            let res = dbus.proxies().rog_bios().gpu_mux_mode()?;
+            let res = dbus.proxies().platform().gpu_mux_mode()?;
             println!("Bios GPU MUX: {:?}", res);
         }
 
         if let Some(opt) = cmd.panel_overdrive_set {
-            dbus.proxies().rog_bios().set_panel_od(opt)?;
+            dbus.proxies().platform().set_panel_od(opt)?;
         }
         if cmd.panel_overdrive_get {
-            let res = dbus.proxies().rog_bios().panel_od()?;
+            let res = dbus.proxies().platform().panel_od()?;
             println!("Panel overdrive on: {}", res);
         }
     }

asusd-user/src/daemon.rs

@@ -5,12 +5,11 @@ use std::sync::{Arc, Mutex};
 
 use asusd_user::config::*;
 use asusd_user::ctrl_anime::{CtrlAnime, CtrlAnimeInner};
-use asusd_user::DBUS_NAME;
 use config_traits::{StdConfig, StdConfigLoad};
 use rog_anime::usb::get_anime_type;
 use rog_aura::aura_detection::LaptopLedData;
 use rog_aura::layouts::KeyLayout;
-use rog_dbus::RogDbusClientBlocking;
+use rog_dbus::{RogDbusClientBlocking, DBUS_NAME};
 use smol::Executor;
 use zbus::Connection;
 
@@ -34,15 +33,18 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("rog-platform v{}", rog_platform::VERSION);
 
     let (client, _) = RogDbusClientBlocking::new()?;
-    let supported = client.proxies().supported().supported_functions()?;
-
+    let supported = client
+        .proxies()
+        .platform()
+        .supported_interfaces()
+        .unwrap_or_default()
+        .contains(&"Anime".to_string());
     let config = ConfigBase::new().load();
-
     let executor = Executor::new();
 
     let early_return = Arc::new(AtomicBool::new(false));
     // Set up the anime data and run loop/thread
-    if supported.anime_ctrl.0 {
+    if supported {
         if let Some(cfg) = config.active_anime {
             let anime_type = get_anime_type()?;
             let anime_config = ConfigAnime::new().set_name(cfg).load();
@@ -100,7 +102,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
                     client
                         .proxies()
-                        .led()
+                        .aura()
                         .direct_addressing_raw(packets)
                         .unwrap();
                     std::thread::sleep(std::time::Duration::from_millis(33));

asusd-user/src/lib.rs

@@ -6,6 +6,4 @@ pub mod ctrl_anime;
 
 pub mod zbus_anime;
 
-pub static DBUS_NAME: &str = "org.asuslinux.Daemon";
-
 pub static VERSION: &str = env!("CARGO_PKG_VERSION");

asusd/Cargo.toml

@@ -19,7 +19,9 @@ rog_anime = { path = "../rog-anime", features = ["dbus"] }
 rog_aura = { path = "../rog-aura", features = ["dbus"] }
 rog_platform = { path = "../rog-platform" }
 rog_profiles = { path = "../rog-profiles" }
-rog_dbus = { path = "../rog-dbus" }
+dmi_id = { path = "../dmi-id" }
+futures-lite = "*"
+udev.workspace = true
 
 async-trait.workspace = true
 tokio.workspace = true
@@ -35,9 +37,6 @@ logind-zbus.workspace = true
 serde.workspace = true
 serde_derive.workspace = true
 
-# Device control
-sysfs-class.workspace = true # used for backlight control and baord ID
-
 concat-idents.workspace = true
 
 systemd-zbus = "*"

asusd/src/config.rs

@@ -1,4 +1,5 @@
-use config_traits::{StdConfig, StdConfigLoad2};
+use config_traits::{StdConfig, StdConfigLoad3};
+use rog_platform::platform::PlatformPolicy;
 use serde_derive::{Deserialize, Serialize};
 
 const CONFIG_FILE: &str = "asusd.ron";
@@ -6,23 +7,35 @@ const CONFIG_FILE: &str = "asusd.ron";
 #[derive(Deserialize, Serialize, Default, Debug)]
 pub struct Config {
     /// Save charge limit for restoring on boot
-    pub bat_charge_limit: u8,
+    pub charge_control_end_threshold: u8,
     pub panel_od: bool,
     pub mini_led_mode: bool,
     pub disable_nvidia_powerd_on_battery: bool,
     pub ac_command: String,
     pub bat_command: String,
+    pub platform_policy_linked_epp: bool,
+    pub platform_policy_on_battery: PlatformPolicy,
+    pub platform_policy_on_ac: PlatformPolicy,
+    //
+    pub ppt_pl1_spl: Option<u8>,
+    pub ppt_pl2_sppt: Option<u8>,
+    pub ppt_fppt: Option<u8>,
+    pub ppt_apu_sppt: Option<u8>,
+    pub ppt_platform_sppt: Option<u8>,
+    pub nv_dynamic_boost: Option<u8>,
+    pub nv_temp_target: Option<u8>,
 }
 
 impl StdConfig for Config {
     fn new() -> Self {
         Config {
-            bat_charge_limit: 100,
-            panel_od: false,
-            mini_led_mode: false,
+            charge_control_end_threshold: 100,
             disable_nvidia_powerd_on_battery: true,
+            platform_policy_on_battery: PlatformPolicy::Quiet,
+            platform_policy_on_ac: PlatformPolicy::Performance,
             ac_command: String::new(),
             bat_command: String::new(),
+            ..Default::default()
         }
     }
 
@@ -35,7 +48,78 @@ impl StdConfig for Config {
     }
 }
 
-impl StdConfigLoad2<Config458, Config462> for Config {}
+impl StdConfigLoad3<Config462, Config472, Config506> for Config {}
+
+#[derive(Deserialize, Serialize)]
+pub struct Config506 {
+    /// Save charge limit for restoring on boot
+    pub charge_control_end_threshold: u8,
+    pub panel_od: bool,
+    pub mini_led_mode: bool,
+    pub disable_nvidia_powerd_on_battery: bool,
+    pub ac_command: String,
+    pub bat_command: String,
+    /// Restored on boot as well as when power is plugged
+    #[serde(skip)]
+    pub platform_policy_to_restore: PlatformPolicy,
+    pub platform_policy_on_battery: PlatformPolicy,
+    pub platform_policy_on_ac: PlatformPolicy,
+    //
+    pub ppt_pl1_spl: Option<u8>,
+    pub ppt_pl2_sppt: Option<u8>,
+    pub ppt_fppt: Option<u8>,
+    pub ppt_apu_sppt: Option<u8>,
+    pub ppt_platform_sppt: Option<u8>,
+    pub nv_dynamic_boost: Option<u8>,
+    pub nv_temp_target: Option<u8>,
+}
+
+impl From<Config506> for Config {
+    fn from(c: Config506) -> Self {
+        Self {
+            charge_control_end_threshold: c.charge_control_end_threshold,
+            panel_od: c.panel_od,
+            disable_nvidia_powerd_on_battery: c.disable_nvidia_powerd_on_battery,
+            ac_command: c.ac_command,
+            bat_command: c.bat_command,
+            mini_led_mode: c.mini_led_mode,
+            platform_policy_linked_epp: true,
+            platform_policy_on_battery: c.platform_policy_on_battery,
+            platform_policy_on_ac: c.platform_policy_on_ac,
+            ppt_pl1_spl: c.ppt_pl1_spl,
+            ppt_pl2_sppt: c.ppt_pl2_sppt,
+            ppt_fppt: c.ppt_fppt,
+            ppt_apu_sppt: c.ppt_apu_sppt,
+            ppt_platform_sppt: c.ppt_platform_sppt,
+            nv_dynamic_boost: c.nv_dynamic_boost,
+            nv_temp_target: c.nv_temp_target,
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct Config472 {
+    /// Save charge limit for restoring on boot
+    pub bat_charge_limit: u8,
+    pub panel_od: bool,
+    pub mini_led_mode: bool,
+    pub disable_nvidia_powerd_on_battery: bool,
+    pub ac_command: String,
+    pub bat_command: String,
+}
+
+impl From<Config472> for Config {
+    fn from(c: Config472) -> Self {
+        Self {
+            charge_control_end_threshold: c.bat_charge_limit,
+            panel_od: c.panel_od,
+            disable_nvidia_powerd_on_battery: true,
+            ac_command: c.ac_command,
+            bat_command: c.bat_command,
+            ..Default::default()
+        }
+    }
+}
 
 #[derive(Deserialize, Serialize)]
 pub struct Config462 {
@@ -50,34 +134,12 @@ pub struct Config462 {
 impl From<Config462> for Config {
     fn from(c: Config462) -> Self {
         Self {
-            bat_charge_limit: c.bat_charge_limit,
+            charge_control_end_threshold: c.bat_charge_limit,
             panel_od: c.panel_od,
-            mini_led_mode: false,
             disable_nvidia_powerd_on_battery: true,
             ac_command: String::new(),
             bat_command: String::new(),
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct Config458 {
-    /// 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 From<Config458> for Config {
-    fn from(c: Config458) -> Self {
-        Self {
-            bat_charge_limit: c.bat_charge_limit,
-            panel_od: c.panel_od,
-            mini_led_mode: false,
-            disable_nvidia_powerd_on_battery: true,
-            ac_command: c.ac_command,
-            bat_command: c.bat_command,
+            ..Default::default()
         }
     }
 }

asusd/src/ctrl_anime/config.rs

@@ -3,7 +3,9 @@ use std::time::Duration;
 use config_traits::{StdConfig, StdConfigLoad2};
 use rog_anime::error::AnimeError;
 use rog_anime::usb::Brightness;
-use rog_anime::{ActionData, ActionLoader, AnimTime, Animations, AnimeType, Fade, Vec2};
+use rog_anime::{
+    ActionData, ActionLoader, AnimTime, Animations, AnimeType, DeviceState, Fade, Vec2,
+};
 use serde_derive::{Deserialize, Serialize};
 
 const CONFIG_FILE: &str = "anime.ron";
@@ -24,7 +26,6 @@ impl From<AnimeConfigV460> for AnimeConfig {
             system: c.system,
             boot: c.boot,
             wake: c.wake,
-            sleep: c.sleep,
             shutdown: c.shutdown,
             ..Default::default()
         }
@@ -32,25 +33,32 @@ impl From<AnimeConfigV460> for AnimeConfig {
 }
 
 #[derive(Deserialize, Serialize, Debug)]
-pub struct AnimeConfigV5 {
+pub struct AnimeConfigV472 {
+    pub model_override: Option<AnimeType>,
     pub system: Vec<ActionLoader>,
     pub boot: Vec<ActionLoader>,
     pub wake: Vec<ActionLoader>,
     pub sleep: Vec<ActionLoader>,
     pub shutdown: Vec<ActionLoader>,
     pub brightness: f32,
-    pub awake_enabled: bool,
-    pub boot_anim_enabled: bool,
+    pub display_enabled: bool,
+    pub display_brightness: Brightness,
+    pub builtin_anims_enabled: bool,
+    pub builtin_anims: Animations,
 }
 
-impl From<AnimeConfigV5> for AnimeConfig {
-    fn from(c: AnimeConfigV5) -> AnimeConfig {
+impl From<AnimeConfigV472> for AnimeConfig {
+    fn from(c: AnimeConfigV472) -> AnimeConfig {
         AnimeConfig {
             system: c.system,
             boot: c.boot,
             wake: c.wake,
-            sleep: c.sleep,
             shutdown: c.shutdown,
+            model_override: c.model_override,
+            display_enabled: c.display_enabled,
+            display_brightness: c.display_brightness,
+            builtin_anims_enabled: c.builtin_anims_enabled,
+            builtin_anims: c.builtin_anims,
             ..Default::default()
         }
     }
@@ -61,7 +69,6 @@ pub struct AnimeConfigCached {
     pub system: Vec<ActionData>,
     pub boot: Vec<ActionData>,
     pub wake: Vec<ActionData>,
-    pub sleep: Vec<ActionData>,
     pub shutdown: Vec<ActionData>,
 }
 
@@ -89,12 +96,6 @@ impl AnimeConfigCached {
         }
         self.wake = wake;
 
-        let mut sleep = Vec::with_capacity(config.sleep.len());
-        for ani in &config.sleep {
-            sleep.push(ActionData::from_anime_action(anime_type, ani)?);
-        }
-        self.sleep = sleep;
-
         let mut shutdown = Vec::with_capacity(config.shutdown.len());
         for ani in &config.shutdown {
             shutdown.push(ActionData::from_anime_action(anime_type, ani)?);
@@ -111,12 +112,15 @@ pub struct AnimeConfig {
     pub system: Vec<ActionLoader>,
     pub boot: Vec<ActionLoader>,
     pub wake: Vec<ActionLoader>,
-    pub sleep: Vec<ActionLoader>,
     pub shutdown: Vec<ActionLoader>,
-    pub brightness: f32,
+    // pub brightness: f32,
     pub display_enabled: bool,
     pub display_brightness: Brightness,
     pub builtin_anims_enabled: bool,
+    pub off_when_unplugged: bool,
+    pub off_when_suspended: bool,
+    pub off_when_lid_closed: bool,
+    pub brightness_on_battery: Brightness,
     pub builtin_anims: Animations,
 }
 
@@ -127,12 +131,15 @@ impl Default for AnimeConfig {
             system: Vec::new(),
             boot: Vec::new(),
             wake: Vec::new(),
-            sleep: Vec::new(),
             shutdown: Vec::new(),
-            brightness: 1.0,
+            // brightness: 1.0,
             display_enabled: true,
             display_brightness: Brightness::Med,
             builtin_anims_enabled: true,
+            off_when_unplugged: true,
+            off_when_suspended: true,
+            off_when_lid_closed: true,
+            brightness_on_battery: Brightness::Low,
             builtin_anims: Animations::default(),
         }
     }
@@ -152,7 +159,22 @@ impl StdConfig for AnimeConfig {
     }
 }
 
-impl StdConfigLoad2<AnimeConfigV460, AnimeConfigV5> for AnimeConfig {}
+impl StdConfigLoad2<AnimeConfigV460, AnimeConfigV472> for AnimeConfig {}
+
+impl From<&AnimeConfig> for DeviceState {
+    fn from(config: &AnimeConfig) -> Self {
+        DeviceState {
+            display_enabled: config.display_enabled,
+            display_brightness: config.display_brightness,
+            builtin_anims_enabled: config.builtin_anims_enabled,
+            builtin_anims: config.builtin_anims,
+            off_when_unplugged: config.off_when_unplugged,
+            off_when_suspended: config.off_when_suspended,
+            off_when_lid_closed: config.off_when_lid_closed,
+            brightness_on_battery: config.brightness_on_battery,
+        }
+    }
+}
 
 impl AnimeConfig {
     // fn clamp_config_brightness(mut config: &mut AnimeConfig) {
@@ -193,14 +215,6 @@ impl AnimeConfig {
                     Duration::from_secs(2),
                 )),
             }],
-            sleep: vec![ActionLoader::ImageAnimation {
-                file: "/usr/share/asusd/anime/custom/sonic-wait.gif".into(),
-                scale: 0.9,
-                angle: 0.0,
-                translation: Vec2::new(3.0, 2.0),
-                brightness: 1.0,
-                time: AnimTime::Infinite,
-            }],
             shutdown: vec![ActionLoader::ImageAnimation {
                 file: "/usr/share/asusd/anime/custom/sonic-wait.gif".into(),
                 scale: 0.9,
@@ -209,7 +223,6 @@ impl AnimeConfig {
                 brightness: 1.0,
                 time: AnimTime::Infinite,
             }],
-            brightness: 1.0,
             ..Default::default()
         }
     }

asusd/src/ctrl_anime/mod.rs

@@ -10,27 +10,16 @@ use std::thread::sleep;
 use ::zbus::export::futures_util::lock::Mutex;
 use log::{error, info, warn};
 use rog_anime::error::AnimeError;
-use rog_anime::usb::{get_anime_type, pkt_flush, pkt_set_enable_powersave_anim, pkts_for_init};
+use rog_anime::usb::{
+    get_anime_type, pkt_flush, pkt_set_brightness, pkt_set_enable_display,
+    pkt_set_enable_powersave_anim, pkts_for_init, Brightness,
+};
 use rog_anime::{ActionData, AnimeDataBuffer, AnimePacketType, AnimeType};
 use rog_platform::hid_raw::HidRaw;
-use rog_platform::supported::AnimeSupportedFunctions;
 use rog_platform::usb_raw::USBRaw;
 
 use self::config::{AnimeConfig, AnimeConfigCached};
 use crate::error::RogError;
-use crate::GetSupported;
-
-impl GetSupported for CtrlAnime {
-    type A = AnimeSupportedFunctions;
-
-    fn get_supported() -> Self::A {
-        if USBRaw::new(0x193b).is_ok() {
-            AnimeSupportedFunctions(true)
-        } else {
-            AnimeSupportedFunctions(HidRaw::new("193b").is_ok())
-        }
-    }
-}
 
 enum Node {
     Usb(USBRaw),
@@ -50,6 +39,13 @@ impl Node {
         }
         Ok(())
     }
+
+    pub fn set_builtins_enabled(&self, enabled: bool, bright: Brightness) -> Result<(), RogError> {
+        self.write_bytes(&pkt_set_enable_powersave_anim(enabled))?;
+        self.write_bytes(&pkt_set_enable_display(enabled))?;
+        self.write_bytes(&pkt_set_brightness(bright))?;
+        self.write_bytes(&pkt_set_enable_powersave_anim(enabled))
+    }
 }
 
 pub struct CtrlAnime {
@@ -77,6 +73,20 @@ impl CtrlAnime {
             return Err(RogError::Anime(AnimeError::NoDevice));
         };
 
+        // TODO: something better to set wakeups disabled
+        if matches!(node, Node::Usb(_)) {
+            if let Ok(mut enumerator) = udev::Enumerator::new() {
+                enumerator.match_subsystem("usb").ok();
+                enumerator.match_attribute("idProduct", "193b").ok();
+
+                if let Ok(mut enumer) = enumerator.scan_devices() {
+                    if let Some(mut dev) = enumer.next() {
+                        dev.set_attribute_value("power/wakeup", "disabled").ok();
+                    }
+                }
+            }
+        }
+
         let mut anime_type = get_anime_type()?;
         if let AnimeType::Unknown = anime_type {
             if let Some(model) = config.model_override {
@@ -234,6 +244,14 @@ impl CtrlAnime {
                             })
                             .ok();
                     }
+                    lock.node
+                        .write_bytes(&pkt_set_enable_powersave_anim(
+                            lock.config.builtin_anims_enabled,
+                        ))
+                        .map_err(|err| {
+                            warn!("rog_anime::run_animation:callback {}", err);
+                        })
+                        .ok();
                 }
                 // Loop ended, set the atmonics
                 thread_running.store(false, Ordering::SeqCst);
@@ -247,7 +265,7 @@ impl CtrlAnime {
     /// global brightness set in config.
     fn write_data_buffer(&self, mut buffer: AnimeDataBuffer) -> Result<(), RogError> {
         for led in buffer.data_mut().iter_mut() {
-            let mut bright = *led as f32 * self.config.brightness;
+            let mut bright = *led as f32;
             if bright > 254.0 {
                 bright = 254.0;
             }

asusd/src/ctrl_anime/trait_impls.rs

@@ -4,18 +4,32 @@ use std::sync::Arc;
 use async_trait::async_trait;
 use config_traits::StdConfig;
 use log::warn;
+use logind_zbus::manager::ManagerProxy;
 use rog_anime::usb::{
     pkt_set_brightness, pkt_set_builtin_animations, pkt_set_enable_display,
-    pkt_set_enable_powersave_anim, AnimAwake, AnimBooting, AnimShutdown, AnimSleeping, Brightness,
+    pkt_set_enable_powersave_anim, Brightness,
 };
-use rog_anime::{AnimeDataBuffer, DeviceState};
+use rog_anime::{Animations, AnimeDataBuffer, DeviceState};
 use zbus::export::futures_util::lock::Mutex;
-use zbus::{dbus_interface, Connection, SignalContext};
+use zbus::{dbus_interface, CacheProperties, Connection, SignalContext};
 
 use super::CtrlAnime;
 use crate::error::RogError;
 
-pub(super) const ZBUS_PATH: &str = "/org/asuslinux/Anime";
+pub const ANIME_ZBUS_NAME: &str = "Anime";
+pub const ANIME_ZBUS_PATH: &str = "/org/asuslinux/Anime";
+
+async fn get_logind_manager<'a>() -> ManagerProxy<'a> {
+    let connection = Connection::system()
+        .await
+        .expect("Controller could not create dbus connection");
+
+    ManagerProxy::builder(&connection)
+        .cache_properties(CacheProperties::No)
+        .build()
+        .await
+        .expect("Controller could not create ManagerProxy")
+}
 
 #[derive(Clone)]
 pub struct CtrlAnimeZbus(pub Arc<Mutex<CtrlAnime>>);
@@ -24,7 +38,7 @@ pub struct CtrlAnimeZbus(pub Arc<Mutex<CtrlAnime>>);
 #[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;
+        Self::add_to_server_helper(self, ANIME_ZBUS_PATH, server).await;
     }
 }
 
@@ -39,156 +53,192 @@ impl CtrlAnimeZbus {
         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);
+            warn!("ctrl_anime::run_animation:callback {}", err);
             err
         })?;
         Ok(())
     }
 
-    /// Set the global AniMe brightness
-    async fn set_image_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 base brightness level
+    #[dbus_interface(property)]
+    async fn brightness(&self) -> Brightness {
+        let lock = self.0.lock().await;
+        lock.config.display_brightness
     }
 
     /// Set base brightness level
-    // TODO: enum for brightness
-    async fn set_brightness(
-        &self,
-        #[zbus(signal_context)] ctxt: SignalContext<'_>,
-        brightness: Brightness,
-    ) {
+    #[dbus_interface(property)]
+    async fn set_brightness(&self, brightness: Brightness) {
         let mut lock = self.0.lock().await;
         lock.node
             .write_bytes(&pkt_set_brightness(brightness))
             .map_err(|err| {
-                warn!("rog_anime::run_animation:callback {}", err);
+                warn!("ctrl_anime::set_brightness {}", err);
             })
             .ok();
+        lock.node
+            .write_bytes(&pkt_set_enable_display(brightness != Brightness::Off))
+            .map_err(|err| {
+                warn!("ctrl_anime::set_brightness {}", err);
+            })
+            .ok();
+
+        lock.config.display_enabled = brightness != Brightness::Off;
         lock.config.display_brightness = brightness;
         lock.config.write();
+    }
 
-        Self::notify_device_state(
-            &ctxt,
-            DeviceState {
-                display_enabled: lock.config.display_enabled,
-                display_brightness: lock.config.display_brightness,
-                builtin_anims_enabled: lock.config.builtin_anims_enabled,
-                builtin_anims: lock.config.builtin_anims,
-            },
-        )
-        .await
-        .ok();
+    #[dbus_interface(property)]
+    async fn builtins_enabled(&self) -> bool {
+        let lock = self.0.lock().await;
+        lock.config.builtin_anims_enabled
     }
 
     /// Enable the builtin animations or not. This is quivalent to "Powersave
     /// animations" in Armory crate
-    async fn set_builtins_enabled(
-        &self,
-        #[zbus(signal_context)] ctxt: SignalContext<'_>,
-        enabled: bool,
-    ) {
+    #[dbus_interface(property)]
+    async fn set_builtins_enabled(&self, enabled: bool) {
         let mut lock = self.0.lock().await;
         lock.node
-            .write_bytes(&pkt_set_enable_powersave_anim(enabled))
+            .set_builtins_enabled(enabled, lock.config.display_brightness)
             .map_err(|err| {
-                warn!("rog_anime::run_animation:callback {}", err);
+                warn!("ctrl_anime::set_builtins_enabled {}", err);
             })
             .ok();
+
+        if !enabled {
+            let data = vec![255u8; lock.anime_type.data_length()];
+            if let Ok(tmp) = AnimeDataBuffer::from_vec(lock.anime_type, data).map_err(|err| {
+                warn!("ctrl_anime::set_builtins_enabled {}", err);
+            }) {
+                lock.node
+                    .write_bytes(tmp.data())
+                    .map_err(|err| {
+                        warn!("ctrl_anime::set_builtins_enabled {}", err);
+                    })
+                    .ok();
+            }
+        }
+
         lock.config.builtin_anims_enabled = enabled;
         lock.config.write();
         if enabled {
             lock.thread_exit.store(true, Ordering::Release);
         }
+    }
 
-        Self::notify_device_state(
-            &ctxt,
-            DeviceState {
-                display_enabled: lock.config.display_enabled,
-                display_brightness: lock.config.display_brightness,
-                builtin_anims_enabled: lock.config.builtin_anims_enabled,
-                builtin_anims: lock.config.builtin_anims,
-            },
-        )
-        .await
-        .ok();
+    #[dbus_interface(property)]
+    async fn builtin_animations(&self) -> Animations {
+        let lock = self.0.lock().await;
+        lock.config.builtin_anims
     }
 
     /// Set which builtin animation is used for each stage
-    async fn set_builtin_animations(
-        &self,
-        #[zbus(signal_context)] ctxt: SignalContext<'_>,
-        boot: AnimBooting,
-        awake: AnimAwake,
-        sleep: AnimSleeping,
-        shutdown: AnimShutdown,
-    ) {
+    #[dbus_interface(property)]
+    async fn set_builtin_animations(&self, settings: Animations) {
         let mut lock = self.0.lock().await;
+        lock.node
+            .write_bytes(&pkt_set_builtin_animations(
+                settings.boot,
+                settings.awake,
+                settings.sleep,
+                settings.shutdown,
+            ))
+            .map_err(|err| {
+                warn!("ctrl_anime::run_animation:callback {}", err);
+            })
+            .ok();
         lock.node
             .write_bytes(&pkt_set_enable_powersave_anim(true))
             .map_err(|err| {
-                warn!("rog_anime::run_animation:callback {}", err);
+                warn!("ctrl_anime::run_animation:callback {}", err);
             })
             .ok();
-        lock.node
-            .write_bytes(&pkt_set_builtin_animations(boot, awake, sleep, shutdown))
-            .map_err(|err| {
-                warn!("rog_anime::run_animation:callback {}", err);
-            })
-            .ok();
-        lock.config.builtin_anims.boot = boot;
-        lock.config.builtin_anims.sleep = sleep;
-        lock.config.builtin_anims.awake = awake;
-        lock.config.builtin_anims.shutdown = shutdown;
+        lock.config.display_enabled = true;
+        lock.config.builtin_anims = settings;
         lock.config.write();
+    }
 
-        Self::notify_device_state(
-            &ctxt,
-            DeviceState {
-                display_enabled: lock.config.display_enabled,
-                display_brightness: lock.config.display_brightness,
-                builtin_anims_enabled: lock.config.builtin_anims_enabled,
-                builtin_anims: lock.config.builtin_anims,
-            },
-        )
-        .await
-        .ok();
+    #[dbus_interface(property)]
+    async fn enable_display(&self) -> bool {
+        let lock = self.0.lock().await;
+        lock.config.display_enabled
     }
 
     /// Set whether the AniMe is enabled at all
-    async fn set_enable_display(
-        &self,
-        #[zbus(signal_context)] ctxt: SignalContext<'_>,
-        enabled: bool,
-    ) {
+    #[dbus_interface(property)]
+    async fn set_enable_display(&self, enabled: bool) {
         let mut lock = self.0.lock().await;
         lock.node
             .write_bytes(&pkt_set_enable_display(enabled))
             .map_err(|err| {
-                warn!("rog_anime::run_animation:callback {}", err);
+                warn!("ctrl_anime::run_animation:callback {}", err);
             })
             .ok();
         lock.config.display_enabled = enabled;
         lock.config.write();
+    }
 
-        Self::notify_device_state(
-            &ctxt,
-            DeviceState {
-                display_enabled: lock.config.display_enabled,
-                display_brightness: lock.config.display_brightness,
-                builtin_anims_enabled: lock.config.builtin_anims_enabled,
-                builtin_anims: lock.config.builtin_anims,
-            },
-        )
-        .await
-        .ok();
+    #[dbus_interface(property)]
+    async fn off_when_unplugged(&self) -> bool {
+        let lock = self.0.lock().await;
+        lock.config.off_when_unplugged
+    }
+
+    /// Set if to turn the AniMe Matrix off when external power is unplugged
+    #[dbus_interface(property)]
+    async fn set_off_when_unplugged(&self, enabled: bool) {
+        let mut lock = self.0.lock().await;
+        let manager = get_logind_manager().await;
+        let pow = manager.on_external_power().await.unwrap_or_default();
+
+        lock.node
+            .write_bytes(&pkt_set_enable_display(!pow && !enabled))
+            .map_err(|err| {
+                warn!("create_sys_event_tasks::off_when_lid_closed {}", err);
+            })
+            .ok();
+
+        lock.config.off_when_unplugged = enabled;
+        lock.config.write();
+    }
+
+    #[dbus_interface(property)]
+    async fn off_when_suspended(&self) -> bool {
+        let lock = self.0.lock().await;
+        lock.config.off_when_suspended
+    }
+
+    /// Set if to turn the AniMe Matrix off when the laptop is suspended
+    #[dbus_interface(property)]
+    async fn set_off_when_suspended(&self, enabled: bool) {
+        let mut lock = self.0.lock().await;
+        lock.config.off_when_suspended = enabled;
+        lock.config.write();
+    }
+
+    #[dbus_interface(property)]
+    async fn off_when_lid_closed(&self) -> bool {
+        let lock = self.0.lock().await;
+        lock.config.off_when_lid_closed
+    }
+
+    /// Set if to turn the AniMe Matrix off when the lid is closed
+    #[dbus_interface(property)]
+    async fn set_off_when_lid_closed(&self, enabled: bool) {
+        let mut lock = self.0.lock().await;
+        let manager = get_logind_manager().await;
+        let lid = manager.lid_closed().await.unwrap_or_default();
+
+        lock.node
+            .write_bytes(&pkt_set_enable_display(lid && !enabled))
+            .map_err(|err| {
+                warn!("create_sys_event_tasks::off_when_lid_closed {}", err);
+            })
+            .ok();
+
+        lock.config.off_when_lid_closed = enabled;
+        lock.config.write();
     }
 
     /// The main loop is the base system set action if the user isn't running
@@ -205,24 +255,14 @@ impl CtrlAnimeZbus {
     // #[dbus_interface(property)]
     async fn device_state(&self) -> DeviceState {
         let lock = self.0.lock().await;
-        DeviceState {
-            display_enabled: lock.config.display_enabled,
-            display_brightness: lock.config.display_brightness,
-            builtin_anims_enabled: lock.config.builtin_anims_enabled,
-            builtin_anims: lock.config.builtin_anims,
-        }
+        DeviceState::from(&lock.config)
     }
-
-    /// Notify listeners of the status of AniMe LED power and factory
-    /// system-status animations
-    #[dbus_interface(signal)]
-    async fn notify_device_state(ctxt: &SignalContext<'_>, data: DeviceState) -> zbus::Result<()>;
 }
 
 #[async_trait]
 impl crate::CtrlTask for CtrlAnimeZbus {
     fn zbus_path() -> &'static str {
-        ZBUS_PATH
+        ANIME_ZBUS_PATH
     }
 
     async fn create_tasks(&self, _: SignalContext<'static>) -> Result<(), RogError> {
@@ -231,36 +271,111 @@ impl crate::CtrlTask for CtrlAnimeZbus {
         let inner3 = self.0.clone();
         let inner4 = self.0.clone();
         self.create_sys_event_tasks(
-            move || {
+            move |sleeping| {
                 // on_sleep
-                let inner1 = inner1.clone();
+                let inner = inner1.clone();
                 async move {
-                    let lock = inner1.lock().await;
-                    CtrlAnime::run_thread(inner1.clone(), lock.cache.sleep.clone(), true).await;
+                    let lock = inner.lock().await;
+                    if lock.config.display_enabled {
+                        lock.thread_exit.store(true, Ordering::Release); // ensure clean slate
+
+                        lock.node
+                            .write_bytes(&pkt_set_enable_display(
+                                !(sleeping && lock.config.off_when_suspended),
+                            ))
+                            .map_err(|err| {
+                                warn!("create_sys_event_tasks::off_when_suspended {}", err);
+                            })
+                            .ok();
+
+                        if lock.config.builtin_anims_enabled {
+                            lock.node
+                                .write_bytes(&pkt_set_enable_powersave_anim(
+                                    !(sleeping && lock.config.off_when_suspended),
+                                ))
+                                .map_err(|err| {
+                                    warn!("create_sys_event_tasks::off_when_suspended {}", err);
+                                })
+                                .ok();
+                        } else if !sleeping && !lock.config.builtin_anims_enabled {
+                            // Run custom wake animation
+                            lock.node
+                                .write_bytes(&pkt_set_enable_powersave_anim(false))
+                                .ok(); // ensure builtins are disabled
+
+                            CtrlAnime::run_thread(inner.clone(), lock.cache.wake.clone(), true)
+                                .await;
+                        }
+                    }
                 }
             },
-            move || {
-                // on_wake
-                let inner2 = inner2.clone();
-                async move {
-                    let lock = inner2.lock().await;
-                    CtrlAnime::run_thread(inner2.clone(), lock.cache.wake.clone(), true).await;
-                }
-            },
-            move || {
+            move |shutting_down| {
                 // on_shutdown
-                let inner3 = inner3.clone();
+                let inner = inner2.clone();
                 async move {
-                    let lock = inner3.lock().await;
-                    CtrlAnime::run_thread(inner3.clone(), lock.cache.shutdown.clone(), true).await;
+                    let lock = inner.lock().await;
+                    if lock.config.display_enabled && !lock.config.builtin_anims_enabled {
+                        if shutting_down {
+                            CtrlAnime::run_thread(inner.clone(), lock.cache.shutdown.clone(), true)
+                                .await;
+                        } else {
+                            CtrlAnime::run_thread(inner.clone(), lock.cache.boot.clone(), true)
+                                .await;
+                        }
+                    }
                 }
             },
-            move || {
-                // on_boot
-                let inner4 = inner4.clone();
+            move |lid_closed| {
+                let inner = inner3.clone();
+                // on lid change
                 async move {
-                    let lock = inner4.lock().await;
-                    CtrlAnime::run_thread(inner4.clone(), lock.cache.boot.clone(), true).await;
+                    let lock = inner.lock().await;
+                    if lock.config.off_when_lid_closed {
+                        if lock.config.builtin_anims_enabled {
+                            lock.node
+                                .write_bytes(&pkt_set_enable_powersave_anim(!lid_closed))
+                                .map_err(|err| {
+                                    warn!("create_sys_event_tasks::off_when_suspended {}", err);
+                                })
+                                .ok();
+                        }
+                        lock.node
+                            .write_bytes(&pkt_set_enable_display(!lid_closed))
+                            .map_err(|err| {
+                                warn!("create_sys_event_tasks::off_when_lid_closed {}", err);
+                            })
+                            .ok();
+                    }
+                }
+            },
+            move |power_plugged| {
+                let inner = inner4.clone();
+                // on power change
+                async move {
+                    let lock = inner.lock().await;
+                    if lock.config.off_when_unplugged {
+                        if lock.config.builtin_anims_enabled {
+                            lock.node
+                                .write_bytes(&pkt_set_enable_powersave_anim(power_plugged))
+                                .map_err(|err| {
+                                    warn!("create_sys_event_tasks::off_when_suspended {}", err);
+                                })
+                                .ok();
+                        }
+                        lock.node
+                            .write_bytes(&pkt_set_enable_display(power_plugged))
+                            .map_err(|err| {
+                                warn!("create_sys_event_tasks::off_when_unplugged {}", err);
+                            })
+                            .ok();
+                    } else {
+                        lock.node
+                            .write_bytes(&pkt_set_brightness(lock.config.brightness_on_battery))
+                            .map_err(|err| {
+                                warn!("create_sys_event_tasks::off_when_unplugged {}", err);
+                            })
+                            .ok();
+                    }
                 }
             },
         )
@@ -275,25 +390,48 @@ impl crate::Reloadable for CtrlAnimeZbus {
     async fn reload(&mut self) -> Result<(), RogError> {
         if let Some(lock) = self.0.try_lock() {
             let anim = &lock.config.builtin_anims;
-            lock.node
-                .write_bytes(&pkt_set_enable_display(lock.config.display_enabled))?;
-            lock.node.write_bytes(&pkt_set_enable_powersave_anim(
+            // Set builtins
+            if lock.config.builtin_anims_enabled {
+                lock.node.write_bytes(&pkt_set_builtin_animations(
+                    anim.boot,
+                    anim.awake,
+                    anim.sleep,
+                    anim.shutdown,
+                ))?;
+            }
+            // Builtins enabled or na?
+            lock.node.set_builtins_enabled(
                 lock.config.builtin_anims_enabled,
-            ))?;
-            lock.node.write_bytes(&pkt_set_builtin_animations(
-                anim.boot,
-                anim.awake,
-                anim.sleep,
-                anim.shutdown,
-            ))?;
+                lock.config.display_brightness,
+            )?;
 
-            if lock.config.builtin_anims_enabled && !lock.cache.boot.is_empty() {
+            let manager = get_logind_manager().await;
+            let lid_closed = manager.lid_closed().await.unwrap_or_default();
+            let power_plugged = manager.on_external_power().await.unwrap_or_default();
+
+            let turn_off = (lid_closed && lock.config.off_when_lid_closed)
+                || (!power_plugged && lock.config.off_when_unplugged);
+            lock.node
+                .write_bytes(&pkt_set_enable_display(!turn_off))
+                .map_err(|err| {
+                    warn!("create_sys_event_tasks::reload {}", err);
+                })
+                .ok();
+
+            if turn_off || !lock.config.display_enabled {
+                lock.node.write_bytes(&pkt_set_enable_display(false))?;
+                // early return so we don't run animation thread
+                return Ok(());
+            }
+
+            if !lock.config.builtin_anims_enabled && !lock.cache.boot.is_empty() {
                 lock.node
                     .write_bytes(&pkt_set_enable_powersave_anim(false))
                     .ok();
+
+                let action = lock.cache.boot.clone();
+                CtrlAnime::run_thread(self.0.clone(), action, true).await;
             }
-            let action = lock.cache.boot.clone();
-            CtrlAnime::run_thread(self.0.clone(), action, true).await;
         }
         Ok(())
     }

asusd/src/ctrl_aura/config.rs

@@ -143,9 +143,9 @@ impl StdConfigLoad for AuraConfig {}
 impl AuraConfig {
     pub fn from_default_support(prod_id: AuraDevice, support_data: &LaptopLedData) -> Self {
         // create a default config here
-        let enabled = if prod_id == AuraDevice::X19b6 {
+        let enabled = if prod_id.is_new_style() {
             AuraPowerConfig::AuraDevRog2(AuraPower::new_all_on())
-        } else if prod_id == AuraDevice::Tuf {
+        } else if prod_id.is_tuf_style() {
             AuraPowerConfig::AuraDevTuf(HashSet::from([
                 AuraDevTuf::Awake,
                 AuraDevTuf::Boot,

asusd/src/ctrl_aura/controller.rs

@@ -1,53 +1,19 @@
 use std::collections::BTreeMap;
 
 use config_traits::{StdConfig, StdConfigLoad};
+use dmi_id::DMIID;
 use log::{info, warn};
 use rog_aura::advanced::{LedUsbPackets, UsbPackets};
 use rog_aura::aura_detection::{LaptopLedData, ASUS_KEYBOARD_DEVICES};
 use rog_aura::usb::{AuraDevice, LED_APPLY, LED_SET};
-use rog_aura::{AuraEffect, AuraZone, Direction, LedBrightness, Speed, GRADIENT, LED_MSG_LEN};
+use rog_aura::{AuraEffect, Direction, LedBrightness, Speed, GRADIENT, LED_MSG_LEN};
 use rog_platform::hid_raw::HidRaw;
 use rog_platform::keyboard_led::KeyboardLed;
-use rog_platform::supported::LedSupportedFunctions;
 
 use super::config::{AuraConfig, AuraPowerConfig};
 use crate::error::RogError;
-use crate::GetSupported;
 
-impl GetSupported for CtrlKbdLed {
-    type A = LedSupportedFunctions;
-
-    fn get_supported() -> Self::A {
-        // let mode = <&str>::from(&<AuraModes>::from(*mode));
-        let laptop = LaptopLedData::get_data();
-
-        let mut prod_id = AuraDevice::Unknown;
-        for prod in ASUS_KEYBOARD_DEVICES {
-            if HidRaw::new(prod.into()).is_ok() {
-                prod_id = prod;
-                break;
-            }
-        }
-
-        let rgb = KeyboardLed::new();
-        if let Ok(p) = rgb.as_ref() {
-            if p.has_kbd_rgb_mode() {
-                prod_id = AuraDevice::Tuf;
-            }
-        }
-
-        LedSupportedFunctions {
-            dev_id: prod_id,
-            brightness: rgb.is_ok(),
-            basic_modes: laptop.basic_modes,
-            basic_zones: laptop.basic_zones,
-            advanced_type: laptop.advanced_type.into(),
-            power_zones: laptop.power_zones,
-        }
-    }
-}
-
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug)]
 pub enum LEDNode {
     KbdLed(KeyboardLed),
     Rog(HidRaw),
@@ -58,15 +24,14 @@ pub struct CtrlKbdLed {
     // TODO: config stores the keyboard type as an AuraPower, use or update this
     pub led_prod: AuraDevice,
     pub led_node: LEDNode,
-    pub kd_brightness: KeyboardLed,
-    pub supported_modes: LaptopLedData,
-    pub flip_effect_write: bool,
+    pub sysfs_node: KeyboardLed,
+    pub supported_data: LaptopLedData,
     pub per_key_mode_active: bool,
     pub config: AuraConfig,
 }
 
 impl CtrlKbdLed {
-    pub fn new(supported_modes: LaptopLedData) -> Result<Self, RogError> {
+    pub fn new(supported_basic_modes: LaptopLedData) -> Result<Self, RogError> {
         let mut led_prod = AuraDevice::Unknown;
         let mut usb_node = None;
         for prod in ASUS_KEYBOARD_DEVICES {
@@ -90,14 +55,12 @@ impl CtrlKbdLed {
         let rgb_led = KeyboardLed::new()?;
 
         if usb_node.is_none() && !rgb_led.has_kbd_rgb_mode() {
-            let dmi = sysfs_class::DmiId::default();
-            if let Ok(prod_family) = dmi.product_family() {
-                if prod_family.contains("TUF") {
-                    warn!(
-                        "kbd_rgb_mode was not found in the /sys/. You require a minimum 6.1 \
-                         kernel and a supported TUF laptop"
-                    );
-                }
+            let dmi = DMIID::new().unwrap_or_default();
+            if dmi.dmi_family.contains("TUF") {
+                warn!(
+                    "kbd_rgb_mode was not found in the /sys/. You require a minimum 6.1 kernel \
+                     and a supported TUF laptop"
+                );
             }
             return Err(RogError::NoAuraKeyboard);
         }
@@ -134,7 +97,7 @@ impl CtrlKbdLed {
                     let mut new_set = Vec::new();
                     // only reuse a zone mode if the mode is supported
                     for mode in loaded {
-                        if supported_modes.basic_modes.contains(&mode.mode) {
+                        if supported_basic_modes.basic_modes.contains(&mode.mode) {
                             new_set.push(mode.clone());
                         }
                     }
@@ -146,50 +109,15 @@ impl CtrlKbdLed {
 
         let ctrl = CtrlKbdLed {
             led_prod,
-            led_node,               // on TUF this is the same as rgb_led / kd_brightness
-            kd_brightness: rgb_led, // If was none then we already returned above
-            supported_modes,
-            flip_effect_write: false,
+            led_node,            // on TUF this is the same as rgb_led / kd_brightness
+            sysfs_node: rgb_led, // If was none then we already returned above
+            supported_data: supported_basic_modes,
             per_key_mode_active: false,
             config: config_loaded,
         };
         Ok(ctrl)
     }
 
-    pub(super) fn get_brightness(&self) -> Result<u8, RogError> {
-        self.kd_brightness
-            .get_brightness()
-            .map_err(RogError::Platform)
-    }
-
-    pub(super) fn set_brightness(&self, brightness: LedBrightness) -> Result<(), RogError> {
-        self.kd_brightness
-            .set_brightness(brightness as u8)
-            .map_err(RogError::Platform)
-    }
-
-    pub fn next_brightness(&mut self) -> Result<(), RogError> {
-        let mut bright = (self.config.brightness as u32) + 1;
-        if bright > 3 {
-            bright = 0;
-        }
-        self.config.brightness = <LedBrightness>::from(bright);
-        self.config.write();
-        self.set_brightness(self.config.brightness)
-    }
-
-    pub fn prev_brightness(&mut self) -> Result<(), RogError> {
-        let mut bright = self.config.brightness as u32;
-        if bright == 0 {
-            bright = 3;
-        } else {
-            bright -= 1;
-        }
-        self.config.brightness = <LedBrightness>::from(bright);
-        self.config.write();
-        self.set_brightness(self.config.brightness)
-    }
-
     /// Set combination state for boot animation/sleep animation/all leds/keys
     /// leds/side leds LED active
     pub(super) fn set_power_states(&mut self) -> Result<(), RogError> {
@@ -210,29 +138,6 @@ impl CtrlKbdLed {
         Ok(())
     }
 
-    /// Set an Aura effect if the effect mode or zone is supported.
-    ///
-    /// 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.basic_modes.contains(&effect.mode)
-            || effect.zone != AuraZone::None
-                && !self.supported_modes.basic_zones.contains(&effect.zone)
-        {
-            return Err(RogError::AuraEffectNotSupported);
-        }
-
-        self.write_mode(&effect)?;
-        self.config.read(); // refresh config if successful
-        self.config.set_builtin(effect);
-        if self.config.brightness == LedBrightness::Off {
-            self.config.brightness = LedBrightness::Med;
-        }
-        self.config.write();
-        self.set_brightness(self.config.brightness)?;
-        Ok(())
-    }
-
     /// Write an effect block. This is for per-key, but can be repurposed to
     /// write the raw factory mode packets - when doing this it is expected that
     /// only the first `Vec` (`effect[0]`) is valid.
@@ -272,47 +177,11 @@ impl CtrlKbdLed {
                     tuf.set_kbd_rgb_mode(&[0, 0, r, g, b, 0])?;
                 }
             }
-            self.flip_effect_write = !self.flip_effect_write;
         }
         Ok(())
     }
 
-    pub(super) fn toggle_mode(&mut self, reverse: bool) -> Result<(), RogError> {
-        let current = self.config.current_mode;
-        if let Some(idx) = self
-            .supported_modes
-            .basic_modes
-            .iter()
-            .position(|v| *v == current)
-        {
-            let mut idx = idx;
-            // goes past end of array
-            if reverse {
-                if idx == 0 {
-                    idx = self.supported_modes.basic_modes.len() - 1;
-                } else {
-                    idx -= 1;
-                }
-            } else {
-                idx += 1;
-                if idx == self.supported_modes.basic_modes.len() {
-                    idx = 0;
-                }
-            }
-            let next = self.supported_modes.basic_modes[idx];
-
-            self.config.read();
-            // if self.config.builtins.contains_key(&next) {
-            self.config.current_mode = next;
-            self.write_current_config_mode()?;
-            // }
-            self.config.write();
-        }
-
-        Ok(())
-    }
-
-    fn write_mode(&mut self, mode: &AuraEffect) -> Result<(), RogError> {
+    pub fn write_mode(&mut self, mode: &AuraEffect) -> Result<(), RogError> {
         if let LEDNode::KbdLed(platform) = &self.led_node {
             let buf = [
                 1,
@@ -376,7 +245,7 @@ impl CtrlKbdLed {
     /// exists.
     fn create_multizone_default(&mut self) -> Result<(), RogError> {
         let mut default = vec![];
-        for (i, tmp) in self.supported_modes.basic_zones.iter().enumerate() {
+        for (i, tmp) in self.supported_data.basic_zones.iter().enumerate() {
             default.push(AuraEffect {
                 mode: self.config.current_mode,
                 zone: *tmp,
@@ -405,87 +274,18 @@ impl CtrlKbdLed {
 mod tests {
     use rog_aura::aura_detection::{LaptopLedData, PowerZones};
     use rog_aura::usb::AuraDevice;
-    use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour};
+    use rog_aura::{AuraModeNum, AuraZone};
     use rog_platform::keyboard_led::KeyboardLed;
 
     use super::CtrlKbdLed;
     use crate::ctrl_aura::config::AuraConfig;
     use crate::ctrl_aura::controller::LEDNode;
 
-    #[test]
-    // #[ignore = "Must be manually run due to detection stage"]
-    fn check_set_mode_errors() {
-        // Checking to ensure set_mode errors when unsupported modes are tried
-        let config = AuraConfig::from_default_support(AuraDevice::X19b6, &LaptopLedData::default());
-        let supported_modes = LaptopLedData {
-            board_name: String::new(),
-            layout_name: "ga401".to_owned(),
-            basic_modes: vec![AuraModeNum::Static],
-            basic_zones: vec![],
-            advanced_type: rog_aura::AdvancedAuraType::None,
-            power_zones: vec![PowerZones::Keyboard, PowerZones::RearGlow],
-        };
-        let mut controller = CtrlKbdLed {
-            led_prod: AuraDevice::X19b6,
-            led_node: LEDNode::None,
-            kd_brightness: KeyboardLed::default(),
-            supported_modes,
-            flip_effect_write: false,
-            per_key_mode_active: false,
-            config,
-        };
-
-        let mut effect = AuraEffect {
-            colour1: Colour {
-                r: 0xff,
-                g: 0x00,
-                b: 0xff,
-            },
-            zone: AuraZone::None,
-            ..Default::default()
-        };
-
-        // This error comes from write_bytes because we don't have a keyboard node
-        // stored
-        assert_eq!(
-            controller
-                .set_effect(effect.clone())
-                .unwrap_err()
-                .to_string(),
-            "No supported Aura keyboard"
-        );
-
-        effect.mode = AuraModeNum::Laser;
-        assert_eq!(
-            controller
-                .set_effect(effect.clone())
-                .unwrap_err()
-                .to_string(),
-            "Aura effect not supported"
-        );
-
-        effect.mode = AuraModeNum::Static;
-        effect.zone = AuraZone::Key2;
-        assert_eq!(
-            controller
-                .set_effect(effect.clone())
-                .unwrap_err()
-                .to_string(),
-            "Aura effect not supported"
-        );
-
-        controller.supported_modes.basic_zones.push(AuraZone::Key2);
-        assert_eq!(
-            controller.set_effect(effect).unwrap_err().to_string(),
-            "No supported Aura keyboard"
-        );
-    }
-
     #[test]
     fn create_multizone_if_no_config() {
         // Checking to ensure set_mode errors when unsupported modes are tried
         let config = AuraConfig::from_default_support(AuraDevice::X19b6, &LaptopLedData::default());
-        let supported_modes = LaptopLedData {
+        let supported_basic_modes = LaptopLedData {
             board_name: String::new(),
             layout_name: "ga401".to_owned(),
             basic_modes: vec![AuraModeNum::Static],
@@ -496,9 +296,8 @@ mod tests {
         let mut controller = CtrlKbdLed {
             led_prod: AuraDevice::X19b6,
             led_node: LEDNode::None,
-            kd_brightness: KeyboardLed::default(),
-            supported_modes,
-            flip_effect_write: false,
+            sysfs_node: KeyboardLed::default(),
+            supported_data: supported_basic_modes,
             per_key_mode_active: false,
             config,
         };
@@ -507,8 +306,8 @@ mod tests {
         assert!(controller.create_multizone_default().is_err());
         assert!(controller.config.multizone.is_none());
 
-        controller.supported_modes.basic_zones.push(AuraZone::Key1);
-        controller.supported_modes.basic_zones.push(AuraZone::Key2);
+        controller.supported_data.basic_zones.push(AuraZone::Key1);
+        controller.supported_data.basic_zones.push(AuraZone::Key2);
         assert!(controller.create_multizone_default().is_ok());
         assert!(controller.config.multizone.is_some());
 
@@ -524,7 +323,7 @@ mod tests {
     fn next_mode_create_multizone_if_no_config() {
         // Checking to ensure set_mode errors when unsupported modes are tried
         let config = AuraConfig::from_default_support(AuraDevice::X19b6, &LaptopLedData::default());
-        let supported_modes = LaptopLedData {
+        let supported_basic_modes = LaptopLedData {
             board_name: String::new(),
             layout_name: "ga401".to_owned(),
             basic_modes: vec![AuraModeNum::Static],
@@ -535,9 +334,8 @@ mod tests {
         let mut controller = CtrlKbdLed {
             led_prod: AuraDevice::X19b6,
             led_node: LEDNode::None,
-            kd_brightness: KeyboardLed::default(),
-            supported_modes,
-            flip_effect_write: false,
+            sysfs_node: KeyboardLed::default(),
+            supported_data: supported_basic_modes,
             per_key_mode_active: false,
             config,
         };

asusd/src/ctrl_aura/trait_impls.rs

@@ -5,35 +5,38 @@ use async_trait::async_trait;
 use config_traits::StdConfig;
 use log::{debug, error, info, warn};
 use rog_aura::advanced::UsbPackets;
+use rog_aura::aura_detection::PowerZones;
 use rog_aura::usb::{AuraDevice, AuraPowerDev};
-use rog_aura::{AuraEffect, AuraModeNum, LedBrightness};
+use rog_aura::{AuraEffect, AuraModeNum, AuraZone, LedBrightness};
 use zbus::export::futures_util::lock::{Mutex, MutexGuard};
 use zbus::export::futures_util::StreamExt;
+use zbus::fdo::Error as ZbErr;
 use zbus::{dbus_interface, Connection, SignalContext};
 
 use super::controller::CtrlKbdLed;
 use crate::error::RogError;
 use crate::CtrlTask;
 
-pub(super) const ZBUS_PATH: &str = "/org/asuslinux/Aura";
+pub const AURA_ZBUS_NAME: &str = "Aura";
+pub const AURA_ZBUS_PATH: &str = "/org/asuslinux/Aura";
 
 #[derive(Clone)]
-pub struct CtrlKbdLedZbus(pub Arc<Mutex<CtrlKbdLed>>);
+pub struct CtrlAuraZbus(pub Arc<Mutex<CtrlKbdLed>>);
 
-impl CtrlKbdLedZbus {
+impl CtrlAuraZbus {
     fn update_config(lock: &mut CtrlKbdLed) -> Result<(), RogError> {
-        let bright = lock.kd_brightness.get_brightness()?;
+        let bright = lock.sysfs_node.get_brightness()?;
         lock.config.read();
-        lock.config.brightness = (bright as u32).into();
+        lock.config.brightness = bright.into();
         lock.config.write();
         Ok(())
     }
 }
 
 #[async_trait]
-impl crate::ZbusRun for CtrlKbdLedZbus {
+impl crate::ZbusRun for CtrlAuraZbus {
     async fn add_to_server(self, server: &mut Connection) {
-        Self::add_to_server_helper(self, ZBUS_PATH, server).await;
+        Self::add_to_server_helper(self, AURA_ZBUS_PATH, server).await;
     }
 }
 
@@ -41,25 +44,142 @@ impl crate::ZbusRun for CtrlKbdLedZbus {
 ///
 /// 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) {
+impl CtrlAuraZbus {
+    /// Return the device type for this Aura keyboard
+    #[dbus_interface(property)]
+    async fn device_type(&self) -> AuraDevice {
         let ctrl = self.0.lock().await;
-        ctrl.set_brightness(brightness)
-            .map_err(|err| warn!("{}", err))
-            .ok();
+        ctrl.led_prod
+    }
+
+    /// Return the current LED brightness
+    #[dbus_interface(property)]
+    async fn brightness(&self) -> Result<LedBrightness, ZbErr> {
+        let ctrl = self.0.lock().await;
+        Ok(ctrl.sysfs_node.get_brightness().map(|n| n.into())?)
+    }
+
+    /// Set the keyboard brightness level (0-3)
+    #[dbus_interface(property)]
+    async fn set_brightness(&mut self, brightness: LedBrightness) -> Result<(), ZbErr> {
+        let ctrl = self.0.lock().await;
+        Ok(ctrl.sysfs_node.set_brightness(brightness.into())?)
+    }
+
+    /// Total levels of brightness available
+    #[dbus_interface(property)]
+    async fn supported_brightness(&self) -> Vec<LedBrightness> {
+        vec![
+            LedBrightness::Off,
+            LedBrightness::Low,
+            LedBrightness::Med,
+            LedBrightness::High,
+        ]
+    }
+
+    /// The total available modes
+    #[dbus_interface(property)]
+    async fn supported_basic_modes(&self) -> Result<Vec<AuraModeNum>, ZbErr> {
+        let ctrl = self.0.lock().await;
+        Ok(ctrl.config.builtins.keys().cloned().collect())
+    }
+
+    #[dbus_interface(property)]
+    async fn supported_basic_zones(&self) -> Result<Vec<AuraZone>, ZbErr> {
+        let ctrl = self.0.lock().await;
+        Ok(ctrl.supported_data.basic_zones.clone())
+    }
+
+    #[dbus_interface(property)]
+    async fn supported_power_zones(&self) -> Result<Vec<PowerZones>, ZbErr> {
+        let ctrl = self.0.lock().await;
+        Ok(ctrl.supported_data.power_zones.clone())
+    }
+
+    /// The current mode data
+    #[dbus_interface(property)]
+    async fn led_mode(&self) -> Result<AuraModeNum, ZbErr> {
+        let ctrl = self.0.lock().await;
+        Ok(ctrl.config.current_mode)
+    }
+
+    /// Set an Aura effect if the effect mode or zone is supported.
+    ///
+    /// On success the aura config file is read to refresh cached values, then
+    /// the effect is stored and config written to disk.
+    #[dbus_interface(property)]
+    async fn set_led_mode(&mut self, num: AuraModeNum) -> Result<(), ZbErr> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.config.current_mode = num;
+        ctrl.write_current_config_mode()?;
+        if ctrl.config.brightness == LedBrightness::Off {
+            ctrl.config.brightness = LedBrightness::Med;
+        }
+        ctrl.sysfs_node
+            .set_brightness(ctrl.config.brightness.into())?;
+        ctrl.config.write();
+        Ok(())
+    }
+
+    /// The current mode data
+    #[dbus_interface(property)]
+    async fn led_mode_data(&self) -> Result<AuraEffect, ZbErr> {
+        let ctrl = self.0.lock().await;
+        let mode = ctrl.config.current_mode;
+        match ctrl.config.builtins.get(&mode) {
+            Some(effect) => Ok(effect.clone()),
+            None => Err(ZbErr::Failed("Could not get the current effect".into())),
+        }
+    }
+
+    /// Set an Aura effect if the effect mode or zone is supported.
+    ///
+    /// On success the aura config file is read to refresh cached values, then
+    /// the effect is stored and config written to disk.
+    #[dbus_interface(property)]
+    async fn set_led_mode_data(&mut self, effect: AuraEffect) -> Result<(), ZbErr> {
+        let mut ctrl = self.0.lock().await;
+        if !ctrl.supported_data.basic_modes.contains(&effect.mode)
+            || effect.zone != AuraZone::None
+                && !ctrl.supported_data.basic_zones.contains(&effect.zone)
+        {
+            return Err(ZbErr::NotSupported(format!(
+                "The Aura effect is not supported: {effect:?}"
+            )));
+        }
+
+        ctrl.write_mode(&effect)?;
+        if ctrl.config.brightness == LedBrightness::Off {
+            ctrl.config.brightness = LedBrightness::Med;
+        }
+        ctrl.sysfs_node
+            .set_brightness(ctrl.config.brightness.into())?;
+        ctrl.config.set_builtin(effect);
+        ctrl.config.write();
+        Ok(())
+    }
+
+    /// Get the data set for every mode available
+    async fn all_mode_data(&self) -> BTreeMap<AuraModeNum, AuraEffect> {
+        let ctrl = self.0.lock().await;
+        ctrl.config.builtins.clone()
+    }
+
+    // As property doesn't work for AuraPowerDev (complexity of serialization?)
+    #[dbus_interface(property)]
+    async fn led_power(&self) -> AuraPowerDev {
+        let ctrl = self.0.lock().await;
+        AuraPowerDev::from(&ctrl.config.enabled)
     }
 
     /// Set a variety of states, input is array of enum.
     /// `enabled` sets if the sent array should be disabled or enabled
     ///
     /// For Modern ROG devices the "enabled" flag is ignored.
-    async fn set_led_power(
-        &mut self,
-        #[zbus(signal_context)] ctxt: SignalContext<'_>,
-        options: AuraPowerDev,
-        enabled: bool,
-    ) -> zbus::fdo::Result<()> {
+    #[dbus_interface(property)]
+    async fn set_led_power(&mut self, options: (AuraPowerDev, bool)) -> Result<(), ZbErr> {
+        let enabled = options.1;
+        let options = options.0;
         let mut ctrl = self.0.lock().await;
         for p in options.tuf {
             ctrl.config.enabled.set_tuf(p, enabled);
@@ -68,158 +188,27 @@ impl CtrlKbdLedZbus {
             ctrl.config.enabled.set_0x1866(p, enabled);
         }
         ctrl.config.enabled.set_0x19b6(options.rog);
-
         ctrl.config.write();
-
-        ctrl.set_power_states().map_err(|e| {
+        Ok(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
-        })?;
-
-        ctrl.set_brightness(ctrl.config.brightness).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(())
-    }
-
-    /// Return the device type for this Aura keyboard
-    async fn device_type(&self) -> AuraDevice {
-        let ctrl = self.0.lock().await;
-        ctrl.led_prod
-    }
-
-    // As property doesn't work for AuraPowerDev (complexity of serialization?)
-    // #[dbus_interface(property)]
-    async fn led_power(&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()
+        })?)
     }
 
     /// On machine that have some form of either per-key keyboard or per-zone
     /// this can be used to write custom effects over dbus. The input is a
     /// nested `Vec<Vec<8>>` where `Vec<u8>` is a raw USB packet
-    async fn direct_addressing_raw(&self, data: UsbPackets) -> zbus::fdo::Result<()> {
+    async fn direct_addressing_raw(&self, data: UsbPackets) -> Result<(), ZbErr> {
         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 {
+impl CtrlTask for CtrlAuraZbus {
     fn zbus_path() -> &'static str {
-        ZBUS_PATH
+        AURA_ZBUS_PATH
     }
 
     async fn create_tasks(&self, _: SignalContext<'static>) -> Result<(), RogError> {
@@ -227,7 +216,8 @@ impl CtrlTask for CtrlKbdLedZbus {
             // If waking up
             if !start {
                 info!("CtrlKbdLedTask reloading brightness and modes");
-                lock.set_brightness(lock.config.brightness)
+                lock.sysfs_node
+                    .set_brightness(lock.config.brightness.into())
                     .map_err(|e| error!("CtrlKbdLedTask: {e}"))
                     .ok();
                 lock.write_current_config_mode()
@@ -241,46 +231,36 @@ impl CtrlTask for CtrlKbdLedZbus {
         };
 
         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 || {
+            move |sleeping| {
                 let inner1 = inner1.clone();
                 async move {
                     let lock = inner1.lock().await;
-                    load_save(true, lock);
+                    load_save(sleeping, lock);
                 }
             },
-            move || {
-                let inner2 = inner2.clone();
-                async move {
-                    let lock = inner2.lock().await;
-                    load_save(false, lock);
-                }
-            },
-            move || {
+            move |_shutting_down| {
                 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);
-                }
+            move |_lid_closed| {
+                // on lid change
+                async move {}
+            },
+            move |_power_plugged| {
+                // power change
+                async move {}
             },
         )
         .await;
 
         let ctrl2 = self.0.clone();
         let ctrl = self.0.lock().await;
-        let watch = ctrl.kd_brightness.monitor_brightness()?;
+        let watch = ctrl.sysfs_node.monitor_brightness()?;
         tokio::spawn(async move {
             let mut buffer = [0; 32];
             watch
@@ -299,7 +279,7 @@ impl CtrlTask for CtrlKbdLedZbus {
 }
 
 #[async_trait]
-impl crate::Reloadable for CtrlKbdLedZbus {
+impl crate::Reloadable for CtrlAuraZbus {
     async fn reload(&mut self) -> Result<(), RogError> {
         let mut ctrl = self.0.lock().await;
         debug!("CtrlKbdLedZbus: reloading keyboard mode");

asusd/src/ctrl_fancurves.rs

@@ -0,0 +1,313 @@
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use config_traits::{StdConfig, StdConfigLoad};
+use futures_lite::StreamExt;
+use log::{debug, error, info, warn};
+use rog_platform::platform::{PlatformPolicy, RogPlatform};
+use rog_profiles::error::ProfileError;
+use rog_profiles::fan_curve_set::CurveData;
+use rog_profiles::{find_fan_curve_node, FanCurvePU, FanCurveProfiles};
+use serde_derive::{Deserialize, Serialize};
+use tokio::sync::Mutex;
+use zbus::{dbus_interface, Connection, SignalContext};
+
+use crate::error::RogError;
+use crate::{CtrlTask, CONFIG_PATH_BASE};
+
+const MOD_NAME: &str = "FanCurveZbus";
+pub const FAN_CURVE_ZBUS_NAME: &str = "FanCurves";
+pub const FAN_CURVE_ZBUS_PATH: &str = "/org/asuslinux/FanCurves";
+
+#[derive(Deserialize, Serialize, Debug, Default)]
+pub struct FanCurveConfig {
+    pub balanced: Vec<CurveData>,
+    pub performance: Vec<CurveData>,
+    pub quiet: Vec<CurveData>,
+    #[serde(skip)]
+    pub current: u8,
+}
+
+impl StdConfig for FanCurveConfig {
+    /// Create a new config. The defaults are zeroed so the device must be read
+    /// to get the actual device defaults.
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn file_name(&self) -> String {
+        "fan_curves.ron".to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        PathBuf::from(CONFIG_PATH_BASE)
+    }
+}
+
+impl StdConfigLoad for FanCurveConfig {}
+
+#[derive(Debug, Clone)]
+pub struct CtrlFanCurveZbus {
+    config: Arc<Mutex<FanCurveConfig>>,
+    fan_curves: Arc<Mutex<FanCurveProfiles>>,
+    platform: RogPlatform,
+}
+
+// Non-zbus-derive impl
+impl CtrlFanCurveZbus {
+    pub fn new() -> Result<Self, RogError> {
+        let platform = RogPlatform::new()?;
+        if platform.has_throttle_thermal_policy() {
+            info!("{MOD_NAME}: Device has profile control available");
+            find_fan_curve_node()?;
+            info!("{MOD_NAME}: Device has fan curves available");
+            let mut config = FanCurveConfig::new();
+            let mut fan_curves = FanCurveProfiles::default();
+
+            // Only do defaults if the config doesn't already exist
+            if !config.file_path().exists() {
+                info!("{MOD_NAME}: Fetching default fan curves");
+
+                for this in [
+                    PlatformPolicy::Balanced,
+                    PlatformPolicy::Performance,
+                    PlatformPolicy::Quiet,
+                ] {
+                    // For each profile we need to switch to it before we
+                    // can read the existing values from hardware. The ACPI method used
+                    // for this is what limits us.
+                    let next = PlatformPolicy::get_next_profile(this);
+                    platform.set_throttle_thermal_policy(next.into())?;
+
+                    let active = platform
+                        .get_throttle_thermal_policy()
+                        .map_or(PlatformPolicy::Balanced, |t| t.into());
+
+                    info!("{MOD_NAME}: {active:?}:");
+                    for curve in fan_curves.get_fan_curves_for(active) {
+                        info!("{}", String::from(curve));
+                    }
+                }
+                config.write();
+            } else {
+                info!("{MOD_NAME}: Fan curves previously stored, loading...");
+                config = config.load();
+                fan_curves.balanced = config.balanced.clone();
+                fan_curves.performance = config.performance.clone();
+                fan_curves.quiet = config.quiet.clone();
+            }
+
+            return Ok(Self {
+                config: Arc::new(Mutex::new(config)),
+                fan_curves: Arc::new(Mutex::new(fan_curves)),
+                platform,
+            });
+        }
+
+        Err(ProfileError::NotSupported.into())
+    }
+
+    pub async fn update_profiles_from_config(&self) {
+        self.fan_curves.lock().await.balanced = self.config.lock().await.balanced.clone();
+        self.fan_curves.lock().await.performance = self.config.lock().await.performance.clone();
+        self.fan_curves.lock().await.quiet = self.config.lock().await.quiet.clone();
+    }
+
+    /// Because this locks both config and fan_curves, it means nothing else can
+    /// hold a lock across this function call. Stupid choice to do this and
+    /// needs to be fixed.
+    pub async fn update_config_from_profiles(&self) {
+        self.config.lock().await.balanced = self.fan_curves.lock().await.balanced.clone();
+        self.config.lock().await.performance = self.fan_curves.lock().await.performance.clone();
+        self.config.lock().await.quiet = self.fan_curves.lock().await.quiet.clone();
+    }
+}
+
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl CtrlFanCurveZbus {
+    /// Set all fan curves for a profile to enabled status. Will also activate a
+    /// fan curve if in the same profile mode
+    async fn set_fan_curves_enabled(
+        &mut self,
+        profile: PlatformPolicy,
+        enabled: bool,
+    ) -> zbus::fdo::Result<()> {
+        self.fan_curves
+            .lock()
+            .await
+            .set_profile_curves_enabled(profile, enabled);
+        self.fan_curves
+            .lock()
+            .await
+            .write_profile_curve_to_platform(profile, &mut find_fan_curve_node()?)?;
+        self.update_config_from_profiles().await;
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    /// Set a single fan curve for a profile to enabled status. Will also
+    /// activate a fan curve if in the same profile mode
+    async fn set_profile_fan_curve_enabled(
+        &mut self,
+        profile: PlatformPolicy,
+        fan: FanCurvePU,
+        enabled: bool,
+    ) -> zbus::fdo::Result<()> {
+        self.fan_curves
+            .lock()
+            .await
+            .set_profile_fan_curve_enabled(profile, fan, enabled);
+        self.fan_curves
+            .lock()
+            .await
+            .write_profile_curve_to_platform(profile, &mut find_fan_curve_node()?)?;
+        self.update_config_from_profiles().await;
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    /// Get the fan-curve data for the currently active PlatformPolicy
+    async fn fan_curve_data(
+        &mut self,
+        profile: PlatformPolicy,
+    ) -> zbus::fdo::Result<Vec<CurveData>> {
+        let curve = self
+            .fan_curves
+            .lock()
+            .await
+            .get_fan_curves_for(profile)
+            .to_vec();
+        Ok(curve)
+    }
+
+    /// 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(
+        &mut self,
+        profile: PlatformPolicy,
+        curve: CurveData,
+    ) -> zbus::fdo::Result<()> {
+        self.fan_curves
+            .lock()
+            .await
+            .save_fan_curve(curve, profile)?;
+        self.fan_curves
+            .lock()
+            .await
+            .write_profile_curve_to_platform(profile, &mut find_fan_curve_node()?)?;
+        self.update_config_from_profiles().await;
+        self.config.lock().await.write();
+        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(&mut self) -> zbus::fdo::Result<()> {
+        let active = self.platform.get_throttle_thermal_policy()?;
+        self.fan_curves
+            .lock()
+            .await
+            .set_active_curve_to_defaults(active.into(), &mut find_fan_curve_node()?)?;
+        self.update_config_from_profiles().await;
+        self.config.lock().await.write();
+        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: PlatformPolicy) -> zbus::fdo::Result<()> {
+        let active = self
+            .platform
+            .get_throttle_thermal_policy()
+            .unwrap_or(PlatformPolicy::Balanced.into());
+
+        self.platform.set_throttle_thermal_policy(profile.into())?;
+        self.fan_curves
+            .lock()
+            .await
+            .set_active_curve_to_defaults(active.into(), &mut find_fan_curve_node()?)?;
+        self.platform.set_throttle_thermal_policy(active)?;
+
+        self.update_config_from_profiles().await;
+        self.config.lock().await.write();
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl crate::ZbusRun for CtrlFanCurveZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, FAN_CURVE_ZBUS_PATH, server).await;
+    }
+}
+
+#[async_trait]
+impl CtrlTask for CtrlFanCurveZbus {
+    fn zbus_path() -> &'static str {
+        FAN_CURVE_ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, _signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
+        let watch_throttle_thermal_policy = self.platform.monitor_throttle_thermal_policy()?;
+        let platform = self.platform.clone();
+        let config = self.config.clone();
+        let fan_curves = self.fan_curves.clone();
+
+        tokio::spawn(async move {
+            let mut buffer = [0; 32];
+            if let Ok(mut stream) = watch_throttle_thermal_policy.into_event_stream(&mut buffer) {
+                while (stream.next().await).is_some() {
+                    debug!("watch_throttle_thermal_policy changed");
+                    if let Ok(profile) = platform.get_throttle_thermal_policy().map_err(|e| {
+                        error!("{MOD_NAME}: get_throttle_thermal_policy error: {e}");
+                    }) {
+                        if profile != config.lock().await.current {
+                            fan_curves
+                                .lock()
+                                .await
+                                .write_profile_curve_to_platform(
+                                    profile.into(),
+                                    &mut find_fan_curve_node().unwrap(),
+                                )
+                                .map_err(|e| {
+                                    warn!("{MOD_NAME}: write_profile_curve_to_platform, {}", e)
+                                })
+                                .ok();
+                            config.lock().await.current = profile;
+                        }
+                    }
+                }
+                dbg!("STREAM ENDED");
+            }
+        });
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl crate::Reloadable for CtrlFanCurveZbus {
+    /// Fetch the active profile and use that to set all related components up
+    async fn reload(&mut self) -> Result<(), RogError> {
+        let active = self.platform.get_throttle_thermal_policy()?.into();
+        if let Ok(mut device) = find_fan_curve_node() {
+            // 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
+            loop {
+                if let Ok(mut curves) = self.fan_curves.try_lock() {
+                    curves.write_profile_curve_to_platform(active, &mut device)?;
+                    break;
+                }
+            }
+        }
+        Ok(())
+    }
+}

asusd/src/ctrl_platform.rs

@@ -1,86 +1,137 @@
-use std::fs::OpenOptions;
-use std::io::{Read, Write};
-use std::path::Path;
 use std::process::Command;
 use std::sync::Arc;
 
 use async_trait::async_trait;
 use config_traits::StdConfig;
-use log::{info, warn};
-use rog_platform::platform::{AsusPlatform, GpuMode};
-use rog_platform::supported::RogBiosSupportedFunctions;
+use log::{debug, error, info, warn};
+use rog_platform::cpu::{CPUControl, CPUGovernor};
+use rog_platform::platform::{GpuMode, PlatformPolicy, Properties, RogPlatform};
+use rog_platform::power::AsusPower;
 use zbus::export::futures_util::lock::Mutex;
-use zbus::{dbus_interface, Connection, SignalContext};
+use zbus::fdo::Error as FdoErr;
+use zbus::{dbus_interface, Connection, ObjectServer, SignalContext};
 
 use crate::config::Config;
+use crate::ctrl_anime::trait_impls::{CtrlAnimeZbus, ANIME_ZBUS_NAME, ANIME_ZBUS_PATH};
+use crate::ctrl_aura::trait_impls::{CtrlAuraZbus, AURA_ZBUS_NAME, AURA_ZBUS_PATH};
+use crate::ctrl_fancurves::{CtrlFanCurveZbus, FAN_CURVE_ZBUS_NAME, FAN_CURVE_ZBUS_PATH};
 use crate::error::RogError;
-use crate::{task_watch_item, CtrlTask, GetSupported};
+use crate::{task_watch_item, task_watch_item_notify, CtrlTask};
 
 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 CtrlPlatform {
-    platform: AsusPlatform,
-    config: Arc<Mutex<Config>>,
+macro_rules! platform_get_value {
+    ($self:ident, $property:tt, $prop_name:literal) => {
+        concat_idents::concat_idents!(has = has_, $property {
+            if $self.platform.has() {
+                concat_idents::concat_idents!(get = get_, $property {
+                    $self.platform
+                    .get()
+                    .map_err(|err| {
+                        warn!("RogPlatform: {}: {}", $prop_name, err);
+                        FdoErr::Failed(format!("RogPlatform: {}: {}", $prop_name, err))
+                    })
+                })
+            } else {
+                info!("RogPlatform: {} not supported", $prop_name);
+                return Err(FdoErr::NotSupported(format!("RogPlatform: {} not supported", $prop_name)));
+            }
+        })
+    }
 }
 
-impl GetSupported for CtrlPlatform {
-    type A = RogBiosSupportedFunctions;
+macro_rules! platform_get_value_if_some {
+    ($self:ident, $property:tt, $prop_name:literal, $default:expr) => {
+        concat_idents::concat_idents!(has = has_, $property {
+            if $self.platform.has() {
+                let lock = $self.config.lock().await;
+                Ok(lock.$property.unwrap_or($default))
+            } else {
+                info!("RogPlatform: {} not supported", $prop_name);
+                return Err(FdoErr::NotSupported(format!("RogPlatform: {} not supported", $prop_name)));
+            }
+        })
+    }
+}
 
-    fn get_supported() -> Self::A {
-        let mut panel_overdrive = false;
-        let mut mini_led_mode = false;
-        let mut dgpu_disable = false;
-        let mut egpu_enable = false;
-        let mut gpu_mux = false;
+macro_rules! platform_set_bool {
+    ($self:ident, $property:tt, $prop_name:literal, $new_value:expr) => {
+        concat_idents::concat_idents!(has = has_, $property {
+            if $self.platform.has() {
+                concat_idents::concat_idents!(set = set_, $property {
+                    $self.platform.set($new_value).map_err(|err| {
+                        error!("RogPlatform: {} {err}", $prop_name);
+                        FdoErr::NotSupported(format!("RogPlatform: {} {err}", $prop_name))
+                    })?;
+                });
+                let mut lock = $self.config.lock().await;
+                lock.$property = $new_value;
+                lock.write();
+                Ok(())
+            } else {
+                info!("RogPlatform: {} not supported", $prop_name);
+                Err(FdoErr::NotSupported(format!("RogPlatform: {} not supported", $prop_name)))
+            }
+        })
+    }
+}
 
-        if let Ok(platform) = AsusPlatform::new() {
-            panel_overdrive = platform.has_panel_od();
-            mini_led_mode = platform.has_mini_led_mode();
-            dgpu_disable = platform.has_dgpu_disable();
-            egpu_enable = platform.has_egpu_enable();
-            gpu_mux = platform.has_gpu_mux_mode();
-        }
-
-        RogBiosSupportedFunctions {
-            post_sound: Path::new(ASUS_POST_LOGO_SOUND).exists(),
-            gpu_mux,
-            panel_overdrive,
-            mini_led_mode,
-            dgpu_disable,
-            egpu_enable,
+/// Intended only for setting platform object values where the value isn't
+/// retained across boots
+macro_rules! platform_set_with_min_max {
+    ($self:ident, $property:tt, $prop_name:literal, $new_value:expr, $min_value:expr, $max_value:expr) => {
+        if !($min_value..=$max_value).contains(&$new_value) {
+            Err(FdoErr::Failed(
+                format!("RogPlatform: {} value not in range {}=..={}", $prop_name, $min_value, $max_value)
+            ))
+        } else {
+            concat_idents::concat_idents!(has = has_, $property {
+                if $self.platform.has() {
+                    concat_idents::concat_idents!(set = set_, $property {
+                        $self.platform.set($new_value).map_err(|err| {
+                            error!("RogPlatform: {} {err}", $prop_name);
+                            FdoErr::NotSupported(format!("RogPlatform: {} {err}", $prop_name))
+                        })?;
+                    });
+                    let mut lock = $self.config.lock().await;
+                    lock.$property = Some($new_value);
+                    lock.write();
+                } else {
+                    error!("RogPlatform: {} not supported", $prop_name);
+                    return Err(FdoErr::NotSupported(format!("RogPlatform: {} not supported", $prop_name)));
+                }
+            });
+            Ok(())
         }
     }
 }
 
+#[derive(Clone)]
+pub struct CtrlPlatform {
+    power: AsusPower,
+    platform: RogPlatform,
+    cpu_control: Option<CPUControl>,
+    config: Arc<Mutex<Config>>,
+}
+
 impl CtrlPlatform {
     pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
-        let platform = AsusPlatform::new()?;
+        let platform = RogPlatform::new()?;
+        let power = AsusPower::new()?;
 
         if !platform.has_gpu_mux_mode() {
             info!("G-Sync Switchable Graphics or GPU MUX not detected");
             info!("Standard graphics switching will still work.");
         }
 
-        if Path::new(ASUS_POST_LOGO_SOUND).exists() {
-            CtrlPlatform::set_path_mutable(ASUS_POST_LOGO_SOUND)?;
-        } else {
-            info!("Switch for POST boot sound not detected");
-        }
-
-        Ok(CtrlPlatform { platform, config })
-    }
-
-    fn set_path_mutable(path: &str) -> Result<(), RogError> {
-        let output = Command::new("/usr/bin/chattr")
-            .arg("-i")
-            .arg(path)
-            .output()
-            .map_err(|err| RogError::Path(path.into(), err))?;
-        info!("Set {} writeable: status: {}", path, output.status);
-        Ok(())
+        Ok(CtrlPlatform {
+            power,
+            platform,
+            config,
+            cpu_control: CPUControl::new()
+                .map_err(|e| error!("Couldn't get CPU control sysfs: {e}"))
+                .ok(),
+        })
     }
 
     fn set_gfx_mode(&self, mode: GpuMode) -> Result<(), RogError> {
@@ -94,232 +145,375 @@ impl CtrlPlatform {
         Ok(())
     }
 
-    pub fn get_boot_sound() -> Result<i8, RogError> {
-        let data = std::fs::read(ASUS_POST_LOGO_SOUND)
-            .map_err(|err| RogError::Read(ASUS_POST_LOGO_SOUND.into(), err))?;
-
-        let idx = data.len() - 1;
-        Ok(data[idx] as i8)
-    }
-
-    pub(super) fn set_boot_sound(on: bool) -> Result<(), RogError> {
-        let path = ASUS_POST_LOGO_SOUND;
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .open(path)
-            .map_err(|err| RogError::Path(path.into(), err))?;
-
-        let mut data = Vec::new();
-        #[allow(clippy::verbose_file_reads)]
-        file.read_to_end(&mut data)
-            .map_err(|err| RogError::Read(path.into(), err))?;
-
-        let idx = data.len() - 1;
-        if on {
-            data[idx] = 1;
-            info!("Set boot POST sound on");
+    async fn run_ac_or_bat_cmd(&self, power_plugged: bool) {
+        let prog: Vec<String> = if power_plugged {
+            // AC ONLINE
+            self.config
+                .lock()
+                .await
+                .ac_command
+                .split_whitespace()
+                .map(|s| s.to_string())
+                .collect()
         } else {
-            data[idx] = 0;
-            info!("Set boot POST sound off");
+            // BATTERY
+            self.config
+                .lock()
+                .await
+                .bat_command
+                .split_whitespace()
+                .map(|s| s.to_string())
+                .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 power_plugged {
+                    error!("AC power command error: {e}");
+                } else {
+                    error!("Battery power command error: {e}");
+                }
+            }
         }
-        file.write_all(&data)
-            .map_err(|err| RogError::Path(path.into(), err))?;
-
-        Ok(())
     }
 
-    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
-        })?;
-        Ok(())
+    fn check_and_set_epp(&self, profile: PlatformPolicy, change_epp: bool) {
+        if !change_epp {
+            info!("PlatformPolicy unlinked from EPP");
+            return;
+        }
+        info!("PlatformPolicy setting EPP");
+        if let Some(cpu) = self.cpu_control.as_ref() {
+            if let Ok(epp) = cpu.get_available_epp() {
+                debug!("Available EPP: {epp:?}");
+                if epp.contains(&profile.into()) {
+                    debug!("Setting {profile:?}");
+                    cpu.set_epp(profile.into()).ok();
+                } else if let Ok(gov) = cpu.get_governor() {
+                    if gov != CPUGovernor::Powersave {
+                        warn!("powersave governor is not is use, you should use it.");
+                    }
+                }
+            }
+        }
+    }
+
+    async fn update_policy_ac_or_bat(&self, power_plugged: bool, change_epp: bool) {
+        let profile = if power_plugged {
+            self.config.lock().await.platform_policy_on_ac
+        } else {
+            self.config.lock().await.platform_policy_on_battery
+        };
+        self.platform
+            .set_throttle_thermal_policy(profile.into())
+            .ok();
+        self.check_and_set_epp(profile, change_epp);
     }
 }
 
 #[dbus_interface(name = "org.asuslinux.Daemon")]
 impl CtrlPlatform {
-    async fn set_gpu_mux_mode(
-        &mut self,
-        #[zbus(signal_context)] ctxt: SignalContext<'_>,
-        mode: GpuMode,
-    ) {
-        self.set_gfx_mode(mode)
-            .map_err(|err| {
-                warn!("CtrlRogBios: set_gpu_mux_mode {}", err);
-                err
-            })
-            .ok();
-        Self::notify_gpu_mux_mode(&ctxt, mode).await.ok();
+    /// Returns a list of property names that this system supports
+    async fn supported_properties(&self) -> Vec<Properties> {
+        let mut supported = Vec::new();
+
+        macro_rules! platform_name {
+            ($property:tt, $prop_name:ty) => {
+                concat_idents::concat_idents!(has = has_, $property {
+                    if self.platform.has() {
+                        supported.push($prop_name.to_owned());
+                    }
+                })
+            }
+        }
+
+        macro_rules! power_name {
+            ($property:tt, $prop_name:ty) => {
+                concat_idents::concat_idents!(has = has_, $property {
+                    if self.power.has() {
+                        supported.push($prop_name.to_owned());
+                    }
+                })
+            }
+        }
+
+        // TODO: automate this
+        power_name!(
+            charge_control_end_threshold,
+            Properties::ChargeControlEndThreshold
+        );
+
+        platform_name!(dgpu_disable, Properties::DgpuDisable);
+        platform_name!(gpu_mux_mode, Properties::GpuMuxMode);
+        platform_name!(post_animation_sound, Properties::PostAnimationSound);
+        platform_name!(panel_od, Properties::PanelOd);
+        platform_name!(mini_led_mode, Properties::MiniLedMode);
+        platform_name!(egpu_enable, Properties::EgpuEnable);
+        platform_name!(throttle_thermal_policy, Properties::PlatformPolicy);
+
+        platform_name!(ppt_pl1_spl, Properties::PptPl1Spl);
+        platform_name!(ppt_pl2_sppt, Properties::PptPl2Sppt);
+        platform_name!(ppt_fppt, Properties::PptFppt);
+        platform_name!(ppt_apu_sppt, Properties::PptApuSppt);
+        platform_name!(ppt_platform_sppt, Properties::PptPlatformSppt);
+        platform_name!(nv_dynamic_boost, Properties::NvDynamicBoost);
+        platform_name!(nv_temp_target, Properties::NvTempTarget);
+
+        supported
     }
 
-    fn gpu_mux_mode(&self) -> GpuMode {
-        match self.platform.get_gpu_mux_mode() {
-            Ok(m) => GpuMode::from_mux(m as u8),
-            Err(e) => {
-                warn!("CtrlRogBios: get_gfx_mode {}", e);
-                GpuMode::Error
-            }
+    async fn supported_interfaces(
+        &self,
+        #[zbus(object_server)] server: &ObjectServer,
+    ) -> Vec<String> {
+        let mut interfaces = Vec::default();
+        if server
+            .interface::<_, CtrlAnimeZbus>(ANIME_ZBUS_PATH)
+            .await
+            .is_ok()
+        {
+            interfaces.push(ANIME_ZBUS_NAME.to_owned());
+        }
+        if server
+            .interface::<_, CtrlAuraZbus>(AURA_ZBUS_PATH)
+            .await
+            .is_ok()
+        {
+            interfaces.push(AURA_ZBUS_NAME.to_owned());
+        }
+        if server
+            .interface::<_, CtrlFanCurveZbus>(FAN_CURVE_ZBUS_PATH)
+            .await
+            .is_ok()
+        {
+            interfaces.push(FAN_CURVE_ZBUS_NAME.to_owned());
+        }
+        interfaces
+    }
+
+    #[dbus_interface(property)]
+    fn charge_control_end_threshold(&self) -> Result<u8, FdoErr> {
+        let limit = self.power.get_charge_control_end_threshold()?;
+        Ok(limit)
+    }
+
+    #[dbus_interface(property)]
+    async fn set_charge_control_end_threshold(&mut self, limit: u8) -> Result<(), FdoErr> {
+        if !(20..=100).contains(&limit) {
+            return Err(RogError::ChargeLimit(limit))?;
+        }
+        self.power.set_charge_control_end_threshold(limit)?;
+        self.config.lock().await.charge_control_end_threshold = limit;
+        Ok(())
+    }
+
+    #[dbus_interface(property)]
+    fn gpu_mux_mode(&self) -> Result<u8, FdoErr> {
+        self.platform.get_gpu_mux_mode().map_err(|err| {
+            warn!("RogPlatform: set_gpu_mux_mode {err}");
+            FdoErr::NotSupported("RogPlatform: set_gpu_mux_mode not supported".to_owned())
+        })
+    }
+
+    #[dbus_interface(property)]
+    async fn set_gpu_mux_mode(&mut self, mode: u8) -> Result<(), FdoErr> {
+        if self.platform.has_gpu_mux_mode() {
+            self.set_gfx_mode(mode.into()).map_err(|err| {
+                warn!("RogPlatform: set_gpu_mux_mode {}", err);
+                FdoErr::Failed(format!("RogPlatform: set_gpu_mux_mode: {err}"))
+            })
+        } else {
+            Err(FdoErr::NotSupported(
+                "RogPlatform: set_gpu_mux_mode not supported".to_owned(),
+            ))
         }
     }
 
-    #[dbus_interface(signal)]
-    async fn notify_gpu_mux_mode(
-        signal_ctxt: &SignalContext<'_>,
-        mode: GpuMode,
-    ) -> zbus::Result<()> {
-    }
-
-    async fn set_post_boot_sound(
+    /// 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_throttle_thermal_policy(
         &mut self,
         #[zbus(signal_context)] ctxt: SignalContext<'_>,
-        on: bool,
-    ) {
-        Self::set_boot_sound(on)
-            .map_err(|err| {
-                warn!("CtrlRogBios: set_post_boot_sound {}", err);
-                err
-            })
-            .ok();
-        Self::notify_post_boot_sound(&ctxt, on)
-            .await
-            .map_err(|err| {
-                warn!("CtrlRogBios: set_post_boot_sound {}", err);
-                err
-            })
-            .ok();
+    ) -> Result<(), FdoErr> {
+        let policy: PlatformPolicy =
+            platform_get_value!(self, throttle_thermal_policy, "throttle_thermal_policy")
+                .map(|n| n.into())?;
+        let policy = PlatformPolicy::next(&policy);
+
+        if self.platform.has_throttle_thermal_policy() {
+            let change_epp = self.config.lock().await.platform_policy_linked_epp;
+            self.check_and_set_epp(policy, change_epp);
+            self.platform
+                .set_throttle_thermal_policy(policy.into())
+                .map_err(|err| {
+                    warn!("RogPlatform: throttle_thermal_policy {}", err);
+                    FdoErr::Failed(format!("RogPlatform: throttle_thermal_policy: {err}"))
+                })?;
+            Ok(self.throttle_thermal_policy_changed(&ctxt).await?)
+        } else {
+            Err(FdoErr::NotSupported(
+                "RogPlatform: throttle_thermal_policy not supported".to_owned(),
+            ))
+        }
     }
 
-    fn post_boot_sound(&self) -> i8 {
-        Self::get_boot_sound()
-            .map_err(|err| {
-                warn!("CtrlRogBios: get_boot_sound {}", err);
-                err
-            })
-            .unwrap_or(-1)
+    #[dbus_interface(property)]
+    fn throttle_thermal_policy(&self) -> Result<PlatformPolicy, FdoErr> {
+        platform_get_value!(self, throttle_thermal_policy, "throttle_thermal_policy")
+            .map(|n| n.into())
     }
 
-    #[dbus_interface(signal)]
-    async fn notify_post_boot_sound(ctxt: &SignalContext<'_>, on: bool) -> zbus::Result<()> {}
+    #[dbus_interface(property)]
+    async fn set_throttle_thermal_policy(&mut self, policy: PlatformPolicy) -> Result<(), FdoErr> {
+        // TODO: watch for external changes
+        if self.platform.has_throttle_thermal_policy() {
+            let change_epp = self.config.lock().await.platform_policy_linked_epp;
+            self.check_and_set_epp(policy, change_epp);
+            self.platform
+                .set_throttle_thermal_policy(policy.into())
+                .map_err(|err| {
+                    warn!("RogPlatform: throttle_thermal_policy {}", err);
+                    FdoErr::Failed(format!("RogPlatform: throttle_thermal_policy: {err}"))
+                })
+        } else {
+            Err(FdoErr::NotSupported(
+                "RogPlatform: throttle_thermal_policy not supported".to_owned(),
+            ))
+        }
+    }
 
-    async fn set_panel_od(&mut self, overdrive: bool) {
-        match self.platform.set_panel_od(overdrive) {
-            Ok(_) => {
-                if let Some(mut lock) = self.config.try_lock() {
-                    lock.panel_od = overdrive;
-                    lock.write();
-                }
-            }
-            Err(err) => warn!("CtrlRogBios: set_panel_overdrive {}", err),
-        };
+    #[dbus_interface(property)]
+    fn post_animation_sound(&self) -> Result<bool, FdoErr> {
+        platform_get_value!(self, post_animation_sound, "post_animation_sound")
+    }
+
+    #[dbus_interface(property)]
+    async fn set_post_animation_sound(&mut self, on: bool) -> Result<(), FdoErr> {
+        if self.platform.has_post_animation_sound() {
+            self.platform.set_post_animation_sound(on).map_err(|err| {
+                warn!("RogPlatform: set_post_animation_sound {}", err);
+                FdoErr::Failed(format!("RogPlatform: set_post_animation_sound: {err}"))
+            })
+        } else {
+            Err(FdoErr::NotSupported(
+                "RogPlatform: set_post_animation_sound not supported".to_owned(),
+            ))
+        }
     }
 
     /// Get the `panel_od` value from platform. Updates the stored value in
     /// internal config also.
-    fn panel_od(&self) -> bool {
-        self.platform
-            .get_panel_od()
-            .map_err(|err| {
-                warn!("CtrlRogBios: get_panel_od {}", err);
-                err
-            })
-            .unwrap_or(false)
+    #[dbus_interface(property)]
+    fn panel_od(&self) -> Result<bool, FdoErr> {
+        platform_get_value!(self, panel_od, "panel_od")
     }
 
-    #[dbus_interface(signal)]
-    async fn notify_panel_od(signal_ctxt: &SignalContext<'_>, overdrive: bool) -> zbus::Result<()> {
-    }
-
-    async fn set_mini_led_mode(&mut self, on: bool) {
-        match self.platform.set_mini_led_mode(on) {
-            Ok(_) => {
-                if let Some(mut lock) = self.config.try_lock() {
-                    lock.mini_led_mode = on;
-                    lock.write();
-                }
-            }
-            Err(err) => warn!("CtrlRogBios: set_mini_led_mode {}", err),
-        };
+    #[dbus_interface(property)]
+    async fn set_panel_od(&mut self, overdrive: bool) -> Result<(), FdoErr> {
+        platform_set_bool!(self, panel_od, "panel_od", overdrive)
     }
 
     /// Get the `panel_od` value from platform. Updates the stored value in
     /// internal config also.
-    fn mini_led_mode(&self) -> bool {
-        self.platform
-            .get_mini_led_mode()
-            .map_err(|err| {
-                warn!("CtrlRogBios: get_mini_led_mode {}", err);
-                err
-            })
-            .unwrap_or(false)
+    #[dbus_interface(property)]
+    fn mini_led_mode(&self) -> Result<bool, FdoErr> {
+        platform_get_value!(self, mini_led_mode, "mini_led_mode")
     }
 
-    #[dbus_interface(signal)]
-    async fn notify_mini_led_mode(signal_ctxt: &SignalContext<'_>, on: 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),
-        };
+    #[dbus_interface(property)]
+    async fn set_mini_led_mode(&mut self, on: bool) -> Result<(), FdoErr> {
+        platform_set_bool!(self, mini_led_mode, "mini_led_mode", on)
     }
 
-    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(property)]
+    fn dgpu_disable(&self) -> Result<bool, FdoErr> {
+        platform_get_value!(self, dgpu_disable, "dgpu_disable")
     }
 
-    #[dbus_interface(signal)]
-    async fn notify_dgpu_disable(
-        signal_ctxt: &SignalContext<'_>,
-        disable: bool,
-    ) -> zbus::Result<()> {
+    #[dbus_interface(property)]
+    fn egpu_enable(&self) -> Result<bool, FdoErr> {
+        platform_get_value!(self, egpu_enable, "egpu_enable")
     }
 
-    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),
-        };
+    /// ************************************************************************
+    #[dbus_interface(property)]
+    async fn ppt_pl1_spl(&self) -> Result<u8, FdoErr> {
+        platform_get_value_if_some!(self, ppt_pl1_spl, "ppt_pl1_spl", 5)
     }
 
-    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(property)]
+    async fn set_ppt_pl1_spl(&mut self, value: u8) -> Result<(), FdoErr> {
+        platform_set_with_min_max!(self, ppt_pl1_spl, "ppt_pl1_spl", value, 5, 250)
     }
 
-    #[dbus_interface(signal)]
-    async fn notify_egpu_enable(signal_ctxt: &SignalContext<'_>, enable: bool) -> zbus::Result<()> {
+    #[dbus_interface(property)]
+    async fn ppt_pl2_sppt(&self) -> Result<u8, FdoErr> {
+        platform_get_value_if_some!(self, ppt_pl2_sppt, "ppt_pl2_sppt", 5)
+    }
+
+    #[dbus_interface(property)]
+    async fn set_ppt_pl2_sppt(&mut self, value: u8) -> Result<(), FdoErr> {
+        platform_set_with_min_max!(self, ppt_pl2_sppt, "ppt_pl2_sppt", value, 5, 250)
+    }
+
+    #[dbus_interface(property)]
+    async fn ppt_fppt(&self) -> Result<u8, FdoErr> {
+        platform_get_value_if_some!(self, ppt_fppt, "ppt_fppt", 5)
+    }
+
+    #[dbus_interface(property)]
+    async fn set_ppt_fppt(&mut self, value: u8) -> Result<(), FdoErr> {
+        platform_set_with_min_max!(self, ppt_fppt, "ppt_fppt", value, 5, 250)
+    }
+
+    #[dbus_interface(property)]
+    async fn ppt_apu_sppt(&self) -> Result<u8, FdoErr> {
+        platform_get_value_if_some!(self, ppt_apu_sppt, "ppt_apu_sppt", 5)
+    }
+
+    #[dbus_interface(property)]
+    async fn set_ppt_apu_sppt(&mut self, value: u8) -> Result<(), FdoErr> {
+        platform_set_with_min_max!(self, ppt_apu_sppt, "ppt_apu_sppt", value, 5, 130)
+    }
+
+    #[dbus_interface(property)]
+    async fn ppt_platform_sppt(&self) -> Result<u8, FdoErr> {
+        platform_get_value_if_some!(self, ppt_platform_sppt, "ppt_platform_sppt", 5)
+    }
+
+    #[dbus_interface(property)]
+    async fn set_ppt_platform_sppt(&mut self, value: u8) -> Result<(), FdoErr> {
+        platform_set_with_min_max!(self, ppt_platform_sppt, "ppt_platform_sppt", value, 5, 130)
+    }
+
+    #[dbus_interface(property)]
+    async fn nv_dynamic_boost(&self) -> Result<u8, FdoErr> {
+        platform_get_value_if_some!(self, nv_dynamic_boost, "nv_dynamic_boost", 5)
+    }
+
+    #[dbus_interface(property)]
+    async fn set_nv_dynamic_boost(&mut self, value: u8) -> Result<(), FdoErr> {
+        platform_set_with_min_max!(self, nv_dynamic_boost, "nv_dynamic_boost", value, 5, 25)
+    }
+
+    #[dbus_interface(property)]
+    async fn nv_temp_target(&self) -> Result<u8, FdoErr> {
+        platform_get_value_if_some!(self, nv_temp_target, "nv_temp_target", 5)
+    }
+
+    #[dbus_interface(property)]
+    async fn set_nv_temp_target(&mut self, value: u8) -> Result<(), FdoErr> {
+        platform_set_with_min_max!(self, nv_temp_target, "nv_temp_target", value, 5, 87)
     }
 }
 
 #[async_trait]
 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;
+        Self::add_to_server_helper(self, ZBUS_PATH, server).await;
     }
 }
 
@@ -327,13 +521,30 @@ impl crate::ZbusRun for CtrlPlatform {
 impl crate::Reloadable for CtrlPlatform {
     async fn reload(&mut self) -> Result<(), RogError> {
         if self.platform.has_panel_od() {
-            let p = if let Some(lock) = self.config.try_lock() {
-                lock.panel_od
-            } else {
-                false
-            };
-            self.set_panel_overdrive(p)?;
+            self.platform
+                .set_panel_od(self.config.lock().await.panel_od)?;
         }
+
+        if self.platform.has_mini_led_mode() {
+            self.platform
+                .set_mini_led_mode(self.config.lock().await.mini_led_mode)?;
+        }
+
+        if self.power.has_charge_control_end_threshold() {
+            self.power.set_charge_control_end_threshold(
+                self.config.lock().await.charge_control_end_threshold,
+            )?;
+        }
+
+        if let Ok(power_plugged) = self.power.get_online() {
+            if self.platform.has_throttle_thermal_policy() {
+                let change_epp = self.config.lock().await.platform_policy_linked_epp;
+                self.update_policy_ac_or_bat(power_plugged > 0, change_epp)
+                    .await;
+            }
+            self.run_ac_or_bat_cmd(power_plugged > 0).await;
+        }
+
         Ok(())
     }
 }
@@ -341,13 +552,32 @@ impl crate::Reloadable for CtrlPlatform {
 impl CtrlPlatform {
     task_watch_item!(panel_od platform);
 
-    task_watch_item!(dgpu_disable platform);
-
-    task_watch_item!(egpu_enable platform);
-
     task_watch_item!(mini_led_mode platform);
+
+    task_watch_item!(charge_control_end_threshold power);
+
+    task_watch_item_notify!(post_animation_sound platform);
+
+    task_watch_item_notify!(dgpu_disable platform);
+
+    task_watch_item_notify!(egpu_enable platform);
+
     // NOTE: see note further below
-    // task_watch_item!(gpu_mux_mode platform);
+    task_watch_item_notify!(gpu_mux_mode platform);
+
+    task_watch_item_notify!(ppt_pl1_spl platform);
+
+    task_watch_item_notify!(ppt_pl2_sppt platform);
+
+    task_watch_item_notify!(ppt_fppt platform);
+
+    task_watch_item_notify!(ppt_apu_sppt platform);
+
+    task_watch_item_notify!(ppt_platform_sppt platform);
+
+    task_watch_item_notify!(nv_dynamic_boost platform);
+
+    task_watch_item_notify!(nv_temp_target platform);
 }
 
 #[async_trait]
@@ -359,16 +589,58 @@ impl CtrlTask for CtrlPlatform {
     async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
         let platform1 = self.clone();
         let platform2 = self.clone();
+        let platform3 = self.clone();
         self.create_sys_event_tasks(
-            move || async { {} },
-            move || {
+            move |sleeping| {
                 let platform1 = platform1.clone();
                 async move {
-                    info!("CtrlRogBios reloading panel_od");
-                    let lock = platform1.config.lock().await;
-                    if platform1.platform.has_panel_od() {
+                    info!("RogPlatform reloading panel_od");
+                    if !sleeping && platform1.platform.has_panel_od() {
                         platform1
-                            .set_panel_overdrive(lock.panel_od)
+                            .platform
+                            .set_panel_od(platform1.config.lock().await.panel_od)
+                            .map_err(|err| {
+                                warn!("CtrlCharge: panel_od {}", err);
+                                err
+                            })
+                            .ok();
+                    }
+                    if sleeping && platform1.power.has_charge_control_end_threshold() {
+                        platform1.config.lock().await.charge_control_end_threshold = platform1
+                            .power
+                            .get_charge_control_end_threshold()
+                            .unwrap_or(100);
+                    } else if !sleeping && platform1.power.has_charge_control_end_threshold() {
+                        platform1
+                            .power
+                            .set_charge_control_end_threshold(
+                                platform1.config.lock().await.charge_control_end_threshold,
+                            )
+                            .ok();
+                    }
+                    if let Ok(power_plugged) = platform1.power.get_online() {
+                        if !sleeping && platform1.platform.has_throttle_thermal_policy() {
+                            let change_epp =
+                                platform1.config.lock().await.platform_policy_linked_epp;
+                            platform1
+                                .update_policy_ac_or_bat(power_plugged > 0, change_epp)
+                                .await;
+                        }
+                        if !sleeping {
+                            platform1.run_ac_or_bat_cmd(power_plugged > 0).await;
+                        }
+                    }
+                }
+            },
+            move |shutting_down| {
+                let platform2 = platform2.clone();
+                async move {
+                    info!("RogPlatform reloading panel_od");
+                    let lock = platform2.config.lock().await;
+                    if !shutting_down && platform2.platform.has_panel_od() {
+                        platform2
+                            .platform
+                            .set_panel_od(lock.panel_od)
                             .map_err(|err| {
                                 warn!("CtrlCharge: panel_od {}", err);
                                 err
@@ -377,33 +649,73 @@ impl CtrlTask for CtrlPlatform {
                     }
                 }
             },
-            move || async { {} },
-            move || {
-                let platform2 = platform2.clone();
+            move |_lid_closed| {
+                // on lid change
+                async move {}
+            },
+            move |power_plugged| {
+                let platform3 = platform3.clone();
+                // power change
                 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)
-                            .map_err(|err| {
-                                warn!("CtrlCharge: panel_od {}", err);
-                                err
-                            })
-                            .ok();
+                    if platform3.platform.has_throttle_thermal_policy() {
+                        let change_epp = platform3.config.lock().await.platform_policy_linked_epp;
+                        platform3
+                            .update_policy_ac_or_bat(power_plugged, change_epp)
+                            .await;
                     }
+                    platform3.run_ac_or_bat_cmd(power_plugged).await;
                 }
             },
         )
         .await;
 
+        // This spawns a new task for every item.
+        // TODO: find a better way to manage this
         self.watch_panel_od(signal_ctxt.clone()).await?;
+        self.watch_mini_led_mode(signal_ctxt.clone()).await?;
+        self.watch_charge_control_end_threshold(signal_ctxt.clone())
+            .await?;
+
         self.watch_dgpu_disable(signal_ctxt.clone()).await?;
         self.watch_egpu_enable(signal_ctxt.clone()).await?;
-        self.watch_mini_led_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?;
+        self.watch_gpu_mux_mode(signal_ctxt.clone()).await?;
+        self.watch_post_animation_sound(signal_ctxt.clone()).await?;
+
+        self.watch_ppt_pl1_spl(signal_ctxt.clone()).await?;
+        self.watch_ppt_pl2_sppt(signal_ctxt.clone()).await?;
+        self.watch_ppt_fppt(signal_ctxt.clone()).await?;
+        self.watch_ppt_apu_sppt(signal_ctxt.clone()).await?;
+        self.watch_ppt_platform_sppt(signal_ctxt.clone()).await?;
+        self.watch_nv_dynamic_boost(signal_ctxt.clone()).await?;
+        self.watch_nv_temp_target(signal_ctxt.clone()).await?;
+
+        let watch_throttle_thermal_policy = self.platform.monitor_throttle_thermal_policy()?;
+        let ctrl = self.clone();
+
+        tokio::spawn(async move {
+            use futures_lite::StreamExt;
+            let mut buffer = [0; 32];
+            if let Ok(mut stream) = watch_throttle_thermal_policy.into_event_stream(&mut buffer) {
+                while (stream.next().await).is_some() {
+                    // this blocks
+                    debug!("Platform: watch_throttle_thermal_policy changed");
+                    if let Ok(profile) = ctrl
+                        .platform
+                        .get_throttle_thermal_policy()
+                        .map(PlatformPolicy::from)
+                        .map_err(|e| {
+                            error!("Platform: get_throttle_thermal_policy error: {e}");
+                        })
+                    {
+                        let change_epp = ctrl.config.lock().await.platform_policy_linked_epp;
+                        ctrl.check_and_set_epp(profile, change_epp);
+                    }
+                }
+            }
+        });
 
         Ok(())
     }

asusd/src/ctrl_power.rs

@@ -1,287 +0,0 @@
-use std::process::Command;
-use std::sync::Arc;
-use std::time::Duration;
-
-use async_trait::async_trait;
-use config_traits::StdConfig;
-use log::{error, info, warn};
-use rog_platform::power::AsusPower;
-use rog_platform::supported::ChargeSupportedFunctions;
-use systemd_zbus::{ManagerProxy as SystemdProxy, Mode, UnitFileState};
-use tokio::time::sleep;
-use zbus::export::futures_util::lock::Mutex;
-use zbus::{dbus_interface, Connection, SignalContext};
-
-use crate::config::Config;
-use crate::error::RogError;
-use crate::{CtrlTask, GetSupported};
-
-const ZBUS_PATH: &str = "/org/asuslinux/Power";
-const NVIDIA_POWERD: &str = "nvidia-powerd.service";
-
-impl GetSupported for CtrlPower {
-    type A = ChargeSupportedFunctions;
-
-    fn get_supported() -> Self::A {
-        ChargeSupportedFunctions {
-            charge_level_set: if let Ok(power) = AsusPower::new() {
-                power.has_charge_control_end_threshold()
-            } else {
-                false
-            },
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct CtrlPower {
-    power: AsusPower,
-    config: Arc<Mutex<Config>>,
-}
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl CtrlPower {
-    async fn set_charge_control_end_threshold(
-        &mut self,
-        #[zbus(signal_context)] ctxt: SignalContext<'_>,
-        limit: u8,
-    ) -> zbus::fdo::Result<()> {
-        if !(20..=100).contains(&limit) {
-            return Err(RogError::ChargeLimit(limit))?;
-        }
-        self.set(limit)
-            .map_err(|err| {
-                warn!("CtrlCharge: set_limit {}", err);
-                err
-            })
-            .ok();
-        Self::notify_charge_control_end_threshold(&ctxt, limit)
-            .await
-            .ok();
-        Ok(())
-    }
-
-    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;
-            }
-        }
-    }
-
-    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_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::ZbusRun for CtrlPower {
-    async fn add_to_server(self, server: &mut Connection) {
-        Self::add_to_server_helper(self, ZBUS_PATH, server).await;
-    }
-}
-
-#[async_trait]
-impl crate::Reloadable for CtrlPower {
-    async fn reload(&mut self) -> Result<(), RogError> {
-        if let Some(mut config) = self.config.try_lock() {
-            config.read();
-            self.set(config.bat_charge_limit)?;
-        }
-        Ok(())
-    }
-}
-
-impl CtrlPower {
-    // task_watch_item!(charge_control_end_threshold power);
-
-    pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
-        Ok(CtrlPower {
-            power: AsusPower::new()?,
-            config,
-        })
-    }
-
-    pub(super) fn set(&self, limit: u8) -> Result<(), RogError> {
-        if !(20..=100).contains(&limit) {
-            return Err(RogError::ChargeLimit(limit));
-        }
-
-        self.power.set_charge_control_end_threshold(limit)?;
-
-        info!("Battery charge limit: {}", limit);
-
-        if let Some(mut config) = self.config.try_lock() {
-            config.read();
-            config.bat_charge_limit = limit;
-            config.write();
-        }
-
-        Ok(())
-    }
-}
-
-#[async_trait]
-impl CtrlTask for CtrlPower {
-    fn zbus_path() -> &'static str {
-        ZBUS_PATH
-    }
-
-    async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
-        let conn = zbus::Connection::system().await?;
-        let sysd1 = SystemdProxy::new(&conn).await?;
-        let sysd2 = sysd1.clone();
-        let sysd3 = sysd1.clone();
-
-        let power1 = self.clone();
-        let power2 = self.clone();
-        self.create_sys_event_tasks(
-            move || async {},
-            move || {
-                let power = power1.clone();
-                let sysd = sysd1.clone();
-                async move {
-                    info!("CtrlCharge reloading charge limit");
-                    let lock = power.config.lock().await;
-                    power
-                        .set(lock.bat_charge_limit)
-                        .map_err(|err| {
-                            warn!("CtrlCharge: set_limit {}", err);
-                            err
-                        })
-                        .ok();
-
-                    if lock.disable_nvidia_powerd_on_battery {
-                        if let Ok(value) = power.power.get_online() {
-                            do_nvidia_powerd_action(&sysd, value == 1).await;
-                        }
-                    }
-                }
-            },
-            move || async {},
-            move || {
-                let power = power2.clone();
-                let sysd = sysd2.clone();
-                async move {
-                    info!("CtrlCharge reloading charge limit");
-                    let lock = power.config.lock().await;
-                    power
-                        .set(lock.bat_charge_limit)
-                        .map_err(|err| {
-                            warn!("CtrlCharge: set_limit {}", err);
-                            err
-                        })
-                        .ok();
-
-                    if lock.disable_nvidia_powerd_on_battery {
-                        if let Ok(value) = power.power.get_online() {
-                            do_nvidia_powerd_action(&sysd, value == 1).await;
-                        }
-                    }
-                }
-            },
-        )
-        .await;
-
-        let config = self.config.clone();
-        // 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 mut config = config.lock().await;
-                        config.read();
-
-                        if config.disable_nvidia_powerd_on_battery {
-                            do_nvidia_powerd_action(&sysd3, value == 1).await;
-                        }
-
-                        Self::notify_mains_online(&signal_ctxt, value == 1)
-                            .await
-                            .unwrap();
-
-                        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
-                // so we need to watch it with a thread and sleep unfortunately
-                sleep(Duration::from_secs(1)).await;
-            }
-        });
-
-        Ok(())
-    }
-}
-
-async fn do_nvidia_powerd_action(proxy: &SystemdProxy<'_>, ac_on: bool) {
-    if let Ok(res) = proxy.get_unit_file_state(NVIDIA_POWERD).await {
-        if res == UnitFileState::Enabled {
-            if ac_on {
-                proxy
-                    .start_unit(NVIDIA_POWERD, Mode::Replace)
-                    .await
-                    .map_err(|e| error!("Error stopping {NVIDIA_POWERD}, {e:?}"))
-                    .ok();
-            } else {
-                proxy
-                    .stop_unit(NVIDIA_POWERD, Mode::Replace)
-                    .await
-                    .map_err(|e| error!("Error stopping {NVIDIA_POWERD}, {e:?}"))
-                    .ok();
-            }
-        }
-    }
-}

asusd/src/ctrl_profiles/config.rs

@@ -1,60 +0,0 @@
-use std::path::PathBuf;
-
-use config_traits::{StdConfig, StdConfigLoad};
-use rog_profiles::fan_curve_set::CurveData;
-use rog_profiles::Profile;
-use serde_derive::{Deserialize, Serialize};
-
-use crate::CONFIG_PATH_BASE;
-
-const CONFIG_FILE: &str = "profile.ron";
-const CONFIG_FAN_FILE: &str = "fan_curves.ron";
-
-#[derive(Deserialize, Serialize, Debug)]
-pub struct ProfileConfig {
-    /// For restore on boot
-    pub active_profile: Profile,
-}
-
-impl StdConfig for ProfileConfig {
-    fn new() -> Self {
-        Self {
-            active_profile: Profile::Balanced,
-        }
-    }
-
-    fn config_dir() -> std::path::PathBuf {
-        PathBuf::from(CONFIG_PATH_BASE)
-    }
-
-    fn file_name(&self) -> String {
-        CONFIG_FILE.to_owned()
-    }
-}
-
-impl StdConfigLoad for ProfileConfig {}
-
-#[derive(Deserialize, Serialize, Debug, Default)]
-pub struct FanCurveConfig {
-    pub balanced: Vec<CurveData>,
-    pub performance: Vec<CurveData>,
-    pub quiet: Vec<CurveData>,
-}
-
-impl StdConfig for FanCurveConfig {
-    /// Create a new config. The defaults are zeroed so the device must be read
-    /// to get the actual device defaults.
-    fn new() -> Self {
-        Self::default()
-    }
-
-    fn file_name(&self) -> String {
-        CONFIG_FAN_FILE.to_owned()
-    }
-
-    fn config_dir() -> std::path::PathBuf {
-        PathBuf::from(CONFIG_PATH_BASE)
-    }
-}
-
-impl StdConfigLoad for FanCurveConfig {}

asusd/src/ctrl_profiles/controller.rs

@@ -1,171 +0,0 @@
-use config_traits::{StdConfig, StdConfigLoad};
-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 super::config::{FanCurveConfig, ProfileConfig};
-use crate::error::RogError;
-use crate::GetSupported;
-
-// TODO: macro wrapper for warn/info/error log macros to add module name
-const MOD_NAME: &str = "CtrlPlatformProfile";
-
-pub struct FanCurves {
-    config_file: FanCurveConfig,
-    profiles: FanCurveProfiles,
-}
-
-impl FanCurves {
-    pub fn update_profiles_from_config(&mut self) {
-        self.profiles.balanced = self.config_file.balanced.clone();
-        self.profiles.performance = self.config_file.performance.clone();
-        self.profiles.quiet = self.config_file.quiet.clone();
-    }
-
-    pub fn update_config_from_profiles(&mut self) {
-        self.config_file.balanced = self.profiles.balanced.clone();
-        self.config_file.performance = self.profiles.performance.clone();
-        self.config_file.quiet = self.profiles.quiet.clone();
-    }
-
-    pub fn profiles(&self) -> &FanCurveProfiles {
-        &self.profiles
-    }
-
-    pub fn profiles_mut(&mut self) -> &mut FanCurveProfiles {
-        &mut self.profiles
-    }
-}
-
-pub struct CtrlPlatformProfile {
-    pub profile_config: ProfileConfig,
-    pub fan_curves: Option<FanCurves>,
-    pub platform: AsusPlatform,
-}
-
-impl GetSupported for CtrlPlatformProfile {
-    type A = PlatformProfileFunctions;
-
-    fn get_supported() -> Self::A {
-        if !Profile::is_platform_profile_supported() {
-            warn!(
-                "platform_profile kernel interface not found, your laptop does not support this, \
-                 or the interface is missing."
-            );
-        }
-
-        let res = FanCurveProfiles::supported_fans();
-
-        if res.is_err() {
-            info!(
-                "fan curves kernel interface not found, your laptop does not support this, or the \
-                 interface is missing."
-            );
-        }
-
-        PlatformProfileFunctions {
-            platform_profile: Profile::is_platform_profile_supported(),
-            fans: res.unwrap_or_default(),
-        }
-    }
-}
-
-impl CtrlPlatformProfile {
-    pub fn new(config: ProfileConfig) -> Result<Self, RogError> {
-        let platform = AsusPlatform::new()?;
-        if platform.has_platform_profile() || platform.has_throttle_thermal_policy() {
-            info!("{MOD_NAME}: Device has profile control available");
-
-            let mut controller = CtrlPlatformProfile {
-                profile_config: config,
-                fan_curves: None,
-                platform,
-            };
-            if FanCurveProfiles::get_device().is_ok() {
-                info!("{MOD_NAME}: Device has fan curves available");
-                let fan_config = FanCurveConfig::new();
-                // Only do defaults if the config doesn't already exist
-                if !fan_config.file_path().exists() {
-                    info!("{MOD_NAME}: Fetching default fan curves");
-                    controller.fan_curves = Some(FanCurves {
-                        config_file: fan_config,
-                        profiles: FanCurveProfiles::default(),
-                    });
-                    for _ in [Profile::Balanced, Profile::Performance, Profile::Quiet] {
-                        // For each profile we need to switch to it before we
-                        // can read the existing values from hardware. The ACPI method used
-                        // for this is what limits us.
-                        let next =
-                            Profile::get_next_profile(controller.profile_config.active_profile);
-                        Profile::set_profile(next)
-                            .map_err(|e| warn!("{MOD_NAME}: set_profile, {}", e))
-                            .ok();
-                        controller.profile_config.active_profile = next;
-
-                        // Make sure to set the baseline to default
-                        controller.set_active_curve_to_defaults()?;
-                        let active = Profile::get_active_profile().unwrap_or(Profile::Balanced);
-
-                        if let Some(curves) = controller.fan_curves.as_ref() {
-                            info!("{MOD_NAME}: {active:?}:");
-                            for curve in curves.profiles().get_fan_curves_for(active) {
-                                info!("{}", String::from(curve));
-                            }
-                        }
-                    }
-                    if let Some(curves) = controller.fan_curves.as_ref() {
-                        curves.config_file.write();
-                    }
-                } else {
-                    info!("{MOD_NAME}: Fan curves previously stored, loading...");
-                    let mut fan_curves = FanCurves {
-                        config_file: fan_config.load(),
-                        profiles: FanCurveProfiles::default(),
-                    };
-                    fan_curves.update_profiles_from_config();
-                    controller.fan_curves = Some(fan_curves);
-                }
-            }
-
-            return Ok(controller);
-        }
-
-        Err(ProfileError::NotSupported.into())
-    }
-
-    pub fn save_config(&mut self) {
-        self.profile_config.write();
-        if let Some(fans) = self.fan_curves.as_mut() {
-            fans.update_config_from_profiles();
-            fans.config_file.write(); // config write
-        }
-    }
-
-    /// Set the curve for the active profile active
-    pub(super) fn write_profile_curve_to_platform(&mut self) -> Result<(), RogError> {
-        if let Some(curves) = &mut self.fan_curves {
-            if let Ok(mut device) = FanCurveProfiles::get_device() {
-                curves.profiles_mut().write_profile_curve_to_platform(
-                    self.profile_config.active_profile,
-                    &mut device,
-                )?;
-            }
-        }
-        Ok(())
-    }
-
-    pub(super) fn set_active_curve_to_defaults(&mut self) -> Result<(), RogError> {
-        if let Some(curves) = self.fan_curves.as_mut() {
-            if let Ok(mut device) = FanCurveProfiles::get_device() {
-                curves.profiles_mut().set_active_curve_to_defaults(
-                    self.profile_config.active_profile,
-                    &mut device,
-                )?;
-                curves.update_config_from_profiles();
-            }
-        }
-        Ok(())
-    }
-}

asusd/src/ctrl_profiles/mod.rs

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

asusd/src/ctrl_profiles/trait_impls.rs

@@ -1,332 +0,0 @@
-use std::str::FromStr;
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use config_traits::StdConfig;
-use log::{error, info, warn};
-use rog_profiles::fan_curve_set::CurveData;
-use rog_profiles::{FanCurvePU, FanCurveProfiles, Profile};
-use zbus::export::futures_util::lock::Mutex;
-use zbus::export::futures_util::StreamExt;
-use zbus::fdo::Error;
-use zbus::{dbus_interface, Connection, SignalContext};
-
-use super::controller::CtrlPlatformProfile;
-use crate::error::RogError;
-use crate::CtrlTask;
-
-const MOD_NAME: &str = "ProfileZbus";
-
-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_owned(),
-        ))
-    }
-
-    /// 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;
-        let next = Profile::get_next_profile(ctrl.profile_config.active_profile);
-        Profile::set_profile(next)
-            .map_err(|e| warn!("{MOD_NAME}: set_profile, {}", e))
-            .ok();
-        ctrl.profile_config.active_profile = next;
-        ctrl.save_config();
-
-        Self::notify_profile(&ctxt, ctrl.profile_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.profile_config.read();
-        Ok(ctrl.profile_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.profile_config.read();
-        Profile::set_profile(profile)
-            .map_err(|e| warn!("{MOD_NAME}: set_profile, {}", e))
-            .ok();
-        ctrl.profile_config.active_profile = profile;
-        ctrl.write_profile_curve_to_platform()
-            .map_err(|e| warn!("{MOD_NAME}: write_profile_curve_to_platform, {}", e))
-            .ok();
-
-        ctrl.save_config();
-
-        Self::notify_profile(&ctxt, ctrl.profile_config.active_profile)
-            .await
-            .ok();
-    }
-
-    /// Set all fan curves for a profile to enabled status. Will also activate a
-    /// fan curve if in the same profile mode
-    async fn set_fan_curves_enabled(
-        &mut self,
-        profile: Profile,
-        enabled: bool,
-    ) -> zbus::fdo::Result<()> {
-        let mut ctrl = self.0.lock().await;
-        ctrl.profile_config.read();
-        if let Some(curves) = &mut ctrl.fan_curves {
-            curves
-                .profiles_mut()
-                .set_profile_curves_enabled(profile, enabled);
-
-            ctrl.write_profile_curve_to_platform()
-                .map_err(|e| warn!("{MOD_NAME}: write_profile_curve_to_platform, {}", e))
-                .ok();
-
-            ctrl.save_config();
-            Ok(())
-        } else {
-            Err(Error::Failed(UNSUPPORTED_MSG.to_owned()))
-        }
-    }
-
-    /// Set a single fan curve for a profile to enabled status. Will also
-    /// activate a fan curve if in the same profile mode
-    async fn set_profile_fan_curve_enabled(
-        &mut self,
-        profile: Profile,
-        fan: FanCurvePU,
-        enabled: bool,
-    ) -> zbus::fdo::Result<()> {
-        let mut ctrl = self.0.lock().await;
-        ctrl.profile_config.read();
-        if let Some(curves) = &mut ctrl.fan_curves {
-            curves
-                .profiles_mut()
-                .set_profile_fan_curve_enabled(profile, fan, enabled);
-
-            ctrl.write_profile_curve_to_platform()
-                .map_err(|e| warn!("{MOD_NAME}: write_profile_curve_to_platform, {}", e))
-                .ok();
-
-            ctrl.save_config();
-            Ok(())
-        } else {
-            Err(Error::Failed(UNSUPPORTED_MSG.to_owned()))
-        }
-    }
-
-    /// Get the fan-curve data for the currently active Profile
-    async fn fan_curve_data(&mut self, profile: Profile) -> zbus::fdo::Result<Vec<CurveData>> {
-        let mut ctrl = self.0.lock().await;
-        ctrl.profile_config.read();
-        if let Some(curves) = &mut ctrl.fan_curves {
-            let curve = curves.profiles().get_fan_curves_for(profile);
-            return Ok(curve.to_vec());
-        }
-        Err(Error::Failed(UNSUPPORTED_MSG.to_owned()))
-    }
-
-    /// 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.profile_config.read();
-        if let Some(curves) = &mut ctrl.fan_curves {
-            curves
-                .profiles_mut()
-                .save_fan_curve(curve, profile)
-                .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
-        } else {
-            return Err(Error::Failed(UNSUPPORTED_MSG.to_owned()));
-        }
-        ctrl.write_profile_curve_to_platform()
-            .map_err(|e| warn!("{MOD_NAME}: 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.profile_config.read();
-        ctrl.set_active_curve_to_defaults()
-            .map_err(|e| warn!("{MOD_NAME}: 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.profile_config.read();
-        let active = Profile::get_active_profile().unwrap_or(Profile::Balanced);
-
-        Profile::set_profile(profile)
-            .map_err(|e| warn!("{MOD_NAME}: set_profile, {}", e))
-            .ok();
-        ctrl.set_active_curve_to_defaults()
-            .map_err(|e| warn!("{MOD_NAME}: Profile::set_active_curve_to_defaults, {}", e))
-            .ok();
-
-        Profile::set_profile(active)
-            .map_err(|e| warn!("{MOD_NAME}: 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 sig_ctx = signal_ctxt.clone();
-        let watch = self
-            .0
-            .lock()
-            .await
-            .platform
-            .monitor_throttle_thermal_policy()?;
-
-        tokio::spawn(async move {
-            let mut buffer = [0; 32];
-            if let Ok(stream) = watch.into_event_stream(&mut buffer) {
-                stream
-                    .for_each(|_| async {
-                        let mut lock = ctrl.lock().await;
-                        if let Ok(profile) =
-                            lock.platform.get_throttle_thermal_policy().map_err(|e| {
-                                error!("{MOD_NAME}: get_throttle_thermal_policy error: {e}");
-                            })
-                        {
-                            let new_profile = Profile::from_throttle_thermal_policy(profile);
-                            if new_profile != lock.profile_config.active_profile {
-                                info!("{MOD_NAME}: platform_profile changed to {new_profile}");
-                                lock.profile_config.active_profile = new_profile;
-                                lock.write_profile_curve_to_platform().unwrap();
-                                lock.save_config();
-                                Profile::set_profile(lock.profile_config.active_profile)
-                                    .map_err(|e| {
-                                        error!("Profile::set_profile() error: {e}");
-                                    })
-                                    .ok();
-
-                                Self::notify_profile(&sig_ctx, lock.profile_config.active_profile)
-                                    .await
-                                    .ok();
-                            }
-                        }
-                    })
-                    .await;
-            }
-        });
-
-        let ctrl = self.0.clone();
-        let watch = self.0.lock().await.platform.monitor_platform_profile()?;
-
-        tokio::spawn(async move {
-            let mut buffer = [0; 32];
-            if let Ok(stream) = watch.into_event_stream(&mut buffer) {
-                stream
-                    .for_each(|_| async {
-                        let mut lock = ctrl.lock().await;
-                        if let Ok(profile) = lock.platform.get_platform_profile().map_err(|e| {
-                            error!("get_platform_profile error: {e}");
-                        }) {
-                            if let Ok(new_profile) = Profile::from_str(&profile).map_err(|e| {
-                                error!("Profile::from_str(&profile) error: {e}");
-                            }) {
-                                if new_profile != lock.profile_config.active_profile {
-                                    info!("{MOD_NAME}: platform_profile changed to {new_profile}");
-                                    lock.profile_config.active_profile = new_profile;
-                                    lock.write_profile_curve_to_platform().unwrap();
-                                    lock.save_config();
-                                    Profile::set_profile(lock.profile_config.active_profile)
-                                        .map_err(|e| {
-                                            error!("Profile::set_profile() error: {e}");
-                                        })
-                                        .ok();
-
-                                    Self::notify_profile(
-                                        &signal_ctxt,
-                                        lock.profile_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.profile_config.active_profile;
-        if let Some(curves) = &mut ctrl.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
-                    .profiles_mut()
-                    .write_profile_curve_to_platform(active, &mut device)?;
-                ctrl.profile_config.write();
-            }
-        }
-        Ok(())
-    }
-}

asusd/src/ctrl_supported.rs

@@ -1,49 +0,0 @@
-use async_trait::async_trait;
-use serde_derive::{Deserialize, Serialize};
-use zbus::zvariant::Type;
-use zbus::{dbus_interface, Connection};
-
-use crate::ctrl_anime::CtrlAnime;
-use crate::ctrl_aura::controller::CtrlKbdLed;
-use crate::ctrl_platform::CtrlPlatform;
-use crate::ctrl_power::CtrlPower;
-use crate::ctrl_profiles::controller::CtrlPlatformProfile;
-use crate::GetSupported;
-
-#[derive(Serialize, Deserialize, Debug, Type)]
-pub struct SupportedFunctions(rog_platform::supported::SupportedFunctions);
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl SupportedFunctions {
-    pub fn supported_functions(
-        &self,
-    ) -> zbus::fdo::Result<&rog_platform::supported::SupportedFunctions> {
-        Ok(&self.0)
-    }
-
-    #[dbus_interface(out_args("answer", "question"))]
-    fn meaning_of_life(&self) -> zbus::fdo::Result<(i32, String)> {
-        Ok((42, String::from("Meaning of life")))
-    }
-}
-
-#[async_trait]
-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;
-    }
-}
-
-impl GetSupported for SupportedFunctions {
-    type A = SupportedFunctions;
-
-    fn get_supported() -> Self::A {
-        Self(rog_platform::supported::SupportedFunctions {
-            anime_ctrl: CtrlAnime::get_supported(),
-            keyboard_led: CtrlKbdLed::get_supported(),
-            charge_ctrl: CtrlPower::get_supported(),
-            platform_profile: CtrlPlatformProfile::get_supported(),
-            rog_bios_ctrl: CtrlPlatform::get_supported(),
-        })
-    }
-}

asusd/src/daemon.rs

@@ -11,19 +11,13 @@ use asusd::ctrl_anime::config::AnimeConfig;
 use asusd::ctrl_anime::trait_impls::CtrlAnimeZbus;
 use asusd::ctrl_anime::CtrlAnime;
 use asusd::ctrl_aura::controller::CtrlKbdLed;
-use asusd::ctrl_aura::trait_impls::CtrlKbdLedZbus;
+use asusd::ctrl_aura::trait_impls::CtrlAuraZbus;
+use asusd::ctrl_fancurves::CtrlFanCurveZbus;
 use asusd::ctrl_platform::CtrlPlatform;
-use asusd::ctrl_power::CtrlPower;
-use asusd::ctrl_profiles::config::ProfileConfig;
-use asusd::ctrl_profiles::controller::CtrlPlatformProfile;
-use asusd::ctrl_profiles::trait_impls::ProfileZbus;
-use asusd::ctrl_supported::SupportedFunctions;
-use asusd::{print_board_info, CtrlTask, GetSupported, Reloadable, ZbusRun};
-use config_traits::{StdConfig, StdConfigLoad, StdConfigLoad2};
+use asusd::{print_board_info, CtrlTask, Reloadable, ZbusRun, DBUS_NAME};
+use config_traits::{StdConfig, StdConfigLoad2, StdConfigLoad3};
 use log::{error, info, warn};
 use rog_aura::aura_detection::LaptopLedData;
-use rog_dbus::DBUS_NAME;
-use rog_profiles::Profile;
 use tokio::time::sleep;
 use zbus::SignalContext;
 
@@ -53,7 +47,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     info!("       daemon v{}", asusd::VERSION);
     info!("    rog-anime v{}", rog_anime::VERSION);
     info!("     rog-aura v{}", rog_aura::VERSION);
-    info!("     rog-dbus v{}", rog_dbus::VERSION);
     info!(" rog-profiles v{}", rog_profiles::VERSION);
     info!("rog-platform v{}", rog_platform::VERSION);
 
@@ -63,9 +56,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
 /// The actual main loop for the daemon
 async fn start_daemon() -> Result<(), Box<dyn Error>> {
-    let supported = SupportedFunctions::get_supported();
+    // let supported = SupportedFunctions::get_supported();
     print_board_info();
-    println!("{:?}", supported.supported_functions());
+    // println!("{:?}", supported.supported_functions());
 
     // Start zbus server
     let mut connection = Connection::system().await?;
@@ -73,7 +66,7 @@ async fn start_daemon() -> Result<(), Box<dyn Error>> {
     let config = Config::new().load();
     let config = Arc::new(Mutex::new(config));
 
-    supported.add_to_server(&mut connection).await;
+    // supported.add_to_server(&mut connection).await;
 
     match CtrlPlatform::new(config.clone()) {
         Ok(ctrl) => {
@@ -85,32 +78,16 @@ async fn start_daemon() -> Result<(), Box<dyn Error>> {
         }
     }
 
-    match CtrlPower::new(config.clone()) {
+    match CtrlFanCurveZbus::new() {
         Ok(ctrl) => {
-            let sig_ctx = CtrlPower::signal_context(&connection)?;
+            let sig_ctx = CtrlFanCurveZbus::signal_context(&connection)?;
             start_tasks(ctrl, &mut connection, sig_ctx).await?;
         }
         Err(err) => {
-            error!("CtrlPower: {}", err);
+            error!("FanCurves: {}", err);
         }
     }
 
-    if Profile::is_platform_profile_supported() {
-        let profile_config = ProfileConfig::new().load();
-        match CtrlPlatformProfile::new(profile_config) {
-            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");
-    }
-
     match CtrlAnime::new(AnimeConfig::new().load()) {
         Ok(ctrl) => {
             let zbus = CtrlAnimeZbus(Arc::new(Mutex::new(ctrl)));
@@ -127,8 +104,8 @@ async fn start_daemon() -> Result<(), Box<dyn Error>> {
     // detection first
     match CtrlKbdLed::new(laptop) {
         Ok(ctrl) => {
-            let zbus = CtrlKbdLedZbus(Arc::new(Mutex::new(ctrl)));
-            let sig_ctx = CtrlKbdLedZbus::signal_context(&connection)?;
+            let zbus = CtrlAuraZbus(Arc::new(Mutex::new(ctrl)));
+            let sig_ctx = CtrlAuraZbus::signal_context(&connection)?;
             start_tasks(zbus, &mut connection, sig_ctx).await?;
         }
         Err(err) => {

asusd/src/lib.rs

@@ -5,30 +5,31 @@ pub mod config;
 pub mod ctrl_anime;
 /// Keyboard LED brightness control, RGB, and LED display modes
 pub mod ctrl_aura;
+/// Control platform profiles + fan-curves if available
+pub mod ctrl_fancurves;
 /// Control ASUS bios function such as boot sound, Optimus/Dedicated gfx mode
 pub mod ctrl_platform;
-/// Control of battery charge level
-pub mod ctrl_power;
-/// Control platform profiles + fan-curves if available
-pub mod ctrl_profiles;
-
-/// Fetch all supported functions for the laptop
-pub mod ctrl_supported;
 
 pub mod error;
 
 use std::future::Future;
+use std::time::Duration;
 
 use async_trait::async_trait;
+use dmi_id::DMIID;
+use futures_lite::stream::StreamExt;
 use log::{debug, info, warn};
 use logind_zbus::manager::ManagerProxy;
-use zbus::export::futures_util::StreamExt;
+use tokio::time::sleep;
 use zbus::zvariant::ObjectPath;
-use zbus::{Connection, SignalContext};
+use zbus::{CacheProperties, Connection, SignalContext};
 
 use crate::error::RogError;
 
 const CONFIG_PATH_BASE: &str = "/etc/asusd/";
+pub static DBUS_NAME: &str = "org.asuslinux.Daemon";
+pub static DBUS_PATH: &str = "/org/asuslinux/Daemon";
+pub static DBUS_IFACE: &str = "org.asuslinux.Daemon";
 
 /// This macro adds a function which spawns an `inotify` task on the passed in
 /// `Executor`.
@@ -46,7 +47,7 @@ const CONFIG_PATH_BASE: &str = "/etc/asusd/";
 /// # Example
 ///
 /// ```ignore
-/// impl CtrlRogBios {
+/// impl RogPlatform {
 ///     task_watch_item!(panel_od platform);
 ///     task_watch_item!(gpu_mux_mode platform);
 /// }
@@ -69,9 +70,45 @@ macro_rules! task_watch_item {
                         tokio::spawn(async move {
                             let mut buffer = [0; 32];
                             watch.into_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();
+                                if let Ok(value) = ctrl.$name() { // get new value from zbus method
+                                    concat_idents::concat_idents!(notif_fn = $name, _changed {
+                                        ctrl.notif_fn(&signal_ctxt).await.ok();
+                                    });
+                                    let mut lock = ctrl.config.lock().await;
+                                    lock.$name = value;
+                                    lock.write();
+                                }
+                            }).await;
+                        });
+                    }
+                    Err(e) => info!("inotify watch failed: {}. You can ignore this if your device does not support the feature", e),
+                }
+            });
+            Ok(())
+        }
+        });
+    };
+}
+
+#[macro_export]
+macro_rules! task_watch_item_notify {
+    ($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(watch) => {
+                        tokio::spawn(async move {
+                            let mut buffer = [0; 32];
+                            watch.into_event_stream(&mut buffer).unwrap().for_each(|_| async {
+                                concat_idents::concat_idents!(notif_fn = $name, _changed {
+                                    ctrl.notif_fn(&signal_ctxt).await.ok();
                                 });
                             }).await;
                         });
@@ -88,12 +125,9 @@ macro_rules! task_watch_item {
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 
 pub fn print_board_info() {
-    let dmi = sysfs_class::DmiId::default();
-    let board_name = dmi.board_name().expect("Could not get board_name");
-    let prod_family = dmi.product_family().expect("Could not get product_family");
-
-    info!("Product family: {}", prod_family.trim());
-    info!("Board name: {}", board_name.trim());
+    let dmi = DMIID::new().unwrap_or_default();
+    info!("Product family: {}", dmi.product_family);
+    info!("Board name: {}", dmi.board_name);
 }
 
 #[async_trait]
@@ -163,15 +197,15 @@ pub trait CtrlTask {
         F4: Send + 'static,
     >(
         &self,
-        mut on_sleep: F1,
-        mut on_wake: F2,
-        mut on_shutdown: F3,
-        mut on_boot: F4,
+        mut on_prepare_for_sleep: F1,
+        mut on_prepare_for_shutdown: F2,
+        mut on_lid_change: F3,
+        mut on_external_power_change: F4,
     ) where
-        F1: FnMut() -> Fut1,
-        F2: FnMut() -> Fut2,
-        F3: FnMut() -> Fut3,
-        F4: FnMut() -> Fut4,
+        F1: FnMut(bool) -> Fut1,
+        F2: FnMut(bool) -> Fut2,
+        F3: FnMut(bool) -> Fut3,
+        F4: FnMut(bool) -> Fut4,
         Fut1: Future<Output = ()> + Send,
         Fut2: Future<Output = ()> + Send,
         Fut3: Future<Output = ()> + Send,
@@ -181,45 +215,66 @@ pub trait CtrlTask {
             .await
             .expect("Controller could not create dbus connection");
 
-        let manager = ManagerProxy::new(&connection)
+        let manager = ManagerProxy::builder(&connection)
+            .cache_properties(CacheProperties::No)
+            .build()
             .await
             .expect("Controller could not create ManagerProxy");
 
+        let manager1 = manager.clone();
         tokio::spawn(async move {
-            if let Ok(mut notif) = manager.receive_prepare_for_sleep().await {
+            if let Ok(mut notif) = manager1.receive_prepare_for_shutdown().await {
                 while let Some(event) = notif.next().await {
+                    // blocks thread :|
                     if let Ok(args) = event.args() {
-                        if args.start {
-                            debug!("Doing on_sleep()");
-                            on_sleep().await;
-                        } else if !args.start() {
-                            debug!("Doing on_wake()");
-                            on_wake().await;
-                        }
+                        debug!("Doing on_prepare_for_shutdown({})", args.start);
+                        on_prepare_for_shutdown(args.start).await;
                     }
                 }
             }
         });
 
-        let manager = ManagerProxy::new(&connection)
-            .await
-            .expect("Controller could not create ManagerProxy");
-
+        let manager2 = manager.clone();
         tokio::spawn(async move {
-            if let Ok(mut notif) = manager.receive_prepare_for_shutdown().await {
+            if let Ok(mut notif) = manager2.receive_prepare_for_sleep().await {
                 while let Some(event) = notif.next().await {
+                    // blocks thread :|
                     if let Ok(args) = event.args() {
-                        if args.start {
-                            debug!("Doing on_shutdown()");
-                            on_shutdown().await;
-                        } else if !args.start() {
-                            debug!("Doing on_boot()");
-                            on_boot().await;
-                        }
+                        debug!("Doing on_prepare_for_sleep({})", args.start);
+                        on_prepare_for_sleep(args.start).await;
                     }
                 }
             }
         });
+
+        let manager3 = manager.clone();
+        tokio::spawn(async move {
+            let mut last_power = manager3.on_external_power().await.unwrap_or_default();
+
+            loop {
+                if let Ok(next) = manager3.on_external_power().await {
+                    if next != last_power {
+                        last_power = next;
+                        on_external_power_change(next).await;
+                    }
+                }
+                sleep(Duration::from_secs(2)).await;
+            }
+        });
+
+        tokio::spawn(async move {
+            let mut last_lid = manager.lid_closed().await.unwrap_or_default();
+            // need to loop on these as they don't emit signals
+            loop {
+                if let Ok(next) = manager.lid_closed().await {
+                    if next != last_lid {
+                        last_lid = next;
+                        on_lid_change(next).await;
+                    }
+                }
+                sleep(Duration::from_secs(2)).await;
+            }
+        });
     }
 }
 

bindings/dbus-xml/org-asuslinux-anime-4.xml

@@ -8,39 +8,6 @@
     <method name="Write">
       <arg name="input" type="(ays)" direction="in"/>
     </method>
-    <!--
-     Set the global AniMe brightness
-     -->
-    <method name="SetImageBrightness">
-      <arg name="bright" type="d" direction="in"/>
-    </method>
-    <!--
-     Set base brightness level
-     -->
-    <method name="SetBrightness">
-      <arg name="brightness" type="s" direction="in"/>
-    </method>
-    <!--
-     Enable the builtin animations or not
-     -->
-    <method name="SetBuiltinsEnabled">
-      <arg name="enabled" type="b" direction="in"/>
-    </method>
-    <!--
-     Set which builtin animation is used for each stage
-     -->
-    <method name="SetBuiltinAnimations">
-      <arg name="boot" type="s" direction="in"/>
-      <arg name="awake" type="s" direction="in"/>
-      <arg name="sleep" type="s" direction="in"/>
-      <arg name="shutdown" type="s" direction="in"/>
-    </method>
-    <!--
-     Set whether the AniMe is enabled at all
-     -->
-    <method name="SetEnableDisplay">
-      <arg name="enabled" type="b" direction="in"/>
-    </method>
     <!--
      The main loop is the base system set action if the user isn't running
      the user daemon
@@ -52,14 +19,39 @@
      Get the device state as stored by asusd
      -->
     <method name="DeviceState">
-      <arg type="bsb(ssss)" direction="out"/>
+      <arg type="(bub(ssss)bbbu)" direction="out"/>
     </method>
     <!--
-     Notify listeners of the status of AniMe LED power and factory
-     system-status animations
+     Set base brightness level
      -->
-    <signal name="NotifyDeviceState">
-      <arg name="data" type="(bsb(ssss))"/>
-    </signal>
+    <!--
+     Set base brightness level
+     -->
+    <property name="Brightness" type="u" access="readwrite"/>
+    <!--
+     Set which builtin animation is used for each stage
+     -->
+    <property name="BuiltinAnimations" type="(ssss)" access="readwrite"/>
+    <!--
+     Enable the builtin animations or not. This is quivalent to "Powersave
+     animations" in Armory crate
+     -->
+    <property name="BuiltinsEnabled" type="b" access="readwrite"/>
+    <!--
+     Set whether the AniMe is enabled at all
+     -->
+    <property name="EnableDisplay" type="b" access="readwrite"/>
+    <!--
+     Set if to turn the AniMe Matrix off when the lid is closed
+     -->
+    <property name="OffWhenLidClosed" type="b" access="readwrite"/>
+    <!--
+     Set if to turn the AniMe Matrix off when the laptop is suspended
+     -->
+    <property name="OffWhenSuspended" type="b" access="readwrite"/>
+    <!--
+     Set if to turn the AniMe Matrix off when external power is unplugged
+     -->
+    <property name="OffWhenUnplugged" type="b" access="readwrite"/>
   </interface>
 </node>

bindings/dbus-xml/org-asuslinux-aura-4.xml

@@ -2,52 +2,10 @@
 <node>
   <interface name="org.asuslinux.Daemon">
     <!--
-     Set the keyboard brightness level (0-3)
+     Get the data set for every mode available
      -->
-    <method name="SetBrightness">
-      <arg name="brightness" type="s" direction="in"/>
-    </method>
-    <!--
-     Set a variety of states, input is array of enum.
-     `enabled` sets if the sent array should be disabled or enabled
-
-     For Modern ROG devices the "enabled" flag is ignored.
-     -->
-    <method name="SetLedPower">
-      <arg name="options" type="(asas((sbbbb)(sbbbb)(sbbbb)(sbbbb)(sbbbb)))" direction="in"/>
-      <arg name="enabled" type="b" direction="in"/>
-    </method>
-    <method name="SetLedMode">
-      <arg name="effect" type="(ss(yyy)(yyy)ss)" direction="in"/>
-    </method>
-    <method name="NextLedMode">
-    </method>
-    <method name="PrevLedMode">
-    </method>
-    <method name="NextLedBrightness">
-    </method>
-    <method name="PrevLedBrightness">
-    </method>
-    <!--
-     Return the device type for this Aura keyboard
-     -->
-    <method name="DeviceType">
-      <arg type="s" direction="out"/>
-    </method>
-    <method name="LedPower">
-      <arg type="asas((sbbbb)(sbbbb)(sbbbb)(sbbbb)(sbbbb))" direction="out"/>
-    </method>
-    <!--
-     Return the current mode data
-     -->
-    <method name="LedMode">
-      <arg type="s" direction="out"/>
-    </method>
-    <!--
-     Return a list of available modes
-     -->
-    <method name="LedModes">
-      <arg type="a{s(ss(yyy)(yyy)ss)}" direction="out"/>
+    <method name="AllModeData">
+      <arg type="a{u(uu(yyy)(yyy)ss)}" direction="out"/>
     </method>
     <!--
      On machine that have some form of either per-key keyboard or per-zone
@@ -57,15 +15,53 @@
     <method name="DirectAddressingRaw">
       <arg name="data" type="aay" direction="in"/>
     </method>
-    <signal name="NotifyLed">
-      <arg name="data" type="(ss(yyy)(yyy)ss)"/>
-    </signal>
-    <signal name="NotifyPowerStates">
-      <arg name="data" type="(asas((sbbbb)(sbbbb)(sbbbb)(sbbbb)(sbbbb)))"/>
-    </signal>
     <!--
      Return the current LED brightness
      -->
-    <property name="LedBrightness" type="n" access="read"/>
+    <!--
+     Set the keyboard brightness level (0-3)
+     -->
+    <property name="Brightness" type="u" access="readwrite"/>
+    <!--
+     Return the device type for this Aura keyboard
+     -->
+    <property name="DeviceType" type="s" access="read"/>
+    <!--
+     The current mode data
+     -->
+    <!--
+     Set an Aura effect if the effect mode or zone is supported.
+
+     On success the aura config file is read to refresh cached values, then
+     the effect is stored and config written to disk.
+     -->
+    <property name="LedMode" type="u" access="readwrite"/>
+    <!--
+     The current mode data
+     -->
+    <!--
+     Set an Aura effect if the effect mode or zone is supported.
+
+     On success the aura config file is read to refresh cached values, then
+     the effect is stored and config written to disk.
+     -->
+    <property name="LedModeData" type="(uu(yyy)(yyy)ss)" access="readwrite"/>
+    <!--
+     Set a variety of states, input is array of enum.
+     `enabled` sets if the sent array should be disabled or enabled
+
+     For Modern ROG devices the "enabled" flag is ignored.
+     -->
+    <property name="LedPower" type="(ayay((ubbbb)(ubbbb)(ubbbb)(ubbbb)(ubbbb)))" access="readwrite"/>
+    <!--
+     The total available modes
+     -->
+    <property name="SupportedBasicModes" type="au" access="read"/>
+    <property name="SupportedBasicZones" type="au" access="read"/>
+    <!--
+     Total levels of brightness available
+     -->
+    <property name="SupportedBrightness" type="au" access="read"/>
+    <property name="SupportedPowerZones" type="au" access="read"/>
   </interface>
 </node>

bindings/dbus-xml/org-asuslinux-fan-curves-4.xml

@@ -2,49 +2,28 @@
 <node>
   <interface name="org.asuslinux.Daemon">
     <!--
-     Fetch profile names
+     Set all fan curves for a profile to enabled status. Will also activate a
+     fan curve if in the same profile mode
      -->
-    <method name="Profiles">
-      <arg type="as" direction="out"/>
-    </method>
-    <!--
-     Toggle to next platform_profile. Names provided by `Profiles`.
-     If fan-curves are supported will also activate a fan curve for profile.
-     -->
-    <method name="NextProfile">
-    </method>
-    <!--
-     Fetch the active profile name
-     -->
-    <method name="ActiveProfile">
-      <arg type="s" direction="out"/>
-    </method>
-    <!--
-     Set this platform_profile name as active
-     -->
-    <method name="SetActiveProfile">
-      <arg name="profile" type="s" direction="in"/>
-    </method>
-    <!--
-     Get a list of profiles that have fan-curves enabled.
-     -->
-    <method name="EnabledFanProfiles">
-      <arg type="as" direction="out"/>
-    </method>
-    <!--
-     Set a profile fan curve enabled status. Will also activate a fan curve
-     if in the same profile mode
-     -->
-    <method name="SetFanCurveEnabled">
+    <method name="SetFanCurvesEnabled">
       <arg name="profile" type="s" direction="in"/>
       <arg name="enabled" type="b" direction="in"/>
     </method>
     <!--
-     Get the fan-curve data for the currently active Profile
+     Set a single fan curve for a profile to enabled status. Will also
+     activate a fan curve if in the same profile mode
+     -->
+    <method name="SetProfileFanCurveEnabled">
+      <arg name="profile" type="s" direction="in"/>
+      <arg name="fan" type="s" direction="in"/>
+      <arg name="enabled" type="b" direction="in"/>
+    </method>
+    <!--
+     Get the fan-curve data for the currently active PlatformPolicy
      -->
     <method name="FanCurveData">
       <arg name="profile" type="s" direction="in"/>
-      <arg type="(b(s(yyyyyyyy)(yyyyyyyy))(s(yyyyyyyy)(yyyyyyyy)))" direction="out"/>
+      <arg type="a(s(yyyyyyyy)(yyyyyyyy)b)" direction="out"/>
     </method>
     <!--
      Set the fan curve for the specified profile.
@@ -52,7 +31,7 @@
      -->
     <method name="SetFanCurve">
       <arg name="profile" type="s" direction="in"/>
-      <arg name="curve" type="(s(yyyyyyyy)(yyyyyyyy))" direction="in"/>
+      <arg name="curve" type="(s(yyyyyyyy)(yyyyyyyy)b)" direction="in"/>
     </method>
     <!--
      Reset the stored (self) and device curve to the defaults of the
@@ -73,8 +52,5 @@
     <method name="ResetProfileCurves">
       <arg name="profile" type="s" direction="in"/>
     </method>
-    <signal name="NotifyProfile">
-      <arg name="profile" type="s"/>
-    </signal>
   </interface>
 </node>

bindings/dbus-xml/org-asuslinux-platform-4.xml

@@ -1,67 +1,46 @@
 <!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
 <node>
   <interface name="org.asuslinux.Daemon">
-    <method name="SetGpuMuxMode">
-      <arg name="mode" type="u" direction="in"/>
+    <!--
+     Returns a list of property names that this system supports
+     -->
+    <method name="SupportedProperties">
+      <arg type="as" direction="out"/>
     </method>
-    <method name="GpuMuxMode">
-      <arg type="u" direction="out"/>
+    <method name="SupportedInterfaces">
+      <arg type="as" direction="out"/>
     </method>
-    <signal name="NotifyGpuMuxMode">
-      <arg name="mode" type="u"/>
-    </signal>
-    <method name="SetPostBootSound">
-      <arg name="on" type="b" direction="in"/>
-    </method>
-    <method name="PostBootSound">
-      <arg type="n" direction="out"/>
-    </method>
-    <signal name="NotifyPostBootSound">
-      <arg name="on" type="b"/>
-    </signal>
-    <method name="SetPanelOd">
-      <arg name="overdrive" type="b" direction="in"/>
+    <!--
+     Toggle to next platform_profile. Names provided by `Profiles`.
+     If fan-curves are supported will also activate a fan curve for profile.
+     -->
+    <method name="NextThrottleThermalPolicy">
     </method>
+    <property name="ChargeControlEndThreshold" type="y" access="readwrite"/>
+    <property name="DgpuDisable" type="b" access="read"/>
+    <property name="EgpuEnable" type="b" access="read"/>
+    <property name="GpuMuxMode" type="y" access="readwrite"/>
     <!--
      Get the `panel_od` value from platform. Updates the stored value in
      internal config also.
      -->
-    <method name="PanelOd">
-      <arg type="b" direction="out"/>
-    </method>
-    <signal name="NotifyPanelOd">
-      <arg name="overdrive" type="b"/>
-    </signal>
-    <method name="SetMiniLedMode">
-      <arg name="on" type="b" direction="in"/>
-    </method>
+    <property name="MiniLedMode" type="b" access="readwrite"/>
+    <property name="NvDynamicBoost" type="y" access="readwrite"/>
+    <property name="NvTempTarget" type="y" access="readwrite"/>
     <!--
      Get the `panel_od` value from platform. Updates the stored value in
      internal config also.
      -->
-    <method name="MiniLedMode">
-      <arg type="b" direction="out"/>
-    </method>
-    <signal name="NotifyMiniLedMode">
-      <arg name="on" type="b"/>
-    </signal>
-    <method name="SetDgpuDisable">
-      <arg name="disable" type="b" direction="in"/>
-    </method>
-    <method name="DgpuDisable">
-      <arg type="b" direction="out"/>
-    </method>
-    <signal name="NotifyDgpuDisable">
-      <arg name="disable" type="b"/>
-    </signal>
-    <method name="SetEgpuEnable">
-      <arg name="enable" type="b" direction="in"/>
-    </method>
-    <method name="EgpuEnable">
-      <arg type="b" direction="out"/>
-    </method>
-    <signal name="NotifyEgpuEnable">
-      <arg name="enable" type="b"/>
-    </signal>
+    <property name="PanelOd" type="b" access="readwrite"/>
+    <property name="PostAnimationSound" type="b" access="readwrite"/>
+    <property name="PptApuSppt" type="y" access="readwrite"/>
+    <property name="PptFppt" type="y" access="readwrite"/>
+    <!--
+     ************************************************************************
+     -->
+    <property name="PptPl1Spl" type="y" access="readwrite"/>
+    <property name="PptPl2Sppt" type="y" access="readwrite"/>
+    <property name="PptPlatformSppt" type="y" access="readwrite"/>
+    <property name="ThrottleThermalPolicy" type="s" access="readwrite"/>
   </interface>
 </node>

bindings/dbus-xml/org-asuslinux-power-4.xml

@@ -1,20 +0,0 @@
-<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
-<node>
-  <interface name="org.asuslinux.Daemon">
-    <method name="SetChargeControlEndThreshold">
-      <arg name="limit" type="y" direction="in"/>
-    </method>
-    <method name="ChargeControlEndThreshold">
-      <arg type="y" direction="out"/>
-    </method>
-    <method name="MainsOnline">
-      <arg type="b" direction="out"/>
-    </method>
-    <signal name="NotifyChargeControlEndThreshold">
-      <arg name="limit" type="y"/>
-    </signal>
-    <signal name="NotifyMainsOnline">
-      <arg name="on" type="b"/>
-    </signal>
-  </interface>
-</node>

bindings/dbus-xml/org-asuslinux-supported-4.xml

@@ -1,12 +0,0 @@
-<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
-<node>
-  <interface name="org.asuslinux.Daemon">
-    <method name="SupportedFunctions">
-      <arg type="b(b)(bb)(sbasassas)(bbbbbb)" direction="out"/>
-    </method>
-    <method name="MeaningOfLife">
-      <arg name="answer" type="i" direction="out"/>
-      <arg name="question" type="s" direction="out"/>
-    </method>
-  </interface>
-</node>

bindings/ts/anime.ts

@@ -1,5 +1,5 @@
 /*
- Generated by typeshare 1.6.0
+ Generated by typeshare 1.7.0
 */
 
 export enum AnimBooting {
@@ -42,6 +42,10 @@ export interface DeviceState {
 	display_brightness: Brightness;
 	builtin_anims_enabled: boolean;
 	builtin_anims: Animations;
+	off_when_unplugged: boolean;
+	off_when_suspended: boolean;
+	off_when_lid_closed: boolean;
+	brightness_on_battery: Brightness;
 }
 
 export enum AnimeType {

bindings/ts/aura.ts

@@ -1,5 +1,5 @@
 /*
- Generated by typeshare 1.6.0
+ Generated by typeshare 1.7.0
 */
 
 /** Represents the per-key raw USB packets */
@@ -227,6 +227,7 @@ export enum AuraDevice {
 	X18c6 = "X18c6",
 	X19b6 = "X19b6",
 	X1a30 = "X1a30",
+	X1abe = "X1abe",
 	Unknown = "Unknown",
 }
 

bindings/ts/platform.ts

@@ -1,48 +1,19 @@
 /*
- Generated by typeshare 1.6.0
+ Generated by typeshare 1.7.0
 */
 
-export type AnimeSupportedFunctions = boolean;
-
-export interface ChargeSupportedFunctions {
-	charge_level_set: boolean;
+export enum CPUGovernor {
+	Performance = "Performance",
+	Powersave = "Powersave",
+	BadValue = "BadValue",
 }
 
-export interface PlatformProfileFunctions {
-	platform_profile: boolean;
-	fan_curves: boolean;
-}
-
-export enum AdvancedAura {
-	None = "None",
-	Zoned = "Zoned",
-	PerKey = "PerKey",
-}
-
-export interface LedSupportedFunctions {
-	dev_id: AuraDevice;
-	brightness: boolean;
-	basic_modes: AuraModeNum[];
-	basic_zones: AuraZone[];
-	advanced_type: AdvancedAura;
-	power_zones: PowerZones[];
-}
-
-export interface RogBiosSupportedFunctions {
-	post_sound: boolean;
-	gpu_mux: boolean;
-	panel_overdrive: boolean;
-	dgpu_disable: boolean;
-	egpu_enable: boolean;
-	mini_led_mode: boolean;
-}
-
-export interface SupportedFunctions {
-	anime_ctrl: AnimeSupportedFunctions;
-	charge_ctrl: ChargeSupportedFunctions;
-	platform_profile: PlatformProfileFunctions;
-	keyboard_led: LedSupportedFunctions;
-	rog_bios_ctrl: RogBiosSupportedFunctions;
+export enum CPUEPP {
+	Default = "Default",
+	Performance = "Performance",
+	BalancePerformance = "BalancePerformance",
+	BalancePower = "BalancePower",
+	Power = "Power",
 }
 
 export enum GpuMode {
@@ -56,3 +27,29 @@ export enum GpuMode {
 	NotSupported = "NotSupported",
 }
 
+/** `throttle_thermal_policy` in asus_wmi */
+export enum PlatformPolicy {
+	Balanced = "Balanced",
+	Performance = "Performance",
+	Quiet = "Quiet",
+}
+
+/** CamelCase names of the properties. Intended for use with DBUS */
+export enum Properties {
+	ChargeControlEndThreshold = "ChargeControlEndThreshold",
+	DgpuDisable = "DgpuDisable",
+	GpuMuxMode = "GpuMuxMode",
+	PostAnimationSound = "PostAnimationSound",
+	PanelOd = "PanelOd",
+	MiniLedMode = "MiniLedMode",
+	EgpuEnable = "EgpuEnable",
+	PlatformPolicy = "PlatformPolicy",
+	PptPl1Spl = "PptPl1Spl",
+	PptPl2Sppt = "PptPl2Sppt",
+	PptFppt = "PptFppt",
+	PptApuSppt = "PptApuSppt",
+	PptPlatformSppt = "PptPlatformSppt",
+	NvDynamicBoost = "NvDynamicBoost",
+	NvTempTarget = "NvTempTarget",
+}
+

bindings/ts/profiles.ts

@@ -1,35 +1,24 @@
 /*
- Generated by typeshare 1.6.0
+ Generated by typeshare 1.7.0
 */
 
 export enum FanCurvePU {
 	CPU = "CPU",
 	GPU = "GPU",
+	MID = "MID",
 }
 
 export interface CurveData {
 	fan: FanCurvePU;
 	pwm: [number, number, number, number, number, number, number, number];
 	temp: [number, number, number, number, number, number, number, number];
-}
-
-/** A `FanCurveSet` contains both CPU and GPU fan curve data */
-export interface FanCurveSet {
 	enabled: boolean;
-	cpu: CurveData;
-	gpu: CurveData;
 }
 
 /** Main purpose of `FanCurves` is to enable restoring state on system boot */
 export interface FanCurveProfiles {
-	balanced: FanCurveSet;
-	performance: FanCurveSet;
-	quiet: FanCurveSet;
-}
-
-export enum Profile {
-	Balanced = "Balanced",
-	Performance = "Performance",
-	Quiet = "Quiet",
+	balanced: CurveData[];
+	performance: CurveData[];
+	quiet: CurveData[];
 }
 

cpuctl/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "cpuctl"
+license = "MPL-2.0"
+edition = "2021"
+version.workspace = true
+
+[dependencies]

cpuctl/src/lib.rs

@@ -0,0 +1,14 @@
+pub fn add(left: usize, right: usize) -> usize {
+    left + right
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_works() {
+        let result = add(2, 2);
+        assert_eq!(result, 4);
+    }
+}

data/asusd.rules

@@ -1,6 +1,3 @@
-#ACTION=="add|change", SUBSYSTEM=="input", ENV{ID_VENDOR_ID}=="0b05", ENV{ID_MODEL_ID}=="1[89][a-zA-Z0-9][a-zA-Z0-9]|193b", ENV{ID_TYPE}=="hid", TAG+="systemd", ENV{SYSTEMD_WANTS}="asusd.service"
-#ACTION=="add|remove", SUBSYSTEM=="input", ENV{ID_VENDOR_ID}=="0b05", ENV{ID_MODEL_ID}=="1[89][a-zA-Z0-9][a-zA-Z0-9]|193b", RUN+="systemctl restart asusd.service"
-
 ENV{DMI_VENDOR}="$attr{[dmi/id]sys_vendor}"
 ENV{DMI_VENDOR}!="ASUSTeK COMPUTER INC.", GOTO="asusd_end"
 

data/asusd.service

@@ -1,15 +1,13 @@
 [Unit]
 Description=ASUS Notebook Control
-StartLimitInterval=200
-StartLimitBurst=2
-Before=multi-user.target
-After=power-profiles-daemon.service
-After=nvidia-powerd.service
+StartLimitInterval=500
+StartLimitBurst=5
+After=nvidia-powerd.service systemd-udevd.service
 
 [Service]
 Environment=IS_SERVICE=1
 Environment=RUST_LOG="info"
-ExecStartPre=/bin/sleep 2
+# ExecStartPre=/bin/sleep 2 # was required only for slow devices
 ExecStart=/usr/bin/asusd
 Restart=on-failure
 RestartSec=1

desktop-extensions/gnome-44/.eslintrc.cjs

@@ -1,25 +0,0 @@
-/* eslint-env node */
-module.exports = {
-    extends: ["eslint:recommended", "plugin:@typescript-eslint/recommended"],
-    parser: "@typescript-eslint/parser",
-    plugins: ["@typescript-eslint"],
-    root: true,
-
-    "rules": {
-    // enable additional rules
-        "indent": ["error", 4],
-        "linebreak-style": ["error", "unix"],
-        "quotes": ["error", "double"],
-        "semi": ["error", "always"],
-
-        // override configuration set by extending "eslint:recommended"
-        "no-empty": "warn",
-        "no-cond-assign": ["error", "always"],
-
-        // disable rules from base configurations
-        "for-direction": "off",
-
-        "@typescript-eslint/no-explicit-any": "warn",
-        "@typescript-eslint/ban-ts-comment": "off"
-    }
-};

desktop-extensions/gnome-44/LICENSE

@@ -1,373 +0,0 @@
-Mozilla Public License Version 2.0
-==================================
-
-1. Definitions
---------------
-
-1.1. "Contributor"
-    means each individual or legal entity that creates, contributes to
-    the creation of, or owns Covered Software.
-
-1.2. "Contributor Version"
-    means the combination of the Contributions of others (if any) used
-    by a Contributor and that particular Contributor's Contribution.
-
-1.3. "Contribution"
-    means Covered Software of a particular Contributor.
-
-1.4. "Covered Software"
-    means Source Code Form to which the initial Contributor has attached
-    the notice in Exhibit A, the Executable Form of such Source Code
-    Form, and Modifications of such Source Code Form, in each case
-    including portions thereof.
-
-1.5. "Incompatible With Secondary Licenses"
-    means
-
-    (a) that the initial Contributor has attached the notice described
-        in Exhibit B to the Covered Software; or
-
-    (b) that the Covered Software was made available under the terms of
-        version 1.1 or earlier of the License, but not also under the
-        terms of a Secondary License.
-
-1.6. "Executable Form"
-    means any form of the work other than Source Code Form.
-
-1.7. "Larger Work"
-    means a work that combines Covered Software with other material, in
-    a separate file or files, that is not Covered Software.
-
-1.8. "License"
-    means this document.
-
-1.9. "Licensable"
-    means having the right to grant, to the maximum extent possible,
-    whether at the time of the initial grant or subsequently, any and
-    all of the rights conveyed by this License.
-
-1.10. "Modifications"
-    means any of the following:
-
-    (a) any file in Source Code Form that results from an addition to,
-        deletion from, or modification of the contents of Covered
-        Software; or
-
-    (b) any new file in Source Code Form that contains any Covered
-        Software.
-
-1.11. "Patent Claims" of a Contributor
-    means any patent claim(s), including without limitation, method,
-    process, and apparatus claims, in any patent Licensable by such
-    Contributor that would be infringed, but for the grant of the
-    License, by the making, using, selling, offering for sale, having
-    made, import, or transfer of either its Contributions or its
-    Contributor Version.
-
-1.12. "Secondary License"
-    means either the GNU General Public License, Version 2.0, the GNU
-    Lesser General Public License, Version 2.1, the GNU Affero General
-    Public License, Version 3.0, or any later versions of those
-    licenses.
-
-1.13. "Source Code Form"
-    means the form of the work preferred for making modifications.
-
-1.14. "You" (or "Your")
-    means an individual or a legal entity exercising rights under this
-    License. For legal entities, "You" includes any entity that
-    controls, is controlled by, or is under common control with You. For
-    purposes of this definition, "control" means (a) the power, direct
-    or indirect, to cause the direction or management of such entity,
-    whether by contract or otherwise, or (b) ownership of more than
-    fifty percent (50%) of the outstanding shares or beneficial
-    ownership of such entity.
-
-2. License Grants and Conditions
---------------------------------
-
-2.1. Grants
-
-Each Contributor hereby grants You a world-wide, royalty-free,
-non-exclusive license:
-
-(a) under intellectual property rights (other than patent or trademark)
-    Licensable by such Contributor to use, reproduce, make available,
-    modify, display, perform, distribute, and otherwise exploit its
-    Contributions, either on an unmodified basis, with Modifications, or
-    as part of a Larger Work; and
-
-(b) under Patent Claims of such Contributor to make, use, sell, offer
-    for sale, have made, import, and otherwise transfer either its
-    Contributions or its Contributor Version.
-
-2.2. Effective Date
-
-The licenses granted in Section 2.1 with respect to any Contribution
-become effective for each Contribution on the date the Contributor first
-distributes such Contribution.
-
-2.3. Limitations on Grant Scope
-
-The licenses granted in this Section 2 are the only rights granted under
-this License. No additional rights or licenses will be implied from the
-distribution or licensing of Covered Software under this License.
-Notwithstanding Section 2.1(b) above, no patent license is granted by a
-Contributor:
-
-(a) for any code that a Contributor has removed from Covered Software;
-    or
-
-(b) for infringements caused by: (i) Your and any other third party's
-    modifications of Covered Software, or (ii) the combination of its
-    Contributions with other software (except as part of its Contributor
-    Version); or
-
-(c) under Patent Claims infringed by Covered Software in the absence of
-    its Contributions.
-
-This License does not grant any rights in the trademarks, service marks,
-or logos of any Contributor (except as may be necessary to comply with
-the notice requirements in Section 3.4).
-
-2.4. Subsequent Licenses
-
-No Contributor makes additional grants as a result of Your choice to
-distribute the Covered Software under a subsequent version of this
-License (see Section 10.2) or under the terms of a Secondary License (if
-permitted under the terms of Section 3.3).
-
-2.5. Representation
-
-Each Contributor represents that the Contributor believes its
-Contributions are its original creation(s) or it has sufficient rights
-to grant the rights to its Contributions conveyed by this License.
-
-2.6. Fair Use
-
-This License is not intended to limit any rights You have under
-applicable copyright doctrines of fair use, fair dealing, or other
-equivalents.
-
-2.7. Conditions
-
-Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
-in Section 2.1.
-
-3. Responsibilities
--------------------
-
-3.1. Distribution of Source Form
-
-All distribution of Covered Software in Source Code Form, including any
-Modifications that You create or to which You contribute, must be under
-the terms of this License. You must inform recipients that the Source
-Code Form of the Covered Software is governed by the terms of this
-License, and how they can obtain a copy of this License. You may not
-attempt to alter or restrict the recipients' rights in the Source Code
-Form.
-
-3.2. Distribution of Executable Form
-
-If You distribute Covered Software in Executable Form then:
-
-(a) such Covered Software must also be made available in Source Code
-    Form, as described in Section 3.1, and You must inform recipients of
-    the Executable Form how they can obtain a copy of such Source Code
-    Form by reasonable means in a timely manner, at a charge no more
-    than the cost of distribution to the recipient; and
-
-(b) You may distribute such Executable Form under the terms of this
-    License, or sublicense it under different terms, provided that the
-    license for the Executable Form does not attempt to limit or alter
-    the recipients' rights in the Source Code Form under this License.
-
-3.3. Distribution of a Larger Work
-
-You may create and distribute a Larger Work under terms of Your choice,
-provided that You also comply with the requirements of this License for
-the Covered Software. If the Larger Work is a combination of Covered
-Software with a work governed by one or more Secondary Licenses, and the
-Covered Software is not Incompatible With Secondary Licenses, this
-License permits You to additionally distribute such Covered Software
-under the terms of such Secondary License(s), so that the recipient of
-the Larger Work may, at their option, further distribute the Covered
-Software under the terms of either this License or such Secondary
-License(s).
-
-3.4. Notices
-
-You may not remove or alter the substance of any license notices
-(including copyright notices, patent notices, disclaimers of warranty,
-or limitations of liability) contained within the Source Code Form of
-the Covered Software, except that You may alter any license notices to
-the extent required to remedy known factual inaccuracies.
-
-3.5. Application of Additional Terms
-
-You may choose to offer, and to charge a fee for, warranty, support,
-indemnity or liability obligations to one or more recipients of Covered
-Software. However, You may do so only on Your own behalf, and not on
-behalf of any Contributor. You must make it absolutely clear that any
-such warranty, support, indemnity, or liability obligation is offered by
-You alone, and You hereby agree to indemnify every Contributor for any
-liability incurred by such Contributor as a result of warranty, support,
-indemnity or liability terms You offer. You may include additional
-disclaimers of warranty and limitations of liability specific to any
-jurisdiction.
-
-4. Inability to Comply Due to Statute or Regulation
----------------------------------------------------
-
-If it is impossible for You to comply with any of the terms of this
-License with respect to some or all of the Covered Software due to
-statute, judicial order, or regulation then You must: (a) comply with
-the terms of this License to the maximum extent possible; and (b)
-describe the limitations and the code they affect. Such description must
-be placed in a text file included with all distributions of the Covered
-Software under this License. Except to the extent prohibited by statute
-or regulation, such description must be sufficiently detailed for a
-recipient of ordinary skill to be able to understand it.
-
-5. Termination
---------------
-
-5.1. The rights granted under this License will terminate automatically
-if You fail to comply with any of its terms. However, if You become
-compliant, then the rights granted under this License from a particular
-Contributor are reinstated (a) provisionally, unless and until such
-Contributor explicitly and finally terminates Your grants, and (b) on an
-ongoing basis, if such Contributor fails to notify You of the
-non-compliance by some reasonable means prior to 60 days after You have
-come back into compliance. Moreover, Your grants from a particular
-Contributor are reinstated on an ongoing basis if such Contributor
-notifies You of the non-compliance by some reasonable means, this is the
-first time You have received notice of non-compliance with this License
-from such Contributor, and You become compliant prior to 30 days after
-Your receipt of the notice.
-
-5.2. If You initiate litigation against any entity by asserting a patent
-infringement claim (excluding declaratory judgment actions,
-counter-claims, and cross-claims) alleging that a Contributor Version
-directly or indirectly infringes any patent, then the rights granted to
-You by any and all Contributors for the Covered Software under Section
-2.1 of this License shall terminate.
-
-5.3. In the event of termination under Sections 5.1 or 5.2 above, all
-end user license agreements (excluding distributors and resellers) which
-have been validly granted by You or Your distributors under this License
-prior to termination shall survive termination.
-
-************************************************************************
-*                                                                      *
-*  6. Disclaimer of Warranty                                           *
-*  -------------------------                                           *
-*                                                                      *
-*  Covered Software is provided under this License on an "as is"       *
-*  basis, without warranty of any kind, either expressed, implied, or  *
-*  statutory, including, without limitation, warranties that the       *
-*  Covered Software is free of defects, merchantable, fit for a        *
-*  particular purpose or non-infringing. The entire risk as to the     *
-*  quality and performance of the Covered Software is with You.        *
-*  Should any Covered Software prove defective in any respect, You     *
-*  (not any Contributor) assume the cost of any necessary servicing,   *
-*  repair, or correction. This disclaimer of warranty constitutes an   *
-*  essential part of this License. No use of any Covered Software is   *
-*  authorized under this License except under this disclaimer.         *
-*                                                                      *
-************************************************************************
-
-************************************************************************
-*                                                                      *
-*  7. Limitation of Liability                                          *
-*  --------------------------                                          *
-*                                                                      *
-*  Under no circumstances and under no legal theory, whether tort      *
-*  (including negligence), contract, or otherwise, shall any           *
-*  Contributor, or anyone who distributes Covered Software as          *
-*  permitted above, be liable to You for any direct, indirect,         *
-*  special, incidental, or consequential damages of any character      *
-*  including, without limitation, damages for lost profits, loss of    *
-*  goodwill, work stoppage, computer failure or malfunction, or any    *
-*  and all other commercial damages or losses, even if such party      *
-*  shall have been informed of the possibility of such damages. This   *
-*  limitation of liability shall not apply to liability for death or   *
-*  personal injury resulting from such party's negligence to the       *
-*  extent applicable law prohibits such limitation. Some               *
-*  jurisdictions do not allow the exclusion or limitation of           *
-*  incidental or consequential damages, so this exclusion and          *
-*  limitation may not apply to You.                                    *
-*                                                                      *
-************************************************************************
-
-8. Litigation
--------------
-
-Any litigation relating to this License may be brought only in the
-courts of a jurisdiction where the defendant maintains its principal
-place of business and such litigation shall be governed by laws of that
-jurisdiction, without reference to its conflict-of-law provisions.
-Nothing in this Section shall prevent a party's ability to bring
-cross-claims or counter-claims.
-
-9. Miscellaneous
-----------------
-
-This License represents the complete agreement concerning the subject
-matter hereof. If any provision of this License is held to be
-unenforceable, such provision shall be reformed only to the extent
-necessary to make it enforceable. Any law or regulation which provides
-that the language of a contract shall be construed against the drafter
-shall not be used to construe this License against a Contributor.
-
-10. Versions of the License
----------------------------
-
-10.1. New Versions
-
-Mozilla Foundation is the license steward. Except as provided in Section
-10.3, no one other than the license steward has the right to modify or
-publish new versions of this License. Each version will be given a
-distinguishing version number.
-
-10.2. Effect of New Versions
-
-You may distribute the Covered Software under the terms of the version
-of the License under which You originally received the Covered Software,
-or under the terms of any subsequent version published by the license
-steward.
-
-10.3. Modified Versions
-
-If you create software not governed by this License, and you want to
-create a new license for such software, you may create and use a
-modified version of this License if you rename the license and remove
-any references to the name of the license steward (except to note that
-such modified license differs from this License).
-
-10.4. Distributing Source Code Form that is Incompatible With Secondary
-Licenses
-
-If You choose to distribute Source Code Form that is Incompatible With
-Secondary Licenses under the terms of this version of the License, the
-notice described in Exhibit B of this License must be attached.
-
-Exhibit A - Source Code Form License Notice
--------------------------------------------
-
-  This Source Code Form is subject to the terms of the Mozilla Public
-  License, v. 2.0. If a copy of the MPL was not distributed with this
-  file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-If it is not possible or desirable to put the notice in a particular
-file, then You may include the notice in a location (such as a LICENSE
-file in a relevant directory) where a recipient would be likely to look
-for such a notice.
-
-You may add additional accurate notices of copyright ownership.
-
-Exhibit B - "Incompatible With Secondary Licenses" Notice
----------------------------------------------------------
-
-  This Source Code Form is "Incompatible With Secondary Licenses", as
-  defined by the Mozilla Public License, v. 2.0.

desktop-extensions/gnome-44/README.md

@@ -1,21 +0,0 @@
-# asusctl
-
-Requires `asusd` to be installed and running.
-
-## build and install
-
-```
-npm install
-npm run build && gnome-extensions install asusctl-gnome@asus-linux.org.zip --force
-npm run build && gnome-extensions enable asusctl-gnome@asus-linux.org.zip
-```
-
-You will need to restart Gnome after installing or updating
-
-## development
-
-```
-npm run build
-gnome-extensions install asusctl-gnome@asus-linux.org.zip --force
-MUTTER_DEBUG_DUMMY_MODE_SPECS=1366x768 dbus-run-session -- gnome-shell --nested --wayland
-```

desktop-extensions/gnome-44/esbuild.js

@@ -1,65 +0,0 @@
-const { build } = require("esbuild");
-const fs = require("fs");
-const path = require("path");
-var exec = require('child_process').exec;
-const AdmZip = require("adm-zip");
-const metadata = require("./src/metadata.json");
-
-build({
-  entryPoints: ['src/extension.ts'],
-  outdir: 'dist',
-  bundle: true,
-  // Do not remove the functions `enable()`, `disable()` and `init()`
-  treeShaking: false,
-  // firefox60  // Since GJS 1.53.90
-  // firefox68  // Since GJS 1.63.90
-  // firefox78  // Since GJS 1.65.90
-  // firefox91  // Since GJS 1.71.1
-  // firefox102 // Since GJS 1.73.2
-  target: "firefox78",
-  platform: "node",
-  // platform: "neutral",
-  // mainFields: ['main'],
-  // conditions: ['require', 'default'],
-  // format: 'cjs',
-  external: ['gi://*', 'system', 'gettext', 'cairo'],
-}).then(() => {
-  const metaSrc = path.resolve(__dirname, "src/metadata.json");
-  const metaDist = path.resolve(__dirname, "dist/metadata.json");
-  const schemaSrc = path.resolve(__dirname, "schemas");
-  const schemaDist = path.resolve(__dirname, "dist/schemas");
-  const dbusXmlSrc = path.resolve(__dirname, "../../bindings/dbus-xml");
-  const dbusXmlDist = path.resolve(__dirname, "dist/resources/dbus");
-  const zipFilename = `${metadata.uuid}.zip`;
-  const zipDist = path.resolve(__dirname, zipFilename);
-
-  exec('glib-compile-schemas schemas/',
-    (error, stdout, stderr) => {
-      console.log('stdout: ' + stdout);
-      console.log('stderr: ' + stderr);
-    });
-
-  fs.copyFileSync(metaSrc, metaDist);
-
-  fs.cpSync(schemaSrc, schemaDist, { recursive: true }, (err) => {
-    if (err) {
-      console.error(err);
-    }
-  });
-
-  fs.cpSync(dbusXmlSrc, dbusXmlDist, { recursive: true }, (err) => {
-    if (err) {
-      console.error(err);
-    }
-  });
-
-  const zip = new AdmZip();
-  zip.addLocalFolder(path.resolve(__dirname, "dist"));
-  zip.writeZip(zipDist);
-
-  console.log(`Build complete. Zip file: ${zipFilename}\n`);
-  console.log(`Install with: gnome-extensions install ${zipFilename}`)
-  console.log(`Update with: gnome-extensions install ${zipFilename} --force`)
-  console.log(`Enable with: gnome-extensions enable ${metadata.uuid} --user`)
-});
-

desktop-extensions/gnome-44/package.json

@@ -1,40 +0,0 @@
-{
-  "name": "asusctl-gnome",
-  "version": "4.7.0",
-  "description": "asusctl-gnome a gnome extension exposing some of the base features of asusd in a helpful and easy to use way",
-  "main": "dist/extension.js",
-  "scripts": {
-    "clear": "rm -rf dist",
-    "build:app": "node esbuild.js",
-    "build": "yarn run clear && yarn run build:app",
-    "validate": "tsc --noEmit"
-  },
-  "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^5.60.1",
-    "@typescript-eslint/parser": "^5.60.1",
-    "adm-zip": "^0.5.10",
-    "esbuild": "^0.17.19",
-    "eslint": "^8.44.0",
-    "typescript": "^5.1.6"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@gitlab.com/asus-linux/asusctl.git"
-  },
-  "keywords": [
-    "gnome-shell",
-    "extension",
-    "asusctl",
-    "asus",
-    "rog",
-    "gnome",
-    "gjs",
-    "typescript"
-  ],
-  "author": "Armas Spann, Marco Laux, Luke Jones",
-  "license": "MPL-2",
-  "bugs": {
-    "url": "https://gitlab.com/asus-linux/asusctl/issues"
-  },
-  "homepage": "https://gitlab.com/asus-linux/asusctl/desktop-extensions/gnome#readme"
-}

desktop-extensions/gnome-44/schemas/org.gnome.shell.extensions.asusctl-gnome.gschema.xml

@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<schemalist gettext-domain="AsusctlGnomeExtension">
-  <schema id="org.gnome.shell.extensions.asusctl-gnome" path="/org/gnome/shell/extensions/asusctl-gnome/" >
-    <key type="b" name="mini-led-enabled">
-      <default>false</default>
-    </key>
-    <key type="b" name="panel-od-enabled">
-      <default>false</default>
-    </key>
-    <key type="b" name="anime-power">
-      <default>false</default>
-    </key>
-    <key name="charge-level" type="u">
-      <range min="20" max="100"/>
-      <default>100</default>
-    </key>
-    <key type="s" name="primary-quickmenu-toggle">
-      <default>"mini-led"</default>
-    </key>
-  </schema>
-</schemalist>

desktop-extensions/gnome-44/src/bindings

@@ -1 +0,0 @@
-../../../bindings/ts

desktop-extensions/gnome-44/src/extension.ts

@@ -1,112 +0,0 @@
-import { AnimeDbus } from "./modules/dbus/animatrix";
-import { Power } from "./modules/dbus/power";
-import { Supported } from "./modules/dbus/supported";
-import { Platform } from "./modules/dbus/platform";
-
-import { QuickPanelOd } from "./modules/quick_toggles/panel_od";
-import { IndicateMiniLed } from "./modules/indicators/mini_led";
-import { QuickMiniLed } from "./modules/quick_toggles/mini_led";
-import { SliderChargeLevel } from "./modules/sliders/charge";
-import { QuickAnimePower } from "./modules/quick_toggles/anime_power";
-import { FeatureMenuToggle } from "./modules/quick_menus/laptop_features";
-import { AuraDbus } from "./modules/dbus/aura";
-import { AuraMenuToggle } from "./modules/quick_menus/aura";
-
-class Extension {
-    private _indicateMiniLed: typeof IndicateMiniLed;
-    private _quickMiniLed: typeof QuickMiniLed;
-    private _quickPanelOd: typeof QuickPanelOd;
-    private _quickAnimePower: typeof QuickAnimePower;
-    private _featureMenuToggle: typeof FeatureMenuToggle;
-    private _auraModeMenuToggle: typeof AuraMenuToggle;
-    private _sliderCharge: typeof SliderChargeLevel;
-
-    public dbus_supported: Supported = new Supported;
-    public dbus_power: Power = new Power;
-    public dbus_aura: AuraDbus = new AuraDbus;
-    public dbus_anime: AnimeDbus = new AnimeDbus;
-    public dbus_platform: Platform = new Platform;
-
-
-    constructor() {
-        this._indicateMiniLed = null;
-        this._quickMiniLed = null;
-        this._quickPanelOd = null;
-        this._quickAnimePower = null;
-        this._sliderCharge = null;
-
-        this.dbus_supported.start();
-        this.dbus_aura.start();
-        this.dbus_platform.start();
-        this.dbus_power.start();
-        this.dbus_anime.start();
-    }
-
-    enable() {
-        if (this._featureMenuToggle == null) {
-            this._featureMenuToggle = new FeatureMenuToggle(this.dbus_supported, this.dbus_platform, this.dbus_anime);
-        }
-        if (this._auraModeMenuToggle == null) {
-            this._auraModeMenuToggle = new AuraMenuToggle(this.dbus_aura);
-        }
-        if (this.dbus_supported.supported.rog_bios_ctrl.mini_led_mode) {
-            // if (this._quickMiniLed == null) {
-            //     this._quickMiniLed = new QuickMiniLed(this.dbus_platform);
-            //     this.dbus_platform.notifyMiniLedSubscribers.push(this._quickMiniLed);
-            // }
-            if (this._indicateMiniLed == null) {
-                this._indicateMiniLed = new IndicateMiniLed(this.dbus_platform);
-            }
-        }
-        // if (this.dbus_supported.supported.rog_bios_ctrl.panel_overdrive) {
-        //     if (this._quickPanelOd == null) {
-        //         this._quickPanelOd = new QuickPanelOd(this.dbus_platform);
-        //         this.dbus_platform.notifyPanelOdSubscribers.push(this._quickPanelOd);
-        //     }
-        // }
-        // if (this.dbus_supported.supported.anime_ctrl) {
-        //     if (this._quickAnimePower == null) {
-        //         this._quickAnimePower = new QuickAnimePower(this._dbus_anime);
-        //     }
-        // }
-        if (this.dbus_supported.supported.charge_ctrl.charge_level_set) {
-            if (this._sliderCharge == null) {
-                this._sliderCharge = new SliderChargeLevel(this.dbus_power);
-            }
-        }
-    }
-
-    disable() {
-        if (this._indicateMiniLed != null) {
-            this._indicateMiniLed.destroy();
-            this._indicateMiniLed = null;
-        }
-        if (this._quickMiniLed != null) {
-            this._quickMiniLed.destroy();
-            this._quickMiniLed = null;
-        }
-        if (this._quickPanelOd != null) {
-            this._quickPanelOd.destroy();
-            this._quickPanelOd = null;
-        }
-        if (this._quickAnimePower != null) {
-            this._quickAnimePower.destroy();
-            this._quickAnimePower = null;
-        }
-        if (this._sliderCharge != null) {
-            this._sliderCharge.destroy();
-            this._sliderCharge = null;
-        }
-
-        this.dbus_power.stop();
-        this.dbus_platform.stop();
-        this.dbus_anime.stop();
-        this.dbus_aura.stop();
-        this.dbus_supported.stop();
-    }
-}
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function init() {
-    return new Extension();
-}

desktop-extensions/gnome-44/src/metadata.json

@@ -1,11 +0,0 @@
-{
-  "name": "asusctl-gnome",
-  "description": "asusctl-gnome a gnome extension exposing some of the base features of asusd in a helpful and easy to use way",
-  "uuid": "asusctl-gnome@asus-linux.org",
-  "uuid-dev": "asusctl-gnome-dev@asus-linux.org",
-  "settings-schema": "org.gnome.shell.extensions.asusctl-gnome",
-  "version": "4.3.2",
-  "shell-version": [
-    "43", "44", "45"
-  ]
-}

desktop-extensions/gnome-44/src/modules/dbus/animatrix.ts

@@ -1,119 +0,0 @@
-import { DbusBase } from "./base";
-import { DeviceState, AnimBooting, Brightness, AnimAwake, AnimSleeping, AnimShutdown } from "../../bindings/anime";
-
-export class AnimeDbus extends DbusBase {
-    deviceState: DeviceState = {
-        display_enabled: false,
-        display_brightness: Brightness.Med,
-        builtin_anims_enabled: false,
-        builtin_anims: {
-            boot: AnimBooting.GlitchConstruction,
-            awake: AnimAwake.BinaryBannerScroll,
-            sleep: AnimSleeping.BannerSwipe,
-            shutdown: AnimShutdown.GlitchOut
-        },
-    };
-
-    // TODO: interface or something to enforce requirement of "sync()" method
-    public notifyAnimeStateSubscribers: any[] = [];
-
-    constructor() {
-        super("org-asuslinux-anime-4", "/org/asuslinux/Anime");
-    }
-
-    public setEnableDisplay(state: boolean | null) {
-        if (this.isRunning()) {
-            try {
-                // if null, toggle the current state
-                state = (state == null ? !this.deviceState.display_enabled : state);
-
-                if (this.deviceState.display_enabled !== state) {
-                    this.deviceState.display_enabled = state;
-                }
-                return this.dbus_proxy.SetEnableDisplaySync(state);
-            } catch (e) {
-                //@ts-ignore
-                log("AniMe DBus set power failed!", e);
-            }
-        }
-    }
-
-    public setPowersaveAnim(state: boolean | null) {
-        if (this.isRunning()) {
-            try {
-                // if null, toggle the current state
-                state = (state == null ? !this.deviceState.builtin_anims_enabled : state);
-
-                if (this.deviceState.builtin_anims_enabled !== state) {
-                    this.deviceState.builtin_anims_enabled = state;
-                }
-                return this.dbus_proxy.SetEnableBuiltinsSync(state);
-            } catch (e) {
-                //@ts-ignore
-                log("AniMe DBus set builtins failed!", e);
-            }
-        }
-    }
-
-    public setBrightness(brightness: Brightness) {
-        if (this.isRunning()) {
-            try {
-                if (this.deviceState.display_brightness !== brightness) {
-                    this.deviceState.display_brightness = brightness;
-                }
-                return this.dbus_proxy.SetBrightnessSync(brightness);
-            } catch (e) {
-                //@ts-ignore
-                log("AniMe DBus set brightness failed!", e);
-            }
-        }
-    }
-
-    _parseData(data: any) {
-        if (data.length > 0) {
-            this.deviceState.display_enabled = data[0];
-            this.deviceState.display_brightness = Brightness[data[1] as Brightness];
-            this.deviceState.builtin_anims_enabled = data[2];
-            this.deviceState.builtin_anims.boot = AnimBooting[data[3][0] as AnimBooting];
-            this.deviceState.builtin_anims.awake = AnimAwake[data[3][1] as AnimAwake];
-            this.deviceState.builtin_anims.sleep = AnimSleeping[data[3][2] as AnimSleeping];
-            this.deviceState.builtin_anims.shutdown = AnimShutdown[data[3][2] as AnimShutdown];
-        }
-    }
-
-    public getDeviceState() {
-        if (this.isRunning()) {
-            try {
-                // janky shit going on with DeviceStateSync
-                this._parseData(this.dbus_proxy.DeviceStateSync());
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to fetch DeviceState!", e);
-            }
-        }
-        return this.deviceState;
-    }
-
-    async start() {
-        await super.start();
-        this.getDeviceState();
-
-        this.dbus_proxy.connectSignal(
-            "NotifyDeviceState",
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            (proxy: any = null, name: string, data: string) => {
-                if (proxy) {
-                    // idiot xml parsing mneans the get is not nested while this is
-                    this._parseData(data[0]);
-                    this.notifyAnimeStateSubscribers.forEach(sub => {
-                        sub.sync();
-                    });
-                }
-            }
-        );
-    }
-
-    async stop() {
-        await super.stop();
-    }
-}

desktop-extensions/gnome-44/src/modules/dbus/aura.ts

@@ -1,284 +0,0 @@
-import { AuraDevRog1, AuraDevTuf, AuraDevice, AuraEffect, AuraModeNum, AuraPower, AuraPowerDev, AuraZone, Direction, PowerZones, Speed } from "../../bindings/aura";
-import { DbusBase } from "./base";
-
-export class AuraDbus extends DbusBase {
-    public device: AuraDevice = AuraDevice.Unknown;
-    public current_aura_mode: AuraModeNum = AuraModeNum.Static;
-    public aura_modes: Map<AuraModeNum, AuraEffect> = new Map;
-    public leds_powered: AuraPowerDev = {
-        tuf: [],
-        old_rog: [],
-        rog: {
-            keyboard: {
-                zone: PowerZones.Keyboard,
-                boot: false,
-                awake: false,
-                sleep: false,
-                shutdown: false
-            },
-            logo: {
-                zone: PowerZones.Logo,
-                boot: false,
-                awake: false,
-                sleep: false,
-                shutdown: false
-            },
-            lightbar: {
-                zone: PowerZones.Lightbar,
-                boot: false,
-                awake: false,
-                sleep: false,
-                shutdown: false
-            },
-            lid: {
-                zone: PowerZones.Lid,
-                boot: false,
-                awake: false,
-                sleep: false,
-                shutdown: false
-            },
-            rear_glow: {
-                zone: PowerZones.RearGlow,
-                boot: false,
-                awake: false,
-                sleep: false,
-                shutdown: false
-            },
-        }
-    };
-    // TODO: interface or something to enforce requirement of "sync()" method
-    public notifyAuraModeSubscribers: any[] = [];
-    public notifyAuraPowerSubscribers: any[] = [];
-
-    constructor() {
-        super("org-asuslinux-aura-4", "/org/asuslinux/Aura");
-    }
-
-    public getDevice() {
-        if (this.isRunning()) {
-            try {
-                this.device = AuraDevice[this.dbus_proxy.DeviceTypeSync() as AuraDevice];
-                //@ts-ignore
-                log("LED device: " + this.device);
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to fetch supported functionalities", e);
-            }
-        }
-    }
-
-    _parsePowerStates(data: any[]) {
-        const power: AuraPowerDev = this.leds_powered;
-
-        power.tuf = data[0].map((value: string) => {
-            return AuraDevTuf[value as AuraDevTuf];
-        });
-        power.old_rog = data[1].map((value: string) => {
-            return AuraDevRog1[value as AuraDevRog1];
-        });
-        power.rog = {
-            keyboard: {
-                zone: PowerZones[data[2][0][0] as PowerZones],
-                boot: data[2][0][1],
-                awake: data[2][0][2],
-                sleep: data[2][0][3],
-                shutdown: data[2][0][4]
-            },
-            logo: {
-                zone: PowerZones[data[2][1][0] as PowerZones],
-                boot: data[2][1][1],
-                awake: data[2][1][2],
-                sleep: data[2][1][3],
-                shutdown: data[2][1][4]
-            },
-            lightbar: {
-                zone: PowerZones[data[2][2][0] as PowerZones],
-                boot: data[2][2][1],
-                awake: data[2][2][2],
-                sleep: data[2][2][3],
-                shutdown: data[2][2][4]
-            },
-            lid: {
-                zone: PowerZones[data[2][3][0] as PowerZones],
-                boot: data[2][3][1],
-                awake: data[2][3][2],
-                sleep: data[2][3][3],
-                shutdown: data[2][3][4]
-            },
-            rear_glow: {
-                zone: PowerZones[data[2][4][0] as PowerZones],
-                boot: data[2][4][1],
-                awake: data[2][4][2],
-                sleep: data[2][4][3],
-                shutdown: data[2][4][4]
-            }
-        };
-
-        return power;
-    }
-
-    public getLedPower() {
-        if (this.isRunning()) {
-            try {
-                const data = this.dbus_proxy.LedPowerSync();
-                this.leds_powered = this._parsePowerStates(data);
-                //@ts-ignore
-                log("LED power tuf: " + this.leds_powered.tuf);
-                //@ts-ignore
-                log("LED power x1866: " + this.leds_powered.old_rog);
-                //@ts-ignore
-                log("LED power x19b6: " + this.leds_powered.rog);
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to fetch supported functionalities", e);
-            }
-        }
-    }
-
-    public getLedMode() {
-        if (this.isRunning()) {
-            try {
-                this.current_aura_mode = AuraModeNum[this.dbus_proxy.LedModeSync() as AuraModeNum];
-                //@ts-ignore
-                log("Current LED mode:", this.current_aura_mode);
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to fetch supported functionalities", e);
-            }
-        }
-    }
-
-    public setLedMode(mode: AuraEffect) {
-        if (this.isRunning()) {
-            try {
-                this.dbus_proxy.SetLedModeSync([
-                    mode.mode,
-                    mode.zone,
-                    [mode.colour1.r, mode.colour1.g, mode.colour1.b],
-                    [mode.colour2.r, mode.colour2.g, mode.colour2.b],
-                    mode.speed,
-                    mode.direction]);
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to fetch supported functionalities", e);
-            }
-        }
-    }
-
-    _parseAuraEffect(data: any[]) {
-        const aura: AuraEffect = {
-            mode: AuraModeNum[data[0] as AuraModeNum],
-            zone: AuraZone[data[1] as AuraZone],
-            colour1: {
-                r: parseInt(data[2][0]),
-                g: parseInt(data[2][1]),
-                b: parseInt(data[2][2]),
-            },
-            colour2: {
-                r: parseInt(data[3][0]),
-                g: parseInt(data[3][1]),
-                b: parseInt(data[3][2]),
-            },
-            speed: Speed[data[4] as Speed],
-            direction: Direction[data[5] as Direction],
-        };
-        return aura;
-    }
-
-    // Return a list of the available modes, and the current settings for each
-    public getLedModes() {
-        // {'Breathe': ('Breathe', 'None', (166, 0, 0), (0, 0, 0), 'Med', 'Right'),
-        // 'Comet': ('Comet', 'None', (166, 0, 0), (0, 0, 0), 'Med', 'Right'),
-        // 'Static': ('Static', 'None', (78, 0, 0), (0, 0, 0), 'Med', 'Right'),
-        // 'Strobe': ('Strobe', 'None', (166, 0, 0), (0, 0, 0), 'Med', 'Right')}
-        if (this.isRunning()) {
-            try {
-                const _data = this.dbus_proxy.LedModesSync();
-                for (const key in _data[0]) {
-                    const data = _data[0][key];
-                    const aura: AuraEffect = this._parseAuraEffect(data);
-                    this.aura_modes.set(AuraModeNum[key as AuraModeNum], aura);
-                }
-
-                for (const [key, value] of this.aura_modes) {
-                    //@ts-ignore
-                    log(key, value.zone, value.colour1.r, value.speed, value.direction);
-                }
-
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to fetch supported functionalities", e);
-            }
-        }
-    }
-
-    async start() {
-        try {
-            await super.start();
-            this.getDevice();
-            this.getLedPower();
-            this.getLedMode();
-            this.getLedModes();
-
-            //@ts-ignore
-            log("Current LED mode data:", this.aura_modes.get(this.current_aura_mode)?.speed);
-
-            this.dbus_proxy.connectSignal(
-                "NotifyLed",
-                (proxy: any = null, name: string, data: any) => {
-                    if (proxy) {
-                        const aura: AuraEffect = this._parseAuraEffect(data[0]);
-                        this.current_aura_mode = aura.mode;
-                        this.aura_modes.set(aura.mode, aura);
-                        //@ts-ignore
-                        log("LED data has changed to ", aura.mode, aura.zone, aura.colour1.r, aura.speed, aura.direction);
-                        this.notifyAuraModeSubscribers.forEach(sub => {
-                            sub.sync();
-                        });
-                    }
-                }
-            );
-
-            this.dbus_proxy.connectSignal(
-                "NotifyPowerStates",
-                (proxy: any = null, name: string, data: any) => {
-                    if (proxy) {
-                        const power: AuraPowerDev = this._parsePowerStates(data[0]);
-                        this.leds_powered = power;
-                        switch (this.device) {
-                            case AuraDevice.Tuf:
-                                //@ts-ignore
-                                log("LED power has changed to ", this.leds_powered.tuf);
-                                break;
-                            case AuraDevice.X1854:
-                            case AuraDevice.X1869:
-                            case AuraDevice.X18c6:
-                                //@ts-ignore
-                                log("LED power has changed to ", this.leds_powered.old_rog);
-                                break;
-                            case AuraDevice.X19b6:
-                            case AuraDevice.X1a30:
-                                //@ts-ignore
-                                log("LED power has changed to ", this.leds_powered.rog);
-                                break;
-                            default:
-                                break;
-                        }
-                        //@ts-ignore
-                        log("LED power has changed to ", this.leds_powered.rog);
-                        this.notifyAuraPowerSubscribers.forEach(sub => {
-                            sub.sync();
-                        });
-                    }
-                }
-            );
-        } catch (e) {
-            //@ts-ignore
-            log("Supported DBus initialization failed!", e);
-        }
-    }
-
-    async stop() {
-        await super.stop();
-    }
-}

desktop-extensions/gnome-44/src/modules/dbus/base.ts

@@ -1,52 +0,0 @@
-declare const imports: any;
-
-import * as Resources from "../resources";
-
-const { Gio } = imports.gi;
-
-export class DbusBase {
-    dbus_proxy: any = null; // type: Gio.DbusProxy
-    connected = false;
-    xml_resource = "";
-    dbus_path = "";
-
-    constructor(resource: string, dbus_path: string) {
-        this.xml_resource = resource;
-        this.dbus_path = dbus_path;
-    }
-
-    async start() {
-        //@ts-ignore
-        log(`Starting ${this.dbus_path} dbus module`);
-        try {
-            const xml = Resources.File.DBus(this.xml_resource);
-            this.dbus_proxy = new Gio.DBusProxy.makeProxyWrapper(xml)(
-                Gio.DBus.system,
-                "org.asuslinux.Daemon",
-                this.dbus_path,
-            );
-
-            this.connected = true;
-            //@ts-ignore
-            log(`${this.dbus_path} client started successfully.`);
-        } catch (e) {
-            //@ts-ignore
-            logError(`${this.xml_resource} dbus init failed!`, e);
-        }
-    }
-
-    async stop() {
-        //@ts-ignore
-        log(`Stopping ${this.xml_resource} dbus module`);
-
-        if (this.connected) {
-            this.dbus_proxy.destroy();
-            this.connected = false;
-            this.dbus_proxy = null;
-        }
-    }
-
-    isRunning(): boolean {
-        return this.connected;
-    }
-}

desktop-extensions/gnome-44/src/modules/dbus/platform.ts

@@ -1,202 +0,0 @@
-import * as bios from "../../bindings/platform";
-import { DbusBase } from "./base";
-
-// TODO: add callbacks for notifications
-export class Platform extends DbusBase {
-    bios: bios.RogBiosSupportedFunctions = {
-        post_sound: false,
-        gpu_mux: false,
-        panel_overdrive: false,
-        dgpu_disable: false,
-        egpu_enable: false,
-        mini_led_mode: false
-    };
-
-    // TODO: interface or something to enforce requirement of "sync()" method
-    public notifyPanelOdSubscribers: any[] = [];
-    public notifyPostBootSoundSubscribers: any[] = [];
-    public notifyMiniLedSubscribers: any[] = [];
-    public notifyGpuMuxSubscribers: any[] = [];
-
-    constructor() {
-        super("org-asuslinux-platform-4", "/org/asuslinux/Platform");
-    }
-
-    public getPostBootSound() {
-        if (this.isRunning()) {
-            try {
-                this.bios.post_sound = this.dbus_proxy.PostBootSoundSync() == "true" ? true : false;
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to get POST Boot Sound state!", e);
-            }
-        }
-        return this.bios.post_sound;
-    }
-
-    public setPostBootSound(state: boolean) {
-        if (this.isRunning()) {
-            try {
-                if (state !== this.bios.post_sound) {
-                    this.bios.post_sound = state;
-                }
-                return this.dbus_proxy.SetPostBootSoundSync(state);
-            } catch (e) {
-                //@ts-ignore
-                log("Platform DBus set Post Boot Sound failed!", e);
-            }
-        }
-    }
-
-    public getGpuMuxMode() {
-        if (this.isRunning()) {
-            try {
-                this.bios.gpu_mux = this.dbus_proxy.GpuMuxModeSync() == "true" ? true : false;
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to get MUX state!", e);
-            }
-        }
-        return this.bios.gpu_mux;
-    }
-
-    public setGpuMuxMode(state: boolean) {
-        if (this.isRunning()) {
-            try {
-                if (!state !== this.bios.gpu_mux) {
-                    this.bios.gpu_mux = !state;
-                }
-                return this.dbus_proxy.SetGpuMuxModeSync(!state);
-            } catch (e) {
-                //@ts-ignore
-                log("Switching the MUX failed!", e);
-            }
-        }
-    }
-
-    public getPanelOd() {
-        if (this.isRunning()) {
-            try {
-                this.bios.panel_overdrive = this.dbus_proxy.PanelOdSync() == "true" ? true : false;
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to get Overdrive state!", e);
-            }
-        }
-        return this.bios.panel_overdrive;
-    }
-
-    public setPanelOd(state: boolean) {
-        if (this.isRunning()) {
-            try {
-                if (state !== this.bios.panel_overdrive) {
-                    this.bios.panel_overdrive = state;
-                }
-                return this.dbus_proxy.SetPanelOdSync(state);
-            } catch (e) {
-                //@ts-ignore
-                log("Overdrive DBus set overdrive state failed!", e);
-            }
-        }
-    }
-
-    public getMiniLedMode() {
-        if (this.isRunning()) {
-            try {
-                this.bios.mini_led_mode = this.dbus_proxy.MiniLedModeSync() == "true" ? true : false;
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to get Overdrive state!", e);
-            }
-        }
-        return this.bios.mini_led_mode;
-    }
-
-    public setMiniLedMode(state: boolean) {
-        if (this.isRunning()) {
-            try {
-                if (state !== this.bios.mini_led_mode) {
-                    this.bios.mini_led_mode = state;
-                }
-                return this.dbus_proxy.SetMiniLedModeSync(state);
-            } catch (e) {
-                //@ts-ignore
-                log("setMiniLedMode failed!", e);
-            }
-        }
-    }
-
-    async start() {
-        try {
-            await super.start();
-
-            this.getPostBootSound();
-            this.dbus_proxy.connectSignal(
-                "NotifyPostBootSound",
-                (proxy: any = null, _name: string, data: boolean) => {
-                    if (proxy) {
-                        //@ts-ignore
-                        log(`PostBootSound changed to ${data}`);
-                        this.notifyPostBootSoundSubscribers.forEach(sub => {
-                            sub.sync();
-                        });
-                    }
-                }
-            );
-
-            this.getPanelOd();
-            this.dbus_proxy.connectSignal(
-                "NotifyPanelOd",
-                (proxy: any = null, _name: string, data: boolean) => {
-                    if (proxy) {
-                        //@ts-ignore
-                        log(`NotifyPanelOd has changed to ${data}.`);
-                        this.notifyPanelOdSubscribers.forEach(sub => {
-                            sub.sync();
-                        });
-                    }
-                }
-            );
-
-            this.getMiniLedMode();
-            this.dbus_proxy.connectSignal(
-                "NotifyMiniLedMode",
-                (proxy: any = null, _name: string, data: boolean) => {
-                    if (proxy) {
-                        //@ts-ignore
-                        log(`MiniLedMode has changed to ${data}.`);
-                        this.notifyMiniLedSubscribers.forEach(sub => {
-                            sub.sync();
-                        });
-                    }
-                }
-            );
-
-            this.getGpuMuxMode();
-            this.dbus_proxy.connectSignal(
-                "NotifyGpuMuxMode",
-                (proxy: any = null, _name: string, data: boolean) => {
-                    if (proxy) {
-                        //@ts-ignore
-                        log(`MUX has changed to ${data}.`);
-                        this.notifyGpuMuxSubscribers.forEach(sub => {
-                            sub.sync();
-                        });
-                    }
-                }
-            );
-
-        } catch (e) {
-            //@ts-ignore
-            log("Platform DBus init failed!", e);
-        }
-    }
-
-    async stop() {
-        await super.stop();
-        this.bios.post_sound = false;
-        this.bios.panel_overdrive = false;
-        this.bios.mini_led_mode = false;
-        this.bios.gpu_mux = false;
-    }
-}

desktop-extensions/gnome-44/src/modules/dbus/power.ts

@@ -1,99 +0,0 @@
-import { DbusBase } from "./base";
-
-// function getMethods(obj: { [x: string]: { toString: () => string; }; }) {
-//     var result = [];
-//     for (var id in obj) {
-//       try {
-//         if (typeof(obj[id]) == "function") {
-//           result.push(id + ": " + obj[id].toString());
-//         }
-//       } catch (err) {
-//         result.push(id + ": inaccessible");
-//       }
-//     }
-//     return result;
-//   }
-
-export class Power extends DbusBase {
-    chargeLimit = 100;
-    mainsOnline = false;
-
-    constructor() {
-        super("org-asuslinux-power-4", "/org/asuslinux/Power");
-    }
-
-    public getChargingLimit() {
-        if (this.isRunning()) {
-            try {
-                this.chargeLimit = this.dbus_proxy.ChargeControlEndThresholdSync();
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to fetch Charging Limit!", e);
-            }
-        }
-        return this.chargeLimit;
-    }
-
-    public setChargingLimit(limit: number) {
-        if (this.isRunning()) {
-            try {
-                if (limit > 0 && this.chargeLimit !== limit) {
-                    // update state
-                    this.chargeLimit = limit;
-                }
-                return this.dbus_proxy.SetChargeControlEndThresholdSync(limit);
-            } catch (e) {
-                //@ts-ignore
-                log("Profile DBus set power profile failed!", e);
-            }
-        }
-    }
-
-    public getMainsOnline() {
-        if (this.isRunning()) {
-            try {
-                this.mainsOnline = this.dbus_proxy.MainsOnlineSync();
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to fetch MainsLonline!", e);
-            }
-        }
-        return this.mainsOnline;
-    }
-
-    async start() {
-        try {
-            await super.start();
-            this.getChargingLimit();
-
-            this.dbus_proxy.connectSignal(
-                "NotifyChargeControlEndThreshold",
-                (proxy: any = null, name: string, data: string) => {
-                    if (proxy) {
-                        //@ts-ignore
-                        log(`Charging Limit has changed to ${data}% (${name}).`);
-                        this.chargeLimit = parseInt(data);
-                    }
-                }
-            );
-
-            this.dbus_proxy.connectSignal(
-                "NotifyMainsOnline",
-                (proxy: any = null, name: string, data: string) => {
-                    if (proxy) {
-                        //@ts-ignore
-                        log(`NotifyMainsOnline has changed to ${data}% (${name}).`);
-                        this.mainsOnline = parseInt(data) == 1 ? true : false;
-                    }
-                }
-            );
-        } catch (e) {
-            //@ts-ignore
-            log("Charging Limit DBus initialization failed!", e);
-        }
-    }
-
-    async stop() {
-        await super.stop();
-    }
-}

desktop-extensions/gnome-44/src/modules/dbus/supported.ts

@@ -1,106 +0,0 @@
-import { SupportedFunctions, AdvancedAura } from "../../bindings/platform";
-import { AuraDevice, AuraModeNum, AuraZone, PowerZones } from "../../bindings/aura";
-import { DbusBase } from "./base";
-
-export class Supported extends DbusBase {
-    // False,
-    // (True,),
-    // (True, True),
-    //   ('X19b6',
-    //   True,
-    //   ['Static',
-    //   'Breathe',
-    //   'Strobe',
-    //   'Rainbow',
-    //   'Star',
-    //   'Rain',
-    //   'Highlight',
-    //   'Laser',
-    //   'Ripple',
-    //   'Pulse',
-    //   'Comet',
-    //   'Flash'],
-    //   [],
-    //   'PerKey',
-    //   ['Keyboard', 'Lightbar', 'Logo', 'RearGlow']),
-    // (False, True, True, True, False, True)
-
-    supported: SupportedFunctions = {
-        anime_ctrl: false,
-        charge_ctrl: {
-            charge_level_set: false
-        },
-        platform_profile: {
-            platform_profile: false,
-            fan_curves: false
-        },
-        keyboard_led: {
-            dev_id: AuraDevice.Unknown,
-            brightness: false,
-            basic_modes: [],
-            basic_zones: [],
-            advanced_type: AdvancedAura.None
-        },
-        rog_bios_ctrl: {
-            post_sound: false,
-            gpu_mux: false,
-            panel_overdrive: false,
-            dgpu_disable: false,
-            egpu_enable: false,
-            mini_led_mode: false
-        }
-    };
-
-    constructor() {
-        super("org-asuslinux-supported-4", "/org/asuslinux/Supported");
-    }
-
-    public getSupported() {
-        if (this.isRunning()) {
-            try {
-                const _data = this.dbus_proxy.SupportedFunctionsSync();
-                this.supported.anime_ctrl = _data[0];
-                this.supported.charge_ctrl.charge_level_set = _data[1];
-                this.supported.platform_profile.platform_profile = _data[2][0];
-                this.supported.platform_profile.fan_curves = _data[2][1];
-                this.supported.keyboard_led.dev_id = AuraDevice[_data[3][0] as AuraDevice];
-                this.supported.keyboard_led.brightness = _data[3][1];
-
-                this.supported.keyboard_led.basic_modes = _data[3][2].map(function (value: string) {
-                    return AuraModeNum[value as AuraModeNum];
-                });
-                this.supported.keyboard_led.basic_zones = _data[3][3].map(function (value: string) {
-                    return AuraZone[value as AuraZone];
-                });
-                this.supported.keyboard_led.advanced_type = AdvancedAura[_data[3][4] as AdvancedAura];
-                this.supported.keyboard_led.power_zones = _data[3][5].map(function (value: string) {
-                    return PowerZones[value as PowerZones];
-                });
-
-                this.supported.rog_bios_ctrl.post_sound = _data[4][0];
-                this.supported.rog_bios_ctrl.gpu_mux = _data[4][1];
-                this.supported.rog_bios_ctrl.panel_overdrive = _data[4][2];
-                this.supported.rog_bios_ctrl.dgpu_disable = _data[4][3];
-                this.supported.rog_bios_ctrl.egpu_enable = _data[4][4];
-                this.supported.rog_bios_ctrl.mini_led_mode = _data[4][5];
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to fetch supported functionalities", e);
-            }
-        }
-    }
-
-    async start() {
-        try {
-            await super.start();
-            this.getSupported();
-        } catch (e) {
-            //@ts-ignore
-            log("Supported DBus initialization failed!", e);
-        }
-    }
-
-    async stop() {
-        await super.stop();
-    }
-}

desktop-extensions/gnome-44/src/modules/helpers.ts

@@ -1,15 +0,0 @@
-declare const imports: any;
-
-const { QuickToggle } = imports.ui.quickSettings;
-const QuickSettingsMenu = imports.ui.main.panel.statusArea.quickSettings;
-
-export function addQuickSettingsItems(items: [typeof QuickToggle], width = 1) {
-    // Add the items with the built-in function
-    QuickSettingsMenu._addItems(items, width);
-
-    // Ensure the tile(s) are above the background apps menu
-    for (const item of items) {
-        QuickSettingsMenu.menu._grid.set_child_below_sibling(item,
-            QuickSettingsMenu._backgroundApps.quickSettingsItems[0]);
-    }
-}

desktop-extensions/gnome-44/src/modules/indicators/mini_led.ts

@@ -1,28 +0,0 @@
-declare const imports: any;
-// REF: https://gjs.guide/extensions/development/creating.html
-
-const { GObject, Gio } = imports.gi;
-const ExtensionUtils = imports.misc.extensionUtils;
-
-const { SystemIndicator } = imports.ui.quickSettings;
-const QuickSettingsMenu = imports.ui.main.panel.statusArea.quickSettings;
-
-export const IndicateMiniLed = GObject.registerClass(
-    class IndicateMiniLed extends SystemIndicator {
-        constructor() {
-            super();
-
-            // Create the icon for the indicator
-            this._indicator = this._addIndicator();
-            this._indicator.icon_name = "selection-mode-symbolic";
-
-            // Showing the indicator when the feature is enabled
-            this._settings = ExtensionUtils.getSettings();
-            this._settings.bind("mini-led-enabled",
-                this._indicator, "visible",
-                Gio.SettingsBindFlags.DEFAULT);
-
-            // Add the indicator to the panel and the toggle to the menu
-            QuickSettingsMenu._indicators.add_child(this);
-        }
-    });

desktop-extensions/gnome-44/src/modules/menu_toggles/anime.ts

@@ -1,86 +0,0 @@
-declare const imports: any;
-
-import { AnimeDbus } from "../dbus/animatrix";
-
-const { GObject } = imports.gi;
-const ExtensionUtils = imports.misc.extensionUtils;
-const PopupMenu = imports.ui.popupMenu;
-
-export const MenuToggleAnimePower = GObject.registerClass(
-    class MenuToggleAnimePower extends PopupMenu.PopupSwitchMenuItem {
-        private _dbus_anime: AnimeDbus;
-        public toggle_callback = () => {};
-
-        constructor(dbus_anime: AnimeDbus) {
-            super(
-                "AniMatrix Display Power", dbus_anime.deviceState.display_enabled
-            );
-            this._dbus_anime = dbus_anime;
-            this.label = "AniMatrix Display Power";
-            this._settings = ExtensionUtils.getSettings();
-
-            this.connectObject(
-                "destroy", () => this._settings.run_dispose(),
-                "toggled", () => this._toggleMode(),
-                this);
-
-            this.connect("destroy", () => {
-                this.destroy();
-            });
-
-            this.sync();
-        }
-
-        _toggleMode() {
-            this._dbus_anime.getDeviceState();
-            if (this.state !== this._dbus_anime.deviceState.display_enabled)
-                this._dbus_anime.setEnableDisplay(this.state);
-            this.toggle_callback();
-        }
-
-        sync() {
-            this._dbus_anime.getDeviceState();
-            const checked = this._dbus_anime.deviceState.display_enabled;
-            this.setToggleState(checked);
-        }
-    });
-
-
-export const MenuToggleAnimeBuiltins = GObject.registerClass(
-    class MenuToggleAnimeBuiltins extends PopupMenu.PopupSwitchMenuItem {
-        private _dbus_anime: AnimeDbus;
-        public toggle_callback = () => {};
-
-        constructor(dbus_anime: AnimeDbus) {
-            super(
-                "AniMatrix Powersave Animation", dbus_anime.deviceState.builtin_anims_enabled
-            );
-            this._dbus_anime = dbus_anime;
-            this.label = "AniMatrix Powersave Animation";
-            this._settings = ExtensionUtils.getSettings();
-
-            this.connectObject(
-                "destroy", () => this._settings.run_dispose(),
-                "toggled", () => this._toggleMode(),
-                this);
-
-            this.connect("destroy", () => {
-                this.destroy();
-            });
-
-            this.sync();
-        }
-
-        _toggleMode() {
-            this._dbus_anime.getDeviceState();
-            if (this.state !== this._dbus_anime.deviceState.builtin_anims_enabled)
-                this._dbus_anime.setPowersaveAnim(this.state);
-            this.toggle_callback();
-        }
-
-        sync() {
-            this._dbus_anime.getDeviceState();
-            const checked = this._dbus_anime.deviceState.display_enabled;
-            this.setToggleState(checked);
-        }
-    });

desktop-extensions/gnome-44/src/modules/menu_toggles/mini_led.ts

@@ -1,46 +0,0 @@
-declare const imports: any;
-
-import { Platform } from "../dbus/platform";
-
-const { GObject, Gio } = imports.gi;
-const ExtensionUtils = imports.misc.extensionUtils;
-const PopupMenu = imports.ui.popupMenu;
-
-export const MenuToggleMiniLed = GObject.registerClass(
-    class MenuToggleMiniLed extends PopupMenu.PopupSwitchMenuItem {
-        private _dbus_platform: Platform;
-        public toggle_callback = () => {};
-
-        constructor(dbus_platform: Platform) {
-            super("MiniLED", dbus_platform.bios.mini_led_mode);
-
-            this._dbus_platform = dbus_platform;
-            this.label = "MiniLED";
-            this._settings = ExtensionUtils.getSettings();
-
-            this.connectObject(
-                "destroy", () => this._settings.run_dispose(),
-                "toggled", () => this._toggleMode(),
-                this);
-
-            this.connect("destroy", () => {
-                this.destroy();
-            });
-
-            this.sync();
-        }
-
-        _toggleMode() {
-            this._dbus_platform.getMiniLedMode();
-            const state = this._dbus_platform.bios.mini_led_mode;
-            if (this.state !== state)
-                this._dbus_platform.setMiniLedMode(this.state);
-            this.toggle_callback();
-        }
-
-        sync() {
-            this._dbus_platform.getMiniLedMode();
-            const toggled = this._dbus_platform.bios.mini_led_mode;
-            this.setToggleState(toggled);
-        }
-    });

desktop-extensions/gnome-44/src/modules/menu_toggles/panel_od.ts

@@ -1,46 +0,0 @@
-declare const imports: any;
-
-import { Platform } from "../dbus/platform";
-
-const { GObject, Gio } = imports.gi;
-const ExtensionUtils = imports.misc.extensionUtils;
-const PopupMenu = imports.ui.popupMenu;
-
-export const MenuTogglePanelOd = GObject.registerClass(
-    class MenuTogglePanelOd extends PopupMenu.PopupSwitchMenuItem {
-        private _dbus_platform: Platform;
-        public toggle_callback = () => {};
-
-        constructor(dbus_platform: Platform) {
-            super("Panel Overdrive", dbus_platform.bios.panel_overdrive);
-
-            this._dbus_platform = dbus_platform;
-            this.label = "Panel Overdrive";
-            this._settings = ExtensionUtils.getSettings();
-
-            this.connectObject(
-                "destroy", () => this._settings.run_dispose(),
-                "toggled", () => this._toggleMode(),
-                this);
-
-            this.connect("destroy", () => {
-                this.destroy();
-            });
-
-            this.sync();
-        }
-
-        _toggleMode() {
-            this._dbus_platform.getPanelOd();
-            const state = this._dbus_platform.bios.panel_overdrive;
-            if (this.state !== state)
-                this._dbus_platform.setPanelOd(this.state);
-            this.toggle_callback();
-        }
-
-        sync() {
-            this._dbus_platform.getPanelOd();
-            const toggled = this._dbus_platform.bios.panel_overdrive;
-            this.setToggleState(toggled);
-        }
-    });

desktop-extensions/gnome-44/src/modules/quick_menus/aura.ts

@@ -1,86 +0,0 @@
-declare const imports: any;
-// REF: https://gjs.guide/extensions/development/creating.html
-
-import { addQuickSettingsItems } from "../helpers";
-import { AuraDbus } from "../dbus/aura";
-import { AuraEffect, AuraModeNum } from "../../bindings/aura";
-
-const { GObject } = imports.gi;
-const ExtensionUtils = imports.misc.extensionUtils;
-// const Me = ExtensionUtils.getCurrentExtension();
-// const Main = imports.ui.main;
-const PopupMenu = imports.ui.popupMenu;
-const QuickSettings = imports.ui.quickSettings;
-
-export const AuraMenuToggle = GObject.registerClass(
-    class AuraMenuToggle extends QuickSettings.QuickMenuToggle {
-        private _dbus_aura: AuraDbus;
-        private _last_mode: AuraModeNum = AuraModeNum.Static;
-
-        constructor(dbus_aura: AuraDbus) {
-            super({
-                title: "Aura Modes",
-                iconName: "selection-mode-symbolic",
-                toggleMode: true,
-            });
-            this._dbus_aura = dbus_aura;
-
-            this.connectObject(
-                "destroy", () => this._settings.run_dispose(),
-                this);
-
-            this.menu.setHeader("selection-mode-symbolic", this._dbus_aura.current_aura_mode);
-
-            this._settings = ExtensionUtils.getSettings();
-
-            this._itemsSection = new PopupMenu.PopupMenuSection();
-
-            this._dbus_aura.aura_modes.forEach((mode, key) => {
-                this._itemsSection.addAction(key, () => {
-                    this._dbus_aura.setLedMode(mode);
-                    this.sync();
-                }, "");
-            });
-
-            this.menu.addMenuItem(this._itemsSection);
-
-            // Add an entry-point for more settings
-            // this.menu.addMenuItem(new PopupMenu.PopupSeparatorMenuItem());
-            // const settingsItem = this.menu.addAction("More Settings",
-            //     () => ExtensionUtils.openPrefs());
-            // // Ensure the settings are unavailable when the screen is locked
-            // settingsItem.visible = Main.sessionMode.allowSettings;
-            // this.menu._settingsActions[Me.uuid] = settingsItem;
-
-            this.connectObject(
-                "clicked", () => {
-                    let mode: AuraEffect | undefined;
-                    if (this._dbus_aura.current_aura_mode == AuraModeNum.Static) {
-                        mode = this._dbus_aura.aura_modes.get(this._last_mode);
-                    } else {
-                        mode = this._dbus_aura.aura_modes.get(AuraModeNum.Static);
-                    }
-                    if (mode != undefined) {
-                        this._dbus_aura.setLedMode(mode);
-                        this.sync();
-                    }
-                },
-                this);
-
-            this._dbus_aura.notifyAuraModeSubscribers.push(this);
-            this.sync();
-
-            addQuickSettingsItems([this]);
-        }
-
-        sync() {
-            const checked = this._dbus_aura.current_aura_mode != AuraModeNum.Static;
-            this.title = this._dbus_aura.current_aura_mode;
-            if (this._last_mode != this._dbus_aura.current_aura_mode && this._dbus_aura.current_aura_mode != AuraModeNum.Static) {
-                this._last_mode = this._dbus_aura.current_aura_mode;
-            }
-
-            if (this.checked !== checked)
-                this.set({ checked });
-        }
-    });

desktop-extensions/gnome-44/src/modules/quick_menus/laptop_features.ts

@@ -1,179 +0,0 @@
-declare const imports: any;
-// REF: https://gjs.guide/extensions/development/creating.html
-
-import { AnimeDbus } from "../dbus/animatrix";
-import { Supported } from "../dbus/supported";
-import { Platform } from "../dbus/platform";
-
-import { addQuickSettingsItems } from "../helpers";
-import { MenuToggleAnimeBuiltins, MenuToggleAnimePower } from "../menu_toggles/anime";
-import { MenuTogglePanelOd } from "../menu_toggles/panel_od";
-import { MenuToggleMiniLed } from "../menu_toggles/mini_led";
-
-
-const { GObject } = imports.gi;
-
-const ExtensionUtils = imports.misc.extensionUtils;
-// const Me = ExtensionUtils.getCurrentExtension();
-// const Main = imports.ui.main;
-const PopupMenu = imports.ui.popupMenu;
-const QuickSettings = imports.ui.quickSettings;
-
-export const FeatureMenuToggle = GObject.registerClass(
-    class FeatureMenuToggle extends QuickSettings.QuickMenuToggle {
-        private _dbus_supported: Supported;
-        private _dbus_platform: Platform;
-        private _dbus_anime: AnimeDbus;
-
-        public miniLed: typeof MenuToggleMiniLed;
-        public panelOd: typeof MenuTogglePanelOd;
-        public animeDisplayPower: typeof MenuToggleAnimePower;
-        public animePowersaveAnim: typeof MenuToggleAnimeBuiltins;
-        private primary = "mini-led";
-
-        constructor(dbus_supported: Supported, dbus_platform: Platform, dbus_anime: AnimeDbus) {
-            super({
-                title: "Laptop",
-                iconName: "selection-mode-symbolic",
-                toggleMode: true,
-            });
-            this._dbus_supported = dbus_supported;
-            this._dbus_platform = dbus_platform;
-            this._dbus_anime = dbus_anime;
-
-            this.menu.setHeader("selection-mode-symbolic", "Laptop features");
-
-            this._settings = ExtensionUtils.getSettings();
-            this.primary = this._settings.get_string("primary-quickmenu-toggle");
-
-            // TODO: temporary block
-            if (this.primary == "mini-led" && !this._dbus_supported.supported.rog_bios_ctrl.mini_led_mode) {
-                this.primary = "panel-od";
-            } else if (this.primary == "panel-od" && !this._dbus_supported.supported.rog_bios_ctrl.panel_overdrive) {
-                this.primary = "anime-power";
-            } else if (this.primary == "anime-power" && !this._dbus_supported.supported.anime_ctrl) {
-                this.primary = "mini-led";
-            } else if (this.primary.length == 0) {
-                this.primary = "panel-od";
-            }
-
-            this.connectObject(
-                "destroy", () => this._settings.run_dispose(),
-                this);
-            this._settings.connect('changed::primary-quickmenu-toggle',
-                this.sync);
-            this._settings.set_string("primary-quickmenu-toggle", this.primary);
-
-            this._itemsSection = new PopupMenu.PopupMenuSection();
-            if (this._dbus_supported.supported.rog_bios_ctrl.mini_led_mode) {
-                if (this.miniLed == null) {
-                    this.miniLed = new MenuToggleMiniLed(this._dbus_platform);
-                    this._dbus_platform.notifyMiniLedSubscribers.push(this.miniLed);
-                    this._itemsSection.addMenuItem(this.miniLed);
-                    this._dbus_platform.notifyMiniLedSubscribers.push(this);
-                    this.miniLed.toggle_callback = () => {
-                        this.primary = "mini-led";
-                        this.sync();
-                    }
-                }
-            }
-
-            if (this._dbus_supported.supported.rog_bios_ctrl.panel_overdrive) {
-                if (this.panelOd == null) {
-                    this.panelOd = new MenuTogglePanelOd(this._dbus_platform);
-                    this._dbus_platform.notifyPanelOdSubscribers.push(this.panelOd);
-                    this._itemsSection.addMenuItem(this.panelOd);
-                    this._dbus_platform.notifyPanelOdSubscribers.push(this);
-                    this.panelOd.toggle_callback = () => {
-                        this.primary = "panel-od";
-                        this.sync();
-                    }
-                }
-            }
-
-            if (this._dbus_supported.supported.anime_ctrl) {
-                if (this.animeDisplayPower == null) {
-                    this.animeDisplayPower = new MenuToggleAnimePower(this._dbus_anime);
-                    this._dbus_anime.notifyAnimeStateSubscribers.push(this.animeDisplayPower);
-                    this._itemsSection.addMenuItem(this.animeDisplayPower);
-                    this._dbus_anime.notifyAnimeStateSubscribers.push(this);
-                    this.animeDisplayPower.toggle_callback = () => {
-                        this.primary = "anime-power";
-                        this.sync();
-                    }
-                }
-
-                if (this.animePowersaveAnim == null) {
-                    this.animePowersaveAnim = new MenuToggleAnimeBuiltins(this._dbus_anime);
-                    this._dbus_anime.notifyAnimeStateSubscribers.push(this.animePowersaveAnim);
-                    this._itemsSection.addMenuItem(this.animePowersaveAnim);
-                }
-            }
-
-            this.connectObject(
-                "clicked", () => {
-                    this._toggle();
-                },
-                this);
-
-            this.menu.addMenuItem(this._itemsSection);
-
-            // // Add an entry-point for more settings
-            // this.menu.addMenuItem(new PopupMenu.PopupSeparatorMenuItem());
-            // const settingsItem = this.menu.addAction("More Settings",
-            //     () => ExtensionUtils.openPrefs());
-            // // Ensure the settings are unavailable when the screen is locked
-            // settingsItem.visible = Main.sessionMode.allowSettings;
-            // this.menu._settingsActions[Me.uuid] = settingsItem;
-
-            this.sync();
-            addQuickSettingsItems([this]);
-        }
-
-        _toggle() {
-            if (this.primary == "mini-led" && this.miniLed != null) {
-                this._dbus_platform.getMiniLedMode();
-                const checked = this._dbus_platform.bios.mini_led_mode;
-                if (this.checked !== checked)
-                    this._dbus_platform.setMiniLedMode(this.checked);
-            }
-
-            if (this.primary == "panel-od" && this.panelOd != null) {
-                this._dbus_platform.getPanelOd();
-                const checked = this._dbus_platform.bios.panel_overdrive;
-                if (this.checked !== checked)
-                    this._dbus_platform.setPanelOd(this.checked);
-            }
-
-            if (this.primary == "anime-power" && this.animeDisplayPower != null) {
-                this._dbus_anime.getDeviceState();
-                const checked = this._dbus_anime.deviceState.display_enabled;
-                if (this.checked !== checked)
-                    this._dbus_anime.setEnableDisplay(this.checked);
-            }
-        }
-
-        sync() {
-            let checked = false;
-            if (this.primary == "mini-led" && this.miniLed != null) {
-                this.title = this.miniLed.label;
-                checked = this._dbus_platform.bios.mini_led_mode;
-            }
-
-            if (this.primary == "panel-od" && this.panelOd != null) {
-                this.title = this.panelOd.label;
-                checked = this._dbus_platform.bios.panel_overdrive;
-            }
-
-            if (this.primary == "anime-power" && this.animeDisplayPower != null) {
-                this.title = this.animeDisplayPower.label;
-                checked = this._dbus_anime.deviceState.display_enabled;
-            }
-
-            // if (this.animePowersaveAnim != null) {
-            // }
-
-            if (this.checked !== checked)
-                this.set({ checked });
-        }
-    });

desktop-extensions/gnome-44/src/modules/quick_toggles/anime_power.ts

@@ -1,56 +0,0 @@
-declare const imports: any;
-
-import { AnimeDbus } from "../dbus/animatrix";
-import { addQuickSettingsItems } from "../helpers";
-
-const { GObject, Gio } = imports.gi;
-const ExtensionUtils = imports.misc.extensionUtils;
-
-const { QuickToggle } = imports.ui.quickSettings;
-
-export const QuickAnimePower = GObject.registerClass(
-    class QuickAnimePower extends QuickToggle {
-        private _dbus_anime: AnimeDbus;
-
-        constructor(dbus_anime: AnimeDbus) {
-            super({
-                title: "AniMatrix Power",
-                iconName: "selection-mode-symbolic",
-                toggleMode: true,
-            });
-            this._dbus_anime = dbus_anime;
-            this.label = "AniMatrix Power";
-            this._settings = ExtensionUtils.getSettings();
-
-            this.connectObject(
-                "destroy", () => this._settings.run_dispose(),
-                "clicked", () => this._toggleMode(),
-                this);
-
-            this.connect("destroy", () => {
-                this.destroy();
-            });
-
-            this._settings.bind("anime-power",
-                this, "checked",
-                Gio.SettingsBindFlags.DEFAULT);
-
-            this.sync();
-
-            addQuickSettingsItems([this]);
-        }
-
-        _toggleMode() {
-            this._dbus_anime.getDeviceState();
-            const checked = this._dbus_anime.deviceState.display_enabled;
-            if (this.checked !== checked)
-                this._dbus_anime.setEnableDisplay(this.checked);
-        }
-
-        sync() {
-            this._dbus_anime.getDeviceState();
-            const checked = this._dbus_anime.deviceState.display_enabled;
-            if (this.checked !== checked)
-                this.set({ checked });
-        }
-    });

desktop-extensions/gnome-44/src/modules/quick_toggles/mini_led.ts

@@ -1,54 +0,0 @@
-declare const imports: any;
-
-import { Platform } from "../dbus/platform";
-import { addQuickSettingsItems } from "../helpers";
-
-const { GObject, Gio } = imports.gi;
-const ExtensionUtils = imports.misc.extensionUtils;
-
-const { QuickToggle } = imports.ui.quickSettings;
-
-export const QuickMiniLed = GObject.registerClass(
-    class QuickMiniLed extends QuickToggle {
-        private _dbus_platform: Platform;
-
-        constructor(dbus_platform: Platform) {
-            super({
-                title: "MiniLED",
-                iconName: "selection-mode-symbolic",
-                toggleMode: true,
-            });
-            this._dbus_platform = dbus_platform;
-            this.label = "MiniLED";
-            this._settings = ExtensionUtils.getSettings();
-
-            this.connectObject(
-                "destroy", () => this._settings.run_dispose(),
-                "clicked", () => this._toggleMode(),
-                this);
-
-            this.connect("destroy", () => {
-                this.destroy();
-            });
-
-            this._settings.bind("mini-led-enabled",
-                this, "checked",
-                Gio.SettingsBindFlags.DEFAULT);
-
-            this.sync();
-
-            addQuickSettingsItems([this]);
-        }
-
-        _toggleMode() {
-            const checked = this._dbus_platform.getMiniLedMode();
-            if (this.checked !== checked)
-                this._dbus_platform.setMiniLedMode(this.checked);
-        }
-
-        sync() {
-            const checked = this._dbus_platform.getMiniLedMode();
-            if (this.checked !== checked)
-                this.set({ checked });
-        }
-    });

desktop-extensions/gnome-44/src/modules/quick_toggles/panel_od.ts

@@ -1,54 +0,0 @@
-declare const imports: any;
-
-import { Platform } from "../dbus/platform";
-import { addQuickSettingsItems } from "../helpers";
-
-const { GObject, Gio } = imports.gi;
-const ExtensionUtils = imports.misc.extensionUtils;
-
-const { QuickToggle } = imports.ui.quickSettings;
-
-export const QuickPanelOd = GObject.registerClass(
-    class QuickPanelOd extends QuickToggle {
-        private _dbus_platform: Platform;
-
-        constructor(dbus_platform: Platform) {
-            super({
-                title: "Panel Overdrive",
-                iconName: "selection-mode-symbolic",
-                toggleMode: true,
-            });
-            this._dbus_platform = dbus_platform;
-            this.label = "Panel Overdrive";
-            this._settings = ExtensionUtils.getSettings();
-
-            this.connectObject(
-                "destroy", () => this._settings.run_dispose(),
-                "clicked", () => this._toggleMode(),
-                this);
-
-            this.connect("destroy", () => {
-                this.destroy();
-            });
-
-            this._settings.bind("panel-od-enabled",
-                this, "checked",
-                Gio.SettingsBindFlags.DEFAULT);
-
-            this.sync();
-
-            addQuickSettingsItems([this]);
-        }
-
-        _toggleMode() {
-            const checked = this._dbus_platform.getPanelOd();
-            if (this.checked !== checked)
-                this._dbus_platform.setPanelOd(this.checked);
-        }
-
-        sync() {
-            const checked = this._dbus_platform.getPanelOd();
-            if (this.checked !== checked)
-                this.set({ checked });
-        }
-    });

desktop-extensions/gnome-44/src/modules/resources.ts

@@ -1,20 +0,0 @@
-declare const imports: any;
-const Me = imports.misc.extensionUtils.getCurrentExtension();
-
-const GLib = imports.gi.GLib;
-
-export class File {
-    public static DBus(name: string) {
-        const file = `${Me.path}/resources/dbus/${name}.xml`;
-        try {
-            const [_ok, bytes] = GLib.file_get_contents(file);
-            if (!_ok)
-            //@ts-ignore
-                log(`Couldn't read contents of "${file}"`);
-            return _ok ? imports.byteArray.toString(bytes) : null;
-        } catch (e) {
-            //@ts-ignore
-            log(`Failed to load "${file}"`, e);
-        }
-    }
-}

desktop-extensions/gnome-44/src/modules/sliders/charge.ts

@@ -1,60 +0,0 @@
-import { Power } from "../dbus/power";
-import { addQuickSettingsItems } from "../helpers";
-
-declare const imports: any;
-
-const { GObject } = imports.gi;
-const ExtensionUtils = imports.misc.extensionUtils;
-const QuickSettings = imports.ui.quickSettings;
-
-export const SliderChargeLevel = GObject.registerClass(
-    class SliderChargeLevel extends QuickSettings.QuickSlider {
-        private _dbus_power: Power;
-
-        constructor(dbus_power: Power) {
-            super({
-                iconName: "selection-mode-symbolic",
-            });
-            this._dbus_power = dbus_power;
-
-            this._sliderChangedId = this.slider.connect("drag-end",
-                this._onSliderChanged.bind(this));
-
-            // Binding the slider to a GSettings key
-            this._settings = ExtensionUtils.getSettings();
-
-            this._settings.connect("changed::charge-level",
-                this._onSettingsChanged.bind(this));
-
-            // Set an accessible name for the slider
-            this.slider.accessible_name = "Charge level";
-
-            this._sync();
-            this._onSettingsChanged();
-
-            addQuickSettingsItems([this], 2);
-        }
-
-        _onSettingsChanged() {
-            // Prevent the slider from emitting a change signal while being updated
-            this.slider.block_signal_handler(this._sliderChangedId);
-            this.slider.value = this._settings.get_uint("charge-level") / 100.0;
-            this.slider.unblock_signal_handler(this._sliderChangedId);
-        }
-
-        _onSliderChanged() {
-            // Assuming our GSettings holds values between 0..100, adjust for the
-            // slider taking values between 0..1
-            const percent = Math.floor(this.slider.value * 100);
-            const stored = Math.floor(this._settings.get_uint("charge-level") / 100.0);
-            if (this.slider.value !== stored)
-                this._dbus_power.setChargingLimit(percent);
-            this._settings.set_uint("charge-level", percent);
-        }
-
-        _sync() {
-            const value = this._dbus_power.getChargingLimit();
-            if (this.slider.value !== value / 100)
-                this._settings.set_uint("charge-level", value);
-        }
-    });

desktop-extensions/gnome-44/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": [
-      "es2019"
-    ],
-    "types": [],
-    "target": "es2019",
-    "module": "CommonJS",
-    "moduleResolution": "node",
-    "declaration": true,
-    "removeComments": true,
-    "strict": true,
-    "allowJs": true
-  },
-  "files": [
-    "./src/extension.ts",
-  ],
-  "include": [
-    "src/*.ts",
-    "src/**/*.ts"
-  ]
-}

desktop-extensions/gnome-44/yarn.lock

@@ -1,940 +0,0 @@
-# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
-# yarn lockfile v1
-
-
-"@aashutoshrathi/word-wrap@^1.2.3":
-  version "1.2.6"
-  resolved "https://registry.npmjs.org/@aashutoshrathi/word-wrap/-/word-wrap-1.2.6.tgz"
-  integrity sha512-1Yjs2SvM8TflER/OD3cOjhWWOZb58A2t7wpE2S9XfBYTiIl+XFhQG2bjy4Pu1I+EAlCNUzRDYDdFwFYUKvXcIA==
-
-"@esbuild/linux-x64@0.17.19":
-  version "0.17.19"
-  resolved "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.17.19.tgz"
-  integrity sha512-68ngA9lg2H6zkZcyp22tsVt38mlhWde8l3eJLWkyLrp4HwMUr3c1s/M2t7+kHIhvMjglIBrFpncX1SzMckomGw==
-
-"@eslint-community/eslint-utils@^4.2.0":
-  version "4.4.0"
-  resolved "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz"
-  integrity sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==
-  dependencies:
-    eslint-visitor-keys "^3.3.0"
-
-"@eslint-community/regexpp@^4.4.0":
-  version "4.5.1"
-  resolved "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.5.1.tgz"
-  integrity sha512-Z5ba73P98O1KUYCCJTUeVpja9RcGoMdncZ6T49FCUl2lN38JtCJ+3WgIDBv0AuY4WChU5PmtJmOCTlN6FZTFKQ==
-
-"@eslint/eslintrc@^2.1.0":
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.0.tgz"
-  integrity sha512-Lj7DECXqIVCqnqjjHMPna4vn6GJcMgul/wuS0je9OZ9gsL0zzDpKPVtcG1HaDVc+9y+qgXneTeUMbCqXJNpH1A==
-  dependencies:
-    ajv "^6.12.4"
-    debug "^4.3.2"
-    espree "^9.6.0"
-    globals "^13.19.0"
-    ignore "^5.2.0"
-    import-fresh "^3.2.1"
-    js-yaml "^4.1.0"
-    minimatch "^3.1.2"
-    strip-json-comments "^3.1.1"
-
-"@eslint/js@8.44.0":
-  version "8.44.0"
-  resolved "https://registry.npmjs.org/@eslint/js/-/js-8.44.0.tgz"
-  integrity sha512-Ag+9YM4ocKQx9AarydN0KY2j0ErMHNIocPDrVo8zAE44xLTjEtz81OdR68/cydGtk6m6jDb5Za3r2useMzYmSw==
-
-"@humanwhocodes/config-array@^0.11.10":
-  version "0.11.10"
-  resolved "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.10.tgz"
-  integrity sha512-KVVjQmNUepDVGXNuoRRdmmEjruj0KfiGSbS8LVc12LMsWDQzRXJ0qdhN8L8uUigKpfEHRhlaQFY0ib1tnUbNeQ==
-  dependencies:
-    "@humanwhocodes/object-schema" "^1.2.1"
-    debug "^4.1.1"
-    minimatch "^3.0.5"
-
-"@humanwhocodes/module-importer@^1.0.1":
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz"
-  integrity sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==
-
-"@humanwhocodes/object-schema@^1.2.1":
-  version "1.2.1"
-  resolved "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz"
-  integrity sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==
-
-"@nodelib/fs.scandir@2.1.5":
-  version "2.1.5"
-  resolved "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz"
-  integrity sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==
-  dependencies:
-    "@nodelib/fs.stat" "2.0.5"
-    run-parallel "^1.1.9"
-
-"@nodelib/fs.stat@^2.0.2", "@nodelib/fs.stat@2.0.5":
-  version "2.0.5"
-  resolved "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz"
-  integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==
-
-"@nodelib/fs.walk@^1.2.3", "@nodelib/fs.walk@^1.2.8":
-  version "1.2.8"
-  resolved "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz"
-  integrity sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==
-  dependencies:
-    "@nodelib/fs.scandir" "2.1.5"
-    fastq "^1.6.0"
-
-"@types/json-schema@^7.0.9":
-  version "7.0.12"
-  resolved "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.12.tgz"
-  integrity sha512-Hr5Jfhc9eYOQNPYO5WLDq/n4jqijdHNlDXjuAQkkt+mWdQR+XJToOHrsD4cPaMXpn6KO7y2+wM8AZEs8VpBLVA==
-
-"@types/semver@^7.3.12":
-  version "7.5.0"
-  resolved "https://registry.npmjs.org/@types/semver/-/semver-7.5.0.tgz"
-  integrity sha512-G8hZ6XJiHnuhQKR7ZmysCeJWE08o8T0AXtk5darsCaTVsYZhhgUrq53jizaR2FvsoeCwJhlmwTjkXBY5Pn/ZHw==
-
-"@typescript-eslint/eslint-plugin@^5.60.1":
-  version "5.60.1"
-  resolved "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.60.1.tgz"
-  integrity sha512-KSWsVvsJsLJv3c4e73y/Bzt7OpqMCADUO846bHcuWYSYM19bldbAeDv7dYyV0jwkbMfJ2XdlzwjhXtuD7OY6bw==
-  dependencies:
-    "@eslint-community/regexpp" "^4.4.0"
-    "@typescript-eslint/scope-manager" "5.60.1"
-    "@typescript-eslint/type-utils" "5.60.1"
-    "@typescript-eslint/utils" "5.60.1"
-    debug "^4.3.4"
-    grapheme-splitter "^1.0.4"
-    ignore "^5.2.0"
-    natural-compare-lite "^1.4.0"
-    semver "^7.3.7"
-    tsutils "^3.21.0"
-
-"@typescript-eslint/parser@^5.0.0", "@typescript-eslint/parser@^5.60.1":
-  version "5.60.1"
-  resolved "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.60.1.tgz"
-  integrity sha512-pHWlc3alg2oSMGwsU/Is8hbm3XFbcrb6P5wIxcQW9NsYBfnrubl/GhVVD/Jm/t8HXhA2WncoIRfBtnCgRGV96Q==
-  dependencies:
-    "@typescript-eslint/scope-manager" "5.60.1"
-    "@typescript-eslint/types" "5.60.1"
-    "@typescript-eslint/typescript-estree" "5.60.1"
-    debug "^4.3.4"
-
-"@typescript-eslint/scope-manager@5.60.1":
-  version "5.60.1"
-  resolved "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.60.1.tgz"
-  integrity sha512-Dn/LnN7fEoRD+KspEOV0xDMynEmR3iSHdgNsarlXNLGGtcUok8L4N71dxUgt3YvlO8si7E+BJ5Fe3wb5yUw7DQ==
-  dependencies:
-    "@typescript-eslint/types" "5.60.1"
-    "@typescript-eslint/visitor-keys" "5.60.1"
-
-"@typescript-eslint/type-utils@5.60.1":
-  version "5.60.1"
-  resolved "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.60.1.tgz"
-  integrity sha512-vN6UztYqIu05nu7JqwQGzQKUJctzs3/Hg7E2Yx8rz9J+4LgtIDFWjjl1gm3pycH0P3mHAcEUBd23LVgfrsTR8A==
-  dependencies:
-    "@typescript-eslint/typescript-estree" "5.60.1"
-    "@typescript-eslint/utils" "5.60.1"
-    debug "^4.3.4"
-    tsutils "^3.21.0"
-
-"@typescript-eslint/types@5.60.1":
-  version "5.60.1"
-  resolved "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.60.1.tgz"
-  integrity sha512-zDcDx5fccU8BA0IDZc71bAtYIcG9PowaOwaD8rjYbqwK7dpe/UMQl3inJ4UtUK42nOCT41jTSCwg76E62JpMcg==
-
-"@typescript-eslint/typescript-estree@5.60.1":
-  version "5.60.1"
-  resolved "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.60.1.tgz"
-  integrity sha512-hkX70J9+2M2ZT6fhti5Q2FoU9zb+GeZK2SLP1WZlvUDqdMbEKhexZODD1WodNRyO8eS+4nScvT0dts8IdaBzfw==
-  dependencies:
-    "@typescript-eslint/types" "5.60.1"
-    "@typescript-eslint/visitor-keys" "5.60.1"
-    debug "^4.3.4"
-    globby "^11.1.0"
-    is-glob "^4.0.3"
-    semver "^7.3.7"
-    tsutils "^3.21.0"
-
-"@typescript-eslint/utils@5.60.1":
-  version "5.60.1"
-  resolved "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.60.1.tgz"
-  integrity sha512-tiJ7FFdFQOWssFa3gqb94Ilexyw0JVxj6vBzaSpfN/8IhoKkDuSAenUKvsSHw2A/TMpJb26izIszTXaqygkvpQ==
-  dependencies:
-    "@eslint-community/eslint-utils" "^4.2.0"
-    "@types/json-schema" "^7.0.9"
-    "@types/semver" "^7.3.12"
-    "@typescript-eslint/scope-manager" "5.60.1"
-    "@typescript-eslint/types" "5.60.1"
-    "@typescript-eslint/typescript-estree" "5.60.1"
-    eslint-scope "^5.1.1"
-    semver "^7.3.7"
-
-"@typescript-eslint/visitor-keys@5.60.1":
-  version "5.60.1"
-  resolved "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.60.1.tgz"
-  integrity sha512-xEYIxKcultP6E/RMKqube11pGjXH1DCo60mQoWhVYyKfLkwbIVVjYxmOenNMxILx0TjCujPTjjnTIVzm09TXIw==
-  dependencies:
-    "@typescript-eslint/types" "5.60.1"
-    eslint-visitor-keys "^3.3.0"
-
-acorn-jsx@^5.3.2:
-  version "5.3.2"
-  resolved "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz"
-  integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==
-
-"acorn@^6.0.0 || ^7.0.0 || ^8.0.0", acorn@^8.9.0:
-  version "8.9.0"
-  resolved "https://registry.npmjs.org/acorn/-/acorn-8.9.0.tgz"
-  integrity sha512-jaVNAFBHNLXspO543WnNNPZFRtavh3skAkITqD0/2aeMkKZTN+254PyhwxFYrk3vQ1xfY+2wbesJMs/JC8/PwQ==
-
-adm-zip@^0.5.10:
-  version "0.5.10"
-  resolved "https://registry.npmjs.org/adm-zip/-/adm-zip-0.5.10.tgz"
-  integrity sha512-x0HvcHqVJNTPk/Bw8JbLWlWoo6Wwnsug0fnYYro1HBrjxZ3G7/AZk7Ahv8JwDe1uIcz8eBqvu86FuF1POiG7vQ==
-
-ajv@^6.10.0, ajv@^6.12.4:
-  version "6.12.6"
-  resolved "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz"
-  integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
-  dependencies:
-    fast-deep-equal "^3.1.1"
-    fast-json-stable-stringify "^2.0.0"
-    json-schema-traverse "^0.4.1"
-    uri-js "^4.2.2"
-
-ansi-regex@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz"
-  integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==
-
-ansi-styles@^4.1.0:
-  version "4.3.0"
-  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz"
-  integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
-  dependencies:
-    color-convert "^2.0.1"
-
-argparse@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz"
-  integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==
-
-array-union@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz"
-  integrity sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==
-
-balanced-match@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz"
-  integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==
-
-brace-expansion@^1.1.7:
-  version "1.1.11"
-  resolved "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz"
-  integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
-  dependencies:
-    balanced-match "^1.0.0"
-    concat-map "0.0.1"
-
-braces@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz"
-  integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==
-  dependencies:
-    fill-range "^7.0.1"
-
-callsites@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz"
-  integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==
-
-chalk@^4.0.0:
-  version "4.1.2"
-  resolved "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz"
-  integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
-  dependencies:
-    ansi-styles "^4.1.0"
-    supports-color "^7.1.0"
-
-color-convert@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz"
-  integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==
-  dependencies:
-    color-name "~1.1.4"
-
-color-name@~1.1.4:
-  version "1.1.4"
-  resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz"
-  integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
-
-concat-map@0.0.1:
-  version "0.0.1"
-  resolved "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz"
-  integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==
-
-cross-spawn@^7.0.2:
-  version "7.0.3"
-  resolved "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz"
-  integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==
-  dependencies:
-    path-key "^3.1.0"
-    shebang-command "^2.0.0"
-    which "^2.0.1"
-
-debug@^4.1.1, debug@^4.3.2, debug@^4.3.4:
-  version "4.3.4"
-  resolved "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz"
-  integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==
-  dependencies:
-    ms "2.1.2"
-
-deep-is@^0.1.3:
-  version "0.1.4"
-  resolved "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz"
-  integrity sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==
-
-dir-glob@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz"
-  integrity sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==
-  dependencies:
-    path-type "^4.0.0"
-
-doctrine@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz"
-  integrity sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==
-  dependencies:
-    esutils "^2.0.2"
-
-esbuild@^0.17.19:
-  version "0.17.19"
-  resolved "https://registry.npmjs.org/esbuild/-/esbuild-0.17.19.tgz"
-  integrity sha512-XQ0jAPFkK/u3LcVRcvVHQcTIqD6E2H1fvZMA5dQPSOWb3suUbWbfbRf94pjc0bNzRYLfIrDRQXr7X+LHIm5oHw==
-  optionalDependencies:
-    "@esbuild/android-arm" "0.17.19"
-    "@esbuild/android-arm64" "0.17.19"
-    "@esbuild/android-x64" "0.17.19"
-    "@esbuild/darwin-arm64" "0.17.19"
-    "@esbuild/darwin-x64" "0.17.19"
-    "@esbuild/freebsd-arm64" "0.17.19"
-    "@esbuild/freebsd-x64" "0.17.19"
-    "@esbuild/linux-arm" "0.17.19"
-    "@esbuild/linux-arm64" "0.17.19"
-    "@esbuild/linux-ia32" "0.17.19"
-    "@esbuild/linux-loong64" "0.17.19"
-    "@esbuild/linux-mips64el" "0.17.19"
-    "@esbuild/linux-ppc64" "0.17.19"
-    "@esbuild/linux-riscv64" "0.17.19"
-    "@esbuild/linux-s390x" "0.17.19"
-    "@esbuild/linux-x64" "0.17.19"
-    "@esbuild/netbsd-x64" "0.17.19"
-    "@esbuild/openbsd-x64" "0.17.19"
-    "@esbuild/sunos-x64" "0.17.19"
-    "@esbuild/win32-arm64" "0.17.19"
-    "@esbuild/win32-ia32" "0.17.19"
-    "@esbuild/win32-x64" "0.17.19"
-
-escape-string-regexp@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz"
-  integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==
-
-eslint-scope@^5.1.1:
-  version "5.1.1"
-  resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz"
-  integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==
-  dependencies:
-    esrecurse "^4.3.0"
-    estraverse "^4.1.1"
-
-eslint-scope@^7.2.0:
-  version "7.2.0"
-  resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.0.tgz"
-  integrity sha512-DYj5deGlHBfMt15J7rdtyKNq/Nqlv5KfU4iodrQ019XESsRnwXH9KAE0y3cwtUHDo2ob7CypAnCqefh6vioWRw==
-  dependencies:
-    esrecurse "^4.3.0"
-    estraverse "^5.2.0"
-
-eslint-visitor-keys@^3.3.0, eslint-visitor-keys@^3.4.1:
-  version "3.4.1"
-  resolved "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.1.tgz"
-  integrity sha512-pZnmmLwYzf+kWaM/Qgrvpen51upAktaaiI01nsJD/Yr3lMOdNtq0cxkrrg16w64VtisN6okbs7Q8AfGqj4c9fA==
-
-eslint@*, "eslint@^6.0.0 || ^7.0.0 || ^8.0.0", "eslint@^6.0.0 || ^7.0.0 || >=8.0.0", eslint@^8.44.0:
-  version "8.44.0"
-  resolved "https://registry.npmjs.org/eslint/-/eslint-8.44.0.tgz"
-  integrity sha512-0wpHoUbDUHgNCyvFB5aXLiQVfK9B0at6gUvzy83k4kAsQ/u769TQDX6iKC+aO4upIHO9WSaA3QoXYQDHbNwf1A==
-  dependencies:
-    "@eslint-community/eslint-utils" "^4.2.0"
-    "@eslint-community/regexpp" "^4.4.0"
-    "@eslint/eslintrc" "^2.1.0"
-    "@eslint/js" "8.44.0"
-    "@humanwhocodes/config-array" "^0.11.10"
-    "@humanwhocodes/module-importer" "^1.0.1"
-    "@nodelib/fs.walk" "^1.2.8"
-    ajv "^6.10.0"
-    chalk "^4.0.0"
-    cross-spawn "^7.0.2"
-    debug "^4.3.2"
-    doctrine "^3.0.0"
-    escape-string-regexp "^4.0.0"
-    eslint-scope "^7.2.0"
-    eslint-visitor-keys "^3.4.1"
-    espree "^9.6.0"
-    esquery "^1.4.2"
-    esutils "^2.0.2"
-    fast-deep-equal "^3.1.3"
-    file-entry-cache "^6.0.1"
-    find-up "^5.0.0"
-    glob-parent "^6.0.2"
-    globals "^13.19.0"
-    graphemer "^1.4.0"
-    ignore "^5.2.0"
-    import-fresh "^3.0.0"
-    imurmurhash "^0.1.4"
-    is-glob "^4.0.0"
-    is-path-inside "^3.0.3"
-    js-yaml "^4.1.0"
-    json-stable-stringify-without-jsonify "^1.0.1"
-    levn "^0.4.1"
-    lodash.merge "^4.6.2"
-    minimatch "^3.1.2"
-    natural-compare "^1.4.0"
-    optionator "^0.9.3"
-    strip-ansi "^6.0.1"
-    strip-json-comments "^3.1.0"
-    text-table "^0.2.0"
-
-espree@^9.6.0:
-  version "9.6.0"
-  resolved "https://registry.npmjs.org/espree/-/espree-9.6.0.tgz"
-  integrity sha512-1FH/IiruXZ84tpUlm0aCUEwMl2Ho5ilqVh0VvQXw+byAz/4SAciyHLlfmL5WYqsvD38oymdUwBss0LtK8m4s/A==
-  dependencies:
-    acorn "^8.9.0"
-    acorn-jsx "^5.3.2"
-    eslint-visitor-keys "^3.4.1"
-
-esquery@^1.4.2:
-  version "1.5.0"
-  resolved "https://registry.npmjs.org/esquery/-/esquery-1.5.0.tgz"
-  integrity sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==
-  dependencies:
-    estraverse "^5.1.0"
-
-esrecurse@^4.3.0:
-  version "4.3.0"
-  resolved "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz"
-  integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==
-  dependencies:
-    estraverse "^5.2.0"
-
-estraverse@^4.1.1:
-  version "4.3.0"
-  resolved "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz"
-  integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==
-
-estraverse@^5.1.0:
-  version "5.3.0"
-  resolved "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz"
-  integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==
-
-estraverse@^5.2.0:
-  version "5.3.0"
-  resolved "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz"
-  integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==
-
-esutils@^2.0.2:
-  version "2.0.3"
-  resolved "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz"
-  integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
-
-fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3:
-  version "3.1.3"
-  resolved "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz"
-  integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==
-
-fast-glob@^3.2.9:
-  version "3.3.0"
-  resolved "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.0.tgz"
-  integrity sha512-ChDuvbOypPuNjO8yIDf36x7BlZX1smcUMTTcyoIjycexOxd6DFsKsg21qVBzEmr3G7fUKIRy2/psii+CIUt7FA==
-  dependencies:
-    "@nodelib/fs.stat" "^2.0.2"
-    "@nodelib/fs.walk" "^1.2.3"
-    glob-parent "^5.1.2"
-    merge2 "^1.3.0"
-    micromatch "^4.0.4"
-
-fast-json-stable-stringify@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz"
-  integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==
-
-fast-levenshtein@^2.0.6:
-  version "2.0.6"
-  resolved "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz"
-  integrity sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==
-
-fastq@^1.6.0:
-  version "1.15.0"
-  resolved "https://registry.npmjs.org/fastq/-/fastq-1.15.0.tgz"
-  integrity sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==
-  dependencies:
-    reusify "^1.0.4"
-
-file-entry-cache@^6.0.1:
-  version "6.0.1"
-  resolved "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz"
-  integrity sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==
-  dependencies:
-    flat-cache "^3.0.4"
-
-fill-range@^7.0.1:
-  version "7.0.1"
-  resolved "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz"
-  integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==
-  dependencies:
-    to-regex-range "^5.0.1"
-
-find-up@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz"
-  integrity sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==
-  dependencies:
-    locate-path "^6.0.0"
-    path-exists "^4.0.0"
-
-flat-cache@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.npmjs.org/flat-cache/-/flat-cache-3.0.4.tgz"
-  integrity sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==
-  dependencies:
-    flatted "^3.1.0"
-    rimraf "^3.0.2"
-
-flatted@^3.1.0:
-  version "3.2.7"
-  resolved "https://registry.npmjs.org/flatted/-/flatted-3.2.7.tgz"
-  integrity sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ==
-
-fs.realpath@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz"
-  integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==
-
-glob-parent@^5.1.2:
-  version "5.1.2"
-  resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz"
-  integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==
-  dependencies:
-    is-glob "^4.0.1"
-
-glob-parent@^6.0.2:
-  version "6.0.2"
-  resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz"
-  integrity sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==
-  dependencies:
-    is-glob "^4.0.3"
-
-glob@^7.1.3:
-  version "7.2.3"
-  resolved "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz"
-  integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==
-  dependencies:
-    fs.realpath "^1.0.0"
-    inflight "^1.0.4"
-    inherits "2"
-    minimatch "^3.1.1"
-    once "^1.3.0"
-    path-is-absolute "^1.0.0"
-
-globals@^13.19.0:
-  version "13.20.0"
-  resolved "https://registry.npmjs.org/globals/-/globals-13.20.0.tgz"
-  integrity sha512-Qg5QtVkCy/kv3FUSlu4ukeZDVf9ee0iXLAUYX13gbR17bnejFTzr4iS9bY7kwCf1NztRNm1t91fjOiyx4CSwPQ==
-  dependencies:
-    type-fest "^0.20.2"
-
-globby@^11.1.0:
-  version "11.1.0"
-  resolved "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz"
-  integrity sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==
-  dependencies:
-    array-union "^2.1.0"
-    dir-glob "^3.0.1"
-    fast-glob "^3.2.9"
-    ignore "^5.2.0"
-    merge2 "^1.4.1"
-    slash "^3.0.0"
-
-grapheme-splitter@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.npmjs.org/grapheme-splitter/-/grapheme-splitter-1.0.4.tgz"
-  integrity sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==
-
-graphemer@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz"
-  integrity sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==
-
-has-flag@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz"
-  integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
-
-ignore@^5.2.0:
-  version "5.2.4"
-  resolved "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz"
-  integrity sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==
-
-import-fresh@^3.0.0, import-fresh@^3.2.1:
-  version "3.3.0"
-  resolved "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz"
-  integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==
-  dependencies:
-    parent-module "^1.0.0"
-    resolve-from "^4.0.0"
-
-imurmurhash@^0.1.4:
-  version "0.1.4"
-  resolved "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz"
-  integrity sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==
-
-inflight@^1.0.4:
-  version "1.0.6"
-  resolved "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz"
-  integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==
-  dependencies:
-    once "^1.3.0"
-    wrappy "1"
-
-inherits@2:
-  version "2.0.4"
-  resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz"
-  integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
-
-is-extglob@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz"
-  integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==
-
-is-glob@^4.0.0, is-glob@^4.0.1, is-glob@^4.0.3:
-  version "4.0.3"
-  resolved "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz"
-  integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==
-  dependencies:
-    is-extglob "^2.1.1"
-
-is-number@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz"
-  integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
-
-is-path-inside@^3.0.3:
-  version "3.0.3"
-  resolved "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz"
-  integrity sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==
-
-isexe@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz"
-  integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==
-
-js-yaml@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz"
-  integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==
-  dependencies:
-    argparse "^2.0.1"
-
-json-schema-traverse@^0.4.1:
-  version "0.4.1"
-  resolved "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz"
-  integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==
-
-json-stable-stringify-without-jsonify@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz"
-  integrity sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==
-
-levn@^0.4.1:
-  version "0.4.1"
-  resolved "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz"
-  integrity sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==
-  dependencies:
-    prelude-ls "^1.2.1"
-    type-check "~0.4.0"
-
-locate-path@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz"
-  integrity sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==
-  dependencies:
-    p-locate "^5.0.0"
-
-lodash.merge@^4.6.2:
-  version "4.6.2"
-  resolved "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz"
-  integrity sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==
-
-lru-cache@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz"
-  integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==
-  dependencies:
-    yallist "^4.0.0"
-
-merge2@^1.3.0, merge2@^1.4.1:
-  version "1.4.1"
-  resolved "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz"
-  integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==
-
-micromatch@^4.0.4:
-  version "4.0.5"
-  resolved "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz"
-  integrity sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==
-  dependencies:
-    braces "^3.0.2"
-    picomatch "^2.3.1"
-
-minimatch@^3.0.5, minimatch@^3.1.1, minimatch@^3.1.2:
-  version "3.1.2"
-  resolved "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz"
-  integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==
-  dependencies:
-    brace-expansion "^1.1.7"
-
-ms@2.1.2:
-  version "2.1.2"
-  resolved "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz"
-  integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
-
-natural-compare-lite@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.npmjs.org/natural-compare-lite/-/natural-compare-lite-1.4.0.tgz"
-  integrity sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g==
-
-natural-compare@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz"
-  integrity sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==
-
-once@^1.3.0:
-  version "1.4.0"
-  resolved "https://registry.npmjs.org/once/-/once-1.4.0.tgz"
-  integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==
-  dependencies:
-    wrappy "1"
-
-optionator@^0.9.3:
-  version "0.9.3"
-  resolved "https://registry.npmjs.org/optionator/-/optionator-0.9.3.tgz"
-  integrity sha512-JjCoypp+jKn1ttEFExxhetCKeJt9zhAgAve5FXHixTvFDW/5aEktX9bufBKLRRMdU7bNtpLfcGu94B3cdEJgjg==
-  dependencies:
-    "@aashutoshrathi/word-wrap" "^1.2.3"
-    deep-is "^0.1.3"
-    fast-levenshtein "^2.0.6"
-    levn "^0.4.1"
-    prelude-ls "^1.2.1"
-    type-check "^0.4.0"
-
-p-limit@^3.0.2:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz"
-  integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==
-  dependencies:
-    yocto-queue "^0.1.0"
-
-p-locate@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz"
-  integrity sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==
-  dependencies:
-    p-limit "^3.0.2"
-
-parent-module@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz"
-  integrity sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==
-  dependencies:
-    callsites "^3.0.0"
-
-path-exists@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz"
-  integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==
-
-path-is-absolute@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz"
-  integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==
-
-path-key@^3.1.0:
-  version "3.1.1"
-  resolved "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz"
-  integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
-
-path-type@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz"
-  integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==
-
-picomatch@^2.3.1:
-  version "2.3.1"
-  resolved "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz"
-  integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==
-
-prelude-ls@^1.2.1:
-  version "1.2.1"
-  resolved "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz"
-  integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==
-
-punycode@^2.1.0:
-  version "2.3.0"
-  resolved "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz"
-  integrity sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==
-
-queue-microtask@^1.2.2:
-  version "1.2.3"
-  resolved "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz"
-  integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==
-
-resolve-from@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz"
-  integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==
-
-reusify@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz"
-  integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==
-
-rimraf@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz"
-  integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==
-  dependencies:
-    glob "^7.1.3"
-
-run-parallel@^1.1.9:
-  version "1.2.0"
-  resolved "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz"
-  integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==
-  dependencies:
-    queue-microtask "^1.2.2"
-
-semver@^7.3.7:
-  version "7.5.3"
-  resolved "https://registry.npmjs.org/semver/-/semver-7.5.3.tgz"
-  integrity sha512-QBlUtyVk/5EeHbi7X0fw6liDZc7BBmEaSYn01fMU1OUYbf6GPsbTtd8WmnqbI20SeycoHSeiybkE/q1Q+qlThQ==
-  dependencies:
-    lru-cache "^6.0.0"
-
-shebang-command@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz"
-  integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==
-  dependencies:
-    shebang-regex "^3.0.0"
-
-shebang-regex@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz"
-  integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
-
-slash@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz"
-  integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==
-
-strip-ansi@^6.0.1:
-  version "6.0.1"
-  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz"
-  integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
-  dependencies:
-    ansi-regex "^5.0.1"
-
-strip-json-comments@^3.1.0, strip-json-comments@^3.1.1:
-  version "3.1.1"
-  resolved "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz"
-  integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==
-
-supports-color@^7.1.0:
-  version "7.2.0"
-  resolved "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz"
-  integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==
-  dependencies:
-    has-flag "^4.0.0"
-
-text-table@^0.2.0:
-  version "0.2.0"
-  resolved "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz"
-  integrity sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==
-
-to-regex-range@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz"
-  integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==
-  dependencies:
-    is-number "^7.0.0"
-
-tslib@^1.8.1:
-  version "1.14.1"
-  resolved "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz"
-  integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==
-
-tsutils@^3.21.0:
-  version "3.21.0"
-  resolved "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz"
-  integrity sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==
-  dependencies:
-    tslib "^1.8.1"
-
-type-check@^0.4.0, type-check@~0.4.0:
-  version "0.4.0"
-  resolved "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz"
-  integrity sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==
-  dependencies:
-    prelude-ls "^1.2.1"
-
-type-fest@^0.20.2:
-  version "0.20.2"
-  resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz"
-  integrity sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==
-
-typescript@^5.1.6, "typescript@>=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta":
-  version "5.1.6"
-  resolved "https://registry.npmjs.org/typescript/-/typescript-5.1.6.tgz"
-  integrity sha512-zaWCozRZ6DLEWAWFrVDz1H6FVXzUSfTy5FUMWsQlU8Ym5JP9eO4xkTIROFCQvhQf61z6O/G6ugw3SgAnvvm+HA==
-
-uri-js@^4.2.2:
-  version "4.4.1"
-  resolved "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz"
-  integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==
-  dependencies:
-    punycode "^2.1.0"
-
-which@^2.0.1:
-  version "2.0.2"
-  resolved "https://registry.npmjs.org/which/-/which-2.0.2.tgz"
-  integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==
-  dependencies:
-    isexe "^2.0.0"
-
-wrappy@1:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz"
-  integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==
-
-yallist@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz"
-  integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
-
-yocto-queue@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz"
-  integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==

desktop-extensions/gnome-45/.eslintrc.cjs

@@ -1,25 +1,25 @@
 /* eslint-env node */
 module.exports = {
-    extends: ["eslint:recommended", "plugin:@typescript-eslint/recommended"],
-    parser: "@typescript-eslint/parser",
-    plugins: ["@typescript-eslint"],
-    root: true,
+  extends: ["eslint:recommended", "plugin:@typescript-eslint/recommended"],
+  parser: "@typescript-eslint/parser",
+  plugins: ["@typescript-eslint"],
+  root: true,
 
-    "rules": {
+  rules: {
     // enable additional rules
-        "indent": ["error", 4],
-        "linebreak-style": ["error", "unix"],
-        "quotes": ["error", "double"],
-        "semi": ["error", "always"],
+    indent: ["error", 4],
+    "linebreak-style": ["error", "unix"],
+    quotes: ["error", "double"],
+    semi: ["error", "always"],
 
-        // override configuration set by extending "eslint:recommended"
-        "no-empty": "warn",
-        "no-cond-assign": ["error", "always"],
+    // override configuration set by extending "eslint:recommended"
+    "no-empty": "warn",
+    "no-cond-assign": ["error", "always"],
 
-        // disable rules from base configurations
-        "for-direction": "off",
+    // disable rules from base configurations
+    "for-direction": "off",
 
-        "@typescript-eslint/no-explicit-any": "warn",
-        "@typescript-eslint/ban-ts-comment": "off"
-    }
+    "@typescript-eslint/no-explicit-any": "warn",
+    "@typescript-eslint/ban-ts-comment": "off",
+  },
 };

desktop-extensions/gnome-45/.prettierignore

@@ -0,0 +1,13 @@
+# Generated files
+/@types/gir-generated/*
+
+# Build outputes
+/dist/
+/build/
+
+# Node configuration and modules
+/package.json
+/node_modules/
+
+# Files I prefer not to be formatted
+*.md

desktop-extensions/gnome-45/.prettierrc.json

@@ -0,0 +1,9 @@
+{
+  "printWidth": 100,
+  "useTabs": false,
+  "semi": true,
+  "singleQuote": false,
+  "trailingComma": "all",
+  "bracketSpacing": true,
+  "arrowParens": "always"
+}

desktop-extensions/gnome-45/esbuild.js

@@ -1,13 +1,14 @@
-const { build } = require("esbuild");
-const fs = require("fs");
-const path = require("path");
-var exec = require('child_process').exec;
-const AdmZip = require("adm-zip");
-const metadata = require("./src/metadata.json");
+import { build } from "esbuild";
+import { exec } from "child_process";
+import { copyFileSync, cpSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import AdmZip from "adm-zip";
+import metadata from "./src/metadata.json" assert { type: "json" };
 
 build({
-  entryPoints: ['src/extension.ts'],
-  outdir: 'dist',
+  entryPoints: ["src/extension.ts"],
+  outdir: "dist",
   bundle: true,
   // Do not remove the functions `enable()`, `disable()` and `init()`
   treeShaking: false,
@@ -17,49 +18,50 @@ build({
   // firefox91  // Since GJS 1.71.1
   // firefox102 // Since GJS 1.73.2
   target: "firefox102",
+  //platform: "neutral",
   platform: "node",
-  // platform: "neutral",
   // mainFields: ['main'],
   // conditions: ['require', 'default'],
-  format: 'esm',
-  external: ['gi://*', 'resource:///*', 'system', 'gettext', 'cairo'],
+  format: "esm",
+  external: ["gi://*", "resource://*", "system", "gettext", "cairo"],
 }).then(() => {
-  const metaSrc = path.resolve(__dirname, "src/metadata.json");
-  const metaDist = path.resolve(__dirname, "dist/metadata.json");
-  const schemaSrc = path.resolve(__dirname, "schemas");
-  const schemaDist = path.resolve(__dirname, "dist/schemas");
-  const dbusXmlSrc = path.resolve(__dirname, "../../bindings/dbus-xml");
-  const dbusXmlDist = path.resolve(__dirname, "dist/resources/dbus");
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+
+  const metaSrc = resolve(__dirname, "src/metadata.json");
+  const metaDist = resolve(__dirname, "dist/metadata.json");
+  const schemaSrc = resolve(__dirname, "schemas");
+  const schemaDist = resolve(__dirname, "dist/schemas");
+  const dbusXmlSrc = resolve(__dirname, "../../bindings/dbus-xml");
+  const dbusXmlDist = resolve(__dirname, "dist/resources/dbus");
   const zipFilename = `${metadata.uuid}.zip`;
-  const zipDist = path.resolve(__dirname, zipFilename);
+  const zipDist = resolve(__dirname, zipFilename);
 
-  exec('glib-compile-schemas schemas/',
-    (error, stdout, stderr) => {
-      console.log('stdout: ' + stdout);
-      console.log('stderr: ' + stderr);
-    });
+  exec("glib-compile-schemas schemas/", (error, stdout, stderr) => {
+    console.log("stdout: " + stdout);
+    console.log("stderr: " + stderr);
+  });
 
-  fs.copyFileSync(metaSrc, metaDist);
+  copyFileSync(metaSrc, metaDist);
 
-  fs.cpSync(schemaSrc, schemaDist, { recursive: true }, (err) => {
+  cpSync(schemaSrc, schemaDist, { recursive: true }, (err) => {
     if (err) {
       console.error(err);
     }
   });
 
-  fs.cpSync(dbusXmlSrc, dbusXmlDist, { recursive: true }, (err) => {
+  cpSync(dbusXmlSrc, dbusXmlDist, { recursive: true }, (err) => {
     if (err) {
       console.error(err);
     }
   });
 
   const zip = new AdmZip();
-  zip.addLocalFolder(path.resolve(__dirname, "dist"));
+  zip.addLocalFolder(resolve(__dirname, "dist"));
   zip.writeZip(zipDist);
 
   console.log(`Build complete. Zip file: ${zipFilename}\n`);
-  console.log(`Install with: gnome-extensions install ${zipFilename}`)
-  console.log(`Update with: gnome-extensions install ${zipFilename} --force`)
-  console.log(`Enable with: gnome-extensions enable ${metadata.uuid} --user`)
+  console.log(`Install with: gnome-extensions install ${zipFilename}`);
+  console.log(`Update with: gnome-extensions install ${zipFilename} --force`);
+  console.log(`Enable with: gnome-extensions enable ${metadata.uuid} --user`);
 });
-

desktop-extensions/gnome-45/package.json

@@ -1,21 +1,36 @@
 {
   "name": "asusctl-gnome",
-  "version": "4.7.0",
+  "version": "5.0.0-RC1",
   "description": "asusctl-gnome a gnome extension exposing some of the base features of asusd in a helpful and easy to use way",
+  "type": "module",
   "main": "dist/extension.js",
   "scripts": {
     "clear": "rm -rf dist",
+    "compile": "tsc --build tsconfig.json",
     "build:app": "node esbuild.js",
     "build": "yarn run clear && yarn run build:app",
-    "validate": "tsc --noEmit"
+    "validate": "tsc --noEmit",
+    "generate:gir-types": "ts-for-gir generate",
+    "check:types": "tsc --build tsconfig.types.json",
+    "lint": "eslint .",
+    "format": "prettier . -w"
   },
   "devDependencies": {
+    "@girs/gnome-shell": "^45.0.0-beta2",
     "@typescript-eslint/eslint-plugin": "^5.60.1",
     "@typescript-eslint/parser": "^5.60.1",
     "adm-zip": "^0.5.10",
-    "esbuild": "^0.17.19",
-    "eslint": "^8.44.0",
-    "typescript": "^5.1.6"
+    "esbuild": "^0.19.5",
+    "eslint": "^8.51.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "prettier": "^3.0.3",
+    "typescript": "^5.2.2"
+  },
+  "dependencies": {
+    "@girs/gjs": "^3.2.5",
+    "@girs/gobject-2.0": "^2.78.0-3.2.5",
+    "@girs/st-13": "^13.0.0-3.2.5"
   },
   "repository": {
     "type": "git",

desktop-extensions/gnome-45/schemas/org.gnome.shell.extensions.asusctl-gnome.gschema.xml

@@ -10,6 +10,9 @@
     <key type="b" name="anime-power">
       <default>false</default>
     </key>
+    <key type="b" name="anime-builtins">
+      <default>false</default>
+    </key>
     <key name="charge-level" type="u">
       <range min="20" max="100"/>
       <default>100</default>

desktop-extensions/gnome-45/src/extension.ts

@@ -1,117 +1,127 @@
-import {Extension, gettext as _} from 'resource:///org/gnome/shell/extensions/extension.js';
-
-import { AnimeDbus } from "./modules/dbus/animatrix";
-import { Power } from "./modules/dbus/power";
-import { Supported } from "./modules/dbus/supported";
-import { Platform } from "./modules/dbus/platform";
-
-import { QuickPanelOd } from "./modules/quick_toggles/panel_od";
-import { IndicateMiniLed } from "./modules/indicators/mini_led";
-import { QuickMiniLed } from "./modules/quick_toggles/mini_led";
-import { SliderChargeLevel } from "./modules/sliders/charge";
-import { QuickAnimePower } from "./modules/quick_toggles/anime_power";
+import { Extension, gettext as _ } from "@girs/gnome-shell/extensions/extension";
+import * as platform from "./bindings/platform";
+import { AsusQuickToggle } from "./modules/rog_quick_toggle";
+import { AsusMenuToggle } from "./modules/rog_menu_toggle";
+import { AsusIndicator } from "./modules/rog_indicator";
+import { AsusSlider } from "./modules/rog_slider_100pc";
 import { FeatureMenuToggle } from "./modules/quick_menus/laptop_features";
-import { AuraDbus } from "./modules/dbus/aura";
-import { AuraMenuToggle } from "./modules/quick_menus/aura";
-
-export var extension;
+import { DbusBase } from "./modules/dbus_proxy";
+import { main } from "@girs/gnome-shell/ui";
 
+export const uuid = "asusctl-gnome@asus-linux.org";
 export default class AsusExtension extends Extension {
-    private _indicateMiniLed: typeof IndicateMiniLed;
-    private _quickMiniLed: typeof QuickMiniLed;
-    private _quickPanelOd: typeof QuickPanelOd;
-    private _quickAnimePower: typeof QuickAnimePower;
-    private _featureMenuToggle: typeof FeatureMenuToggle;
-    private _auraModeMenuToggle: typeof AuraMenuToggle;
-    private _sliderCharge: typeof SliderChargeLevel;
+  // public dbus_aura: AuraDbus = new AuraDbus;
+  // public dbus_anime: AnimeDbus = new AnimeDbus;
+  public dbus_platform: DbusBase | undefined;
+  public dbus_anime: DbusBase | undefined;
 
-    public dbus_supported: Supported = new Supported;
-    public dbus_power: Power = new Power;
-    public dbus_aura: AuraDbus = new AuraDbus;
-    public dbus_anime: AnimeDbus = new AnimeDbus;
-    public dbus_platform: Platform = new Platform;
-    public extensionPath: any = null;
+  private individual = false;
+  public supported_properties!: platform.Properties;
+  public supported_interfaces: string[] = [];
+  private feature_menu = null;
+  private panel_od = null;
+  private mini_led = null;
+  private anime_display = null;
+  private anime_builtins = null;
+  private charge_thres = null;
+  // private _feature: typeof FeatureMenuToggle;
 
-    settings() {
-        return this._settings;
+  async enable() {
+    log(this.path);
+
+    if (this.dbus_platform == undefined) {
+      this.dbus_platform = new DbusBase("org-asuslinux-platform-4.xml", "/org/asuslinux/Platform");
+      await this.dbus_platform.start();
     }
 
-    async enable() {
-        this._settings = this.getSettings();
-        this.extensionPath = this.path;
-        extension = this;
+    if (this.dbus_anime == undefined) {
+      this.dbus_anime = new DbusBase("org-asuslinux-anime-4.xml", "/org/asuslinux/Anime");
+      await this.dbus_anime.start();
+    }
 
-        this._indicateMiniLed = null;
-        this._quickMiniLed = null;
-        this._quickPanelOd = null;
-        this._quickAnimePower = null;
-        this._sliderCharge = null;
+    this.supported_interfaces = this.dbus_platform?.proxy.SupportedInterfacesSync()[0];
+    this.supported_properties = this.dbus_platform?.proxy.SupportedPropertiesSync()[0];
+    log(this.supported_interfaces);
+    log(this.supported_properties);
 
-        await this.dbus_supported.start();
-        await this.dbus_aura.start();
-        await this.dbus_platform.start();
-        await this.dbus_power.start();
-        await this.dbus_anime.start();
+    // new AsusIndicator("selection-mode-symbolic", "mini-led-enabled");
+    // new AsusIndicator("selection-mode-symbolic", "panel-od-enabled");
 
-        if (this._featureMenuToggle == null) {
-            this._featureMenuToggle = new FeatureMenuToggle(this.dbus_supported, this.dbus_platform, this.dbus_anime);
+    if (!this.individual) {
+      if (this.feature_menu == null)
+        this.feature_menu = new FeatureMenuToggle(this.dbus_platform, this.dbus_anime);
+    } else {
+      if (this.supported_properties.includes("PanelOd") && this.dbus_platform.proxy.PanelOd != null)
+        if (this.panel_od == null) {
+          this.panel_od = new AsusQuickToggle(
+            this.dbus_platform,
+            "PanelOd",
+            "panel-od-enabled",
+            "Panel Overdrive",
+          );
         }
-        if (this._auraModeMenuToggle == null) {
-            this._auraModeMenuToggle = new AuraMenuToggle(this.dbus_aura);
+
+      if (this.supported_properties.includes("MiniLed") && this.dbus_platform.proxy.MiniLed != null)
+        if (this.mini_led == null) {
+          this.mini_led = new AsusQuickToggle(
+            this.dbus_platform,
+            "MiniLed",
+            "mini-led-enabled",
+            "Mini-LED",
+          );
         }
-        if (this.dbus_supported.supported.rog_bios_ctrl.mini_led_mode) {
-            // if (this._quickMiniLed == null) {
-            //     this._quickMiniLed = new QuickMiniLed(this.dbus_platform);
-            //     this.dbus_platform.notifyMiniLedSubscribers.push(this._quickMiniLed);
-            // }
-            if (this._indicateMiniLed == null) {
-                this._indicateMiniLed = new IndicateMiniLed(this.dbus_platform);
-            }
+
+      if (
+        this.supported_interfaces.includes("Anime") &&
+        this.dbus_anime.proxy.EnableDisplay != null
+      )
+        if (this.anime_display == null) {
+          this.anime_display = new AsusQuickToggle(
+            this.dbus_anime,
+            "EnableDisplay",
+            "anime-power",
+            "AniMe Display",
+          );
         }
-        // if (this.dbus_supported.supported.rog_bios_ctrl.panel_overdrive) {
-        //     if (this._quickPanelOd == null) {
-        //         this._quickPanelOd = new QuickPanelOd(this.dbus_platform);
-        //         this.dbus_platform.notifyPanelOdSubscribers.push(this._quickPanelOd);
-        //     }
-        // }
-        // if (this.dbus_supported.supported.anime_ctrl) {
-        //     if (this._quickAnimePower == null) {
-        //         this._quickAnimePower = new QuickAnimePower(this._dbus_anime);
-        //     }
-        // }
-        if (this.dbus_supported.supported.charge_ctrl.charge_level_set) {
-            if (this._sliderCharge == null) {
-                this._sliderCharge = new SliderChargeLevel(this.dbus_power);
-            }
+
+      if (
+        this.supported_interfaces.includes("Anime") &&
+        this.dbus_anime.proxy.BuiltinsEnabled != null
+      )
+        if (this.anime_builtins == null) {
+          this.anime_builtins = new AsusQuickToggle(
+            this.dbus_anime,
+            "BuiltinsEnabled",
+            "anime-builtins",
+            "Use builtins",
+          );
         }
     }
 
-    disable() {
-        if (this._indicateMiniLed != null) {
-            this._indicateMiniLed.destroy();
-            this._indicateMiniLed = null;
-        }
-        if (this._quickMiniLed != null) {
-            this._quickMiniLed.destroy();
-            this._quickMiniLed = null;
-        }
-        if (this._quickPanelOd != null) {
-            this._quickPanelOd.destroy();
-            this._quickPanelOd = null;
-        }
-        if (this._quickAnimePower != null) {
-            this._quickAnimePower.destroy();
-            this._quickAnimePower = null;
-        }
-        if (this._sliderCharge != null) {
-            this._sliderCharge.destroy();
-            this._sliderCharge = null;
-        }
+    if (
+      this.supported_properties.includes("ChargeControlEndThreshold") &&
+      this.dbus_platform.proxy.ChargeControlEndThreshold != null
+    )
+      if (this.charge_thres == null) {
+        this.charge_thres = new AsusSlider(
+          this.dbus_platform,
+          "ChargeControlEndThreshold",
+          "charge-level",
+          "Charge Level",
+        );
+      }
+  }
 
-        this.dbus_power.stop();
-        this.dbus_platform.stop();
-        // this.dbus_anime.stop();
-        this.dbus_aura.stop();
-        this.dbus_supported.stop();
-    }
-}
+  disable() {
+    this.dbus_platform?.stop();
+    this.dbus_anime?.stop();
+
+    this.feature_menu?.destroy();
+    feature_menu?.destroy();
+    panel_od?.destroy();
+    mini_led?.destroy();
+    anime_display?.destroy();
+    anime_builtins?.destroy();
+    charge_thres?.destroy();
+  }
+}

desktop-extensions/gnome-45/src/metadata.json

@@ -5,7 +5,5 @@
   "uuid-dev": "asusctl-gnome-dev@asus-linux.org",
   "settings-schema": "org.gnome.shell.extensions.asusctl-gnome",
   "version": "4.3.2",
-  "shell-version": [
-    "43", "44", "45"
-  ]
+  "shell-version": ["45"]
 }

desktop-extensions/gnome-45/src/modules/dbus/animatrix.ts

@@ -1,119 +1,98 @@
-import { DbusBase } from "./base";
-import { DeviceState, AnimBooting, Brightness, AnimAwake, AnimSleeping, AnimShutdown } from "../../bindings/anime";
+import { DbusBase } from "../dbus_proxy";
+import {
+  DeviceState,
+  AnimBooting,
+  Brightness,
+  AnimAwake,
+  AnimSleeping,
+  AnimShutdown,
+} from "../../bindings/anime";
 
 export class AnimeDbus extends DbusBase {
-    deviceState: DeviceState = {
-        display_enabled: false,
-        display_brightness: Brightness.Med,
-        builtin_anims_enabled: false,
-        builtin_anims: {
-            boot: AnimBooting.GlitchConstruction,
-            awake: AnimAwake.BinaryBannerScroll,
-            sleep: AnimSleeping.BannerSwipe,
-            shutdown: AnimShutdown.GlitchOut
-        },
-    };
+  deviceState: DeviceState = {
+    display_enabled: false,
+    display_brightness: Brightness.Med,
+    builtin_anims_enabled: false,
+    builtin_anims: {
+      boot: AnimBooting.GlitchConstruction,
+      awake: AnimAwake.BinaryBannerScroll,
+      sleep: AnimSleeping.BannerSwipe,
+      shutdown: AnimShutdown.GlitchOut,
+    },
+    off_when_unplugged: false,
+    off_when_suspended: false,
+    off_when_lid_closed: false,
+  };
 
-    // TODO: interface or something to enforce requirement of "sync()" method
-    public notifyAnimeStateSubscribers: any[] = [];
+  // TODO: interface or something to enforce requirement of "sync()" method
+  public notifyAnimeStateSubscribers: any[] = [];
 
-    constructor() {
-        super("org-asuslinux-anime-4", "/org/asuslinux/Anime");
+  constructor() {
+    super("org-asuslinux-anime-4", "/org/asuslinux/Anime");
+  }
+
+  _parseData(data: any) {
+    if (data.length > 0) {
+      this.deviceState.display_enabled = data[0];
+      this.deviceState.display_brightness = Brightness[data[1] as Brightness];
+      this.deviceState.builtin_anims_enabled = data[2];
+      this.deviceState.builtin_anims.boot = AnimBooting[data[3][0] as AnimBooting];
+      this.deviceState.builtin_anims.awake = AnimAwake[data[3][1] as AnimAwake];
+      this.deviceState.builtin_anims.sleep = AnimSleeping[data[3][2] as AnimSleeping];
+      this.deviceState.builtin_anims.shutdown = AnimShutdown[data[3][3] as AnimShutdown];
+      this.deviceState.off_when_unplugged = data[4];
+      this.deviceState.off_when_suspended = data[5];
+      this.deviceState.off_when_lid_closed = data[6];
     }
+  }
 
-    public setEnableDisplay(state: boolean | null) {
-        if (this.isRunning()) {
-            try {
-                // if null, toggle the current state
-                state = (state == null ? !this.deviceState.display_enabled : state);
+  public getDeviceState() {
+    if (this.isRunning()) {
+      try {
+        // janky shit going on with DeviceStateSync
+        this._parseData(this.dbus_proxy.DeviceStateSync());
+        //@ts-ignore
+        log("Anime Matrix: display_enabled: " + this.deviceState.display_enabled);
+        //@ts-ignore
+        log("Anime Matrix: display_brightness: " + this.deviceState.display_brightness);
+        //@ts-ignore
+        log("Anime Matrix: builtin_anims_enabled: " + this.deviceState.builtin_anims_enabled);
+        //@ts-ignore
+        log("Anime Matrix: builtin_anims: " + this.deviceState.builtin_anims);
+        //@ts-ignore
+        log("Anime Matrix: off_when_unplugged: " + this.deviceState.off_when_unplugged);
+        //@ts-ignore
+        log("Anime Matrix: off_when_suspended: " + this.deviceState.off_when_suspended);
+        //@ts-ignore
+        log("Anime Matrix: off_when_lid_closed: " + this.deviceState.off_when_lid_closed);
+      } catch (e) {
+        //@ts-ignore
+        log("Failed to fetch DeviceState!", e);
+      }
+    }
+    return this.deviceState;
+  }
 
-                if (this.deviceState.display_enabled !== state) {
-                    this.deviceState.display_enabled = state;
-                }
-                return this.dbus_proxy.SetEnableDisplaySync(state);
-            } catch (e) {
-                //@ts-ignore
-                log("AniMe DBus set power failed!", e);
-            }
+  async start() {
+    await super.start();
+    this.getDeviceState();
+
+    this.dbus_proxy.connectSignal(
+      "NotifyDeviceState",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (proxy: any = null, name: string, data: string) => {
+        if (proxy) {
+          // idiot xml parsing mneans the get is not nested while this is
+          this._parseData(data[0]);
+          this.notifyAnimeStateSubscribers.forEach((sub) => {
+            sub.sync();
+          });
         }
-    }
+      },
+    );
+  }
 
-    public setPowersaveAnim(state: boolean | null) {
-        if (this.isRunning()) {
-            try {
-                // if null, toggle the current state
-                state = (state == null ? !this.deviceState.builtin_anims_enabled : state);
-
-                if (this.deviceState.builtin_anims_enabled !== state) {
-                    this.deviceState.builtin_anims_enabled = state;
-                }
-                return this.dbus_proxy.SetEnableBuiltinsSync(state);
-            } catch (e) {
-                //@ts-ignore
-                log("AniMe DBus set builtins failed!", e);
-            }
-        }
-    }
-
-    public setBrightness(brightness: Brightness) {
-        if (this.isRunning()) {
-            try {
-                if (this.deviceState.display_brightness !== brightness) {
-                    this.deviceState.display_brightness = brightness;
-                }
-                return this.dbus_proxy.SetBrightnessSync(brightness);
-            } catch (e) {
-                //@ts-ignore
-                log("AniMe DBus set brightness failed!", e);
-            }
-        }
-    }
-
-    _parseData(data: any) {
-        if (data.length > 0) {
-            this.deviceState.display_enabled = data[0];
-            this.deviceState.display_brightness = Brightness[data[1] as Brightness];
-            this.deviceState.builtin_anims_enabled = data[2];
-            this.deviceState.builtin_anims.boot = AnimBooting[data[3][0] as AnimBooting];
-            this.deviceState.builtin_anims.awake = AnimAwake[data[3][1] as AnimAwake];
-            this.deviceState.builtin_anims.sleep = AnimSleeping[data[3][2] as AnimSleeping];
-            this.deviceState.builtin_anims.shutdown = AnimShutdown[data[3][2] as AnimShutdown];
-        }
-    }
-
-    public getDeviceState() {
-        if (this.isRunning()) {
-            try {
-                // janky shit going on with DeviceStateSync
-                this._parseData(this.dbus_proxy.DeviceStateSync());
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to fetch DeviceState!", e);
-            }
-        }
-        return this.deviceState;
-    }
-
-    async start() {
-        await super.start();
-        this.getDeviceState();
-
-        this.dbus_proxy.connectSignal(
-            "NotifyDeviceState",
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            (proxy: any = null, name: string, data: string) => {
-                if (proxy) {
-                    // idiot xml parsing mneans the get is not nested while this is
-                    this._parseData(data[0]);
-                    this.notifyAnimeStateSubscribers.forEach(sub => {
-                        sub.sync();
-                    });
-                }
-            }
-        );
-    }
-
-    async stop() {
-        await super.stop();
-    }
-}
+  async stop() {
+    await super.stop();
+  }
+}

desktop-extensions/gnome-45/src/modules/dbus/aura.ts

@@ -1,284 +1,300 @@
-import { AuraDevRog1, AuraDevTuf, AuraDevice, AuraEffect, AuraModeNum, AuraPower, AuraPowerDev, AuraZone, Direction, PowerZones, Speed } from "../../bindings/aura";
+import {
+  AuraDevRog1,
+  AuraDevTuf,
+  AuraDevice,
+  AuraEffect,
+  AuraModeNum,
+  AuraPower,
+  AuraPowerDev,
+  AuraZone,
+  Direction,
+  PowerZones,
+  Speed,
+} from "../../bindings/aura";
 import { DbusBase } from "./base";
 
 export class AuraDbus extends DbusBase {
-    public device: AuraDevice = AuraDevice.Unknown;
-    public current_aura_mode: AuraModeNum = AuraModeNum.Static;
-    public aura_modes: Map<AuraModeNum, AuraEffect> = new Map;
-    public leds_powered: AuraPowerDev = {
-        tuf: [],
-        old_rog: [],
-        rog: {
-            keyboard: {
-                zone: PowerZones.Keyboard,
-                boot: false,
-                awake: false,
-                sleep: false,
-                shutdown: false
-            },
-            logo: {
-                zone: PowerZones.Logo,
-                boot: false,
-                awake: false,
-                sleep: false,
-                shutdown: false
-            },
-            lightbar: {
-                zone: PowerZones.Lightbar,
-                boot: false,
-                awake: false,
-                sleep: false,
-                shutdown: false
-            },
-            lid: {
-                zone: PowerZones.Lid,
-                boot: false,
-                awake: false,
-                sleep: false,
-                shutdown: false
-            },
-            rear_glow: {
-                zone: PowerZones.RearGlow,
-                boot: false,
-                awake: false,
-                sleep: false,
-                shutdown: false
-            },
-        }
+  public device: AuraDevice = AuraDevice.Unknown;
+  public current_aura_mode: AuraModeNum = AuraModeNum.Static;
+  public aura_modes: Map<AuraModeNum, AuraEffect> = new Map();
+  public leds_powered: AuraPowerDev = {
+    tuf: [],
+    old_rog: [],
+    rog: {
+      keyboard: {
+        zone: PowerZones.Keyboard,
+        boot: false,
+        awake: false,
+        sleep: false,
+        shutdown: false,
+      },
+      logo: {
+        zone: PowerZones.Logo,
+        boot: false,
+        awake: false,
+        sleep: false,
+        shutdown: false,
+      },
+      lightbar: {
+        zone: PowerZones.Lightbar,
+        boot: false,
+        awake: false,
+        sleep: false,
+        shutdown: false,
+      },
+      lid: {
+        zone: PowerZones.Lid,
+        boot: false,
+        awake: false,
+        sleep: false,
+        shutdown: false,
+      },
+      rear_glow: {
+        zone: PowerZones.RearGlow,
+        boot: false,
+        awake: false,
+        sleep: false,
+        shutdown: false,
+      },
+    },
+  };
+  // TODO: interface or something to enforce requirement of "sync()" method
+  public notifyAuraModeSubscribers: any[] = [];
+  public notifyAuraPowerSubscribers: any[] = [];
+
+  constructor() {
+    super("org-asuslinux-aura-4", "/org/asuslinux/Aura");
+  }
+
+  public getDevice() {
+    if (this.isRunning()) {
+      try {
+        this.device = AuraDevice[this.dbus_proxy.DeviceTypeSync() as AuraDevice];
+        //@ts-ignore
+        log("LED device: " + this.device);
+      } catch (e) {
+        //@ts-ignore
+        log("Failed to fetch supported functionalities", e);
+      }
+    }
+  }
+
+  _parsePowerStates(data: any[]) {
+    const power: AuraPowerDev = this.leds_powered;
+
+    power.tuf = data[0].map((value: string) => {
+      return AuraDevTuf[value as AuraDevTuf];
+    });
+    power.old_rog = data[1].map((value: string) => {
+      return AuraDevRog1[value as AuraDevRog1];
+    });
+    power.rog = {
+      keyboard: {
+        zone: PowerZones[data[2][0][0] as PowerZones],
+        boot: data[2][0][1],
+        awake: data[2][0][2],
+        sleep: data[2][0][3],
+        shutdown: data[2][0][4],
+      },
+      logo: {
+        zone: PowerZones[data[2][1][0] as PowerZones],
+        boot: data[2][1][1],
+        awake: data[2][1][2],
+        sleep: data[2][1][3],
+        shutdown: data[2][1][4],
+      },
+      lightbar: {
+        zone: PowerZones[data[2][2][0] as PowerZones],
+        boot: data[2][2][1],
+        awake: data[2][2][2],
+        sleep: data[2][2][3],
+        shutdown: data[2][2][4],
+      },
+      lid: {
+        zone: PowerZones[data[2][3][0] as PowerZones],
+        boot: data[2][3][1],
+        awake: data[2][3][2],
+        sleep: data[2][3][3],
+        shutdown: data[2][3][4],
+      },
+      rear_glow: {
+        zone: PowerZones[data[2][4][0] as PowerZones],
+        boot: data[2][4][1],
+        awake: data[2][4][2],
+        sleep: data[2][4][3],
+        shutdown: data[2][4][4],
+      },
     };
-    // TODO: interface or something to enforce requirement of "sync()" method
-    public notifyAuraModeSubscribers: any[] = [];
-    public notifyAuraPowerSubscribers: any[] = [];
 
-    constructor() {
-        super("org-asuslinux-aura-4", "/org/asuslinux/Aura");
+    return power;
+  }
+
+  public getLedPower() {
+    if (this.isRunning()) {
+      try {
+        const data = this.dbus_proxy.LedPowerSync();
+        this.leds_powered = this._parsePowerStates(data);
+        //@ts-ignore
+        log("LED power tuf: " + this.leds_powered.tuf);
+        //@ts-ignore
+        log("LED power x1866: " + this.leds_powered.old_rog);
+        //@ts-ignore
+        log("LED power x19b6: " + this.leds_powered.rog);
+      } catch (e) {
+        //@ts-ignore
+        log("Failed to fetch supported functionalities", e);
+      }
     }
+  }
 
-    public getDevice() {
-        if (this.isRunning()) {
-            try {
-                this.device = AuraDevice[this.dbus_proxy.DeviceTypeSync() as AuraDevice];
-                //@ts-ignore
-                log("LED device: " + this.device);
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to fetch supported functionalities", e);
-            }
+  public getLedMode() {
+    if (this.isRunning()) {
+      try {
+        this.current_aura_mode = AuraModeNum[this.dbus_proxy.LedModeSync() as AuraModeNum];
+        //@ts-ignore
+        log("Current LED mode:", this.current_aura_mode);
+      } catch (e) {
+        //@ts-ignore
+        log("Failed to fetch supported functionalities", e);
+      }
+    }
+  }
+
+  public setLedMode(mode: AuraEffect) {
+    if (this.isRunning()) {
+      try {
+        this.dbus_proxy.SetLedModeSync([
+          mode.mode,
+          mode.zone,
+          [mode.colour1.r, mode.colour1.g, mode.colour1.b],
+          [mode.colour2.r, mode.colour2.g, mode.colour2.b],
+          mode.speed,
+          mode.direction,
+        ]);
+      } catch (e) {
+        //@ts-ignore
+        log("Failed to fetch supported functionalities", e);
+      }
+    }
+  }
+
+  _parseAuraEffect(data: any[]) {
+    const aura: AuraEffect = {
+      mode: AuraModeNum[data[0] as AuraModeNum],
+      zone: AuraZone[data[1] as AuraZone],
+      colour1: {
+        r: parseInt(data[2][0]),
+        g: parseInt(data[2][1]),
+        b: parseInt(data[2][2]),
+      },
+      colour2: {
+        r: parseInt(data[3][0]),
+        g: parseInt(data[3][1]),
+        b: parseInt(data[3][2]),
+      },
+      speed: Speed[data[4] as Speed],
+      direction: Direction[data[5] as Direction],
+    };
+    return aura;
+  }
+
+  // Return a list of the available modes, and the current settings for each
+  public getLedModes() {
+    // {'Breathe': ('Breathe', 'None', (166, 0, 0), (0, 0, 0), 'Med', 'Right'),
+    // 'Comet': ('Comet', 'None', (166, 0, 0), (0, 0, 0), 'Med', 'Right'),
+    // 'Static': ('Static', 'None', (78, 0, 0), (0, 0, 0), 'Med', 'Right'),
+    // 'Strobe': ('Strobe', 'None', (166, 0, 0), (0, 0, 0), 'Med', 'Right')}
+    if (this.isRunning()) {
+      try {
+        const _data = this.dbus_proxy.LedModesSync();
+        for (const key in _data[0]) {
+          const data = _data[0][key];
+          const aura: AuraEffect = this._parseAuraEffect(data);
+          this.aura_modes.set(AuraModeNum[key as AuraModeNum], aura);
         }
-    }
 
-    _parsePowerStates(data: any[]) {
-        const power: AuraPowerDev = this.leds_powered;
-
-        power.tuf = data[0].map((value: string) => {
-            return AuraDevTuf[value as AuraDevTuf];
-        });
-        power.old_rog = data[1].map((value: string) => {
-            return AuraDevRog1[value as AuraDevRog1];
-        });
-        power.rog = {
-            keyboard: {
-                zone: PowerZones[data[2][0][0] as PowerZones],
-                boot: data[2][0][1],
-                awake: data[2][0][2],
-                sleep: data[2][0][3],
-                shutdown: data[2][0][4]
-            },
-            logo: {
-                zone: PowerZones[data[2][1][0] as PowerZones],
-                boot: data[2][1][1],
-                awake: data[2][1][2],
-                sleep: data[2][1][3],
-                shutdown: data[2][1][4]
-            },
-            lightbar: {
-                zone: PowerZones[data[2][2][0] as PowerZones],
-                boot: data[2][2][1],
-                awake: data[2][2][2],
-                sleep: data[2][2][3],
-                shutdown: data[2][2][4]
-            },
-            lid: {
-                zone: PowerZones[data[2][3][0] as PowerZones],
-                boot: data[2][3][1],
-                awake: data[2][3][2],
-                sleep: data[2][3][3],
-                shutdown: data[2][3][4]
-            },
-            rear_glow: {
-                zone: PowerZones[data[2][4][0] as PowerZones],
-                boot: data[2][4][1],
-                awake: data[2][4][2],
-                sleep: data[2][4][3],
-                shutdown: data[2][4][4]
-            }
-        };
-
-        return power;
-    }
-
-    public getLedPower() {
-        if (this.isRunning()) {
-            try {
-                const data = this.dbus_proxy.LedPowerSync();
-                this.leds_powered = this._parsePowerStates(data);
-                //@ts-ignore
-                log("LED power tuf: " + this.leds_powered.tuf);
-                //@ts-ignore
-                log("LED power x1866: " + this.leds_powered.old_rog);
-                //@ts-ignore
-                log("LED power x19b6: " + this.leds_powered.rog);
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to fetch supported functionalities", e);
-            }
+        for (const [key, value] of this.aura_modes) {
+          //@ts-ignore
+          log(key, value.zone, value.colour1.r, value.speed, value.direction);
         }
+      } catch (e) {
+        //@ts-ignore
+        log("Failed to fetch supported functionalities", e);
+      }
     }
+  }
 
-    public getLedMode() {
-        if (this.isRunning()) {
-            try {
-                this.current_aura_mode = AuraModeNum[this.dbus_proxy.LedModeSync() as AuraModeNum];
-                //@ts-ignore
-                log("Current LED mode:", this.current_aura_mode);
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to fetch supported functionalities", e);
-            }
+  async start() {
+    try {
+      await super.start();
+      this.getDevice();
+      this.getLedPower();
+      this.getLedMode();
+      this.getLedModes();
+
+      //@ts-ignore
+      log("Current LED mode data:", this.aura_modes.get(this.current_aura_mode)?.speed);
+
+      this.dbus_proxy.connectSignal("NotifyLed", (proxy: any = null, name: string, data: any) => {
+        if (proxy) {
+          const aura: AuraEffect = this._parseAuraEffect(data[0]);
+          this.current_aura_mode = aura.mode;
+          this.aura_modes.set(aura.mode, aura);
+          //@ts-ignore
+          log(
+            "LED data has changed to ",
+            aura.mode,
+            aura.zone,
+            aura.colour1.r,
+            aura.speed,
+            aura.direction,
+          );
+          this.notifyAuraModeSubscribers.forEach((sub) => {
+            sub.sync();
+          });
         }
-    }
+      });
 
-    public setLedMode(mode: AuraEffect) {
-        if (this.isRunning()) {
-            try {
-                this.dbus_proxy.SetLedModeSync([
-                    mode.mode,
-                    mode.zone,
-                    [mode.colour1.r, mode.colour1.g, mode.colour1.b],
-                    [mode.colour2.r, mode.colour2.g, mode.colour2.b],
-                    mode.speed,
-                    mode.direction]);
-            } catch (e) {
+      this.dbus_proxy.connectSignal(
+        "NotifyPowerStates",
+        (proxy: any = null, name: string, data: any) => {
+          if (proxy) {
+            const power: AuraPowerDev = this._parsePowerStates(data[0]);
+            this.leds_powered = power;
+            switch (this.device) {
+              case AuraDevice.Tuf:
                 //@ts-ignore
-                log("Failed to fetch supported functionalities", e);
-            }
-        }
-    }
-
-    _parseAuraEffect(data: any[]) {
-        const aura: AuraEffect = {
-            mode: AuraModeNum[data[0] as AuraModeNum],
-            zone: AuraZone[data[1] as AuraZone],
-            colour1: {
-                r: parseInt(data[2][0]),
-                g: parseInt(data[2][1]),
-                b: parseInt(data[2][2]),
-            },
-            colour2: {
-                r: parseInt(data[3][0]),
-                g: parseInt(data[3][1]),
-                b: parseInt(data[3][2]),
-            },
-            speed: Speed[data[4] as Speed],
-            direction: Direction[data[5] as Direction],
-        };
-        return aura;
-    }
-
-    // Return a list of the available modes, and the current settings for each
-    public getLedModes() {
-        // {'Breathe': ('Breathe', 'None', (166, 0, 0), (0, 0, 0), 'Med', 'Right'),
-        // 'Comet': ('Comet', 'None', (166, 0, 0), (0, 0, 0), 'Med', 'Right'),
-        // 'Static': ('Static', 'None', (78, 0, 0), (0, 0, 0), 'Med', 'Right'),
-        // 'Strobe': ('Strobe', 'None', (166, 0, 0), (0, 0, 0), 'Med', 'Right')}
-        if (this.isRunning()) {
-            try {
-                const _data = this.dbus_proxy.LedModesSync();
-                for (const key in _data[0]) {
-                    const data = _data[0][key];
-                    const aura: AuraEffect = this._parseAuraEffect(data);
-                    this.aura_modes.set(AuraModeNum[key as AuraModeNum], aura);
-                }
-
-                for (const [key, value] of this.aura_modes) {
-                    //@ts-ignore
-                    log(key, value.zone, value.colour1.r, value.speed, value.direction);
-                }
-
-            } catch (e) {
+                log("LED power has changed to ", this.leds_powered.tuf);
+                break;
+              case AuraDevice.X1854:
+              case AuraDevice.X1869:
+              case AuraDevice.X18c6:
                 //@ts-ignore
-                log("Failed to fetch supported functionalities", e);
+                log("LED power has changed to ", this.leds_powered.old_rog);
+                break;
+              case AuraDevice.X19b6:
+              case AuraDevice.X1a30:
+                //@ts-ignore
+                log("LED power has changed to ", this.leds_powered.rog);
+                break;
+              default:
+                break;
             }
-        }
-    }
-
-    async start() {
-        try {
-            await super.start();
-            this.getDevice();
-            this.getLedPower();
-            this.getLedMode();
-            this.getLedModes();
-
             //@ts-ignore
-            log("Current LED mode data:", this.aura_modes.get(this.current_aura_mode)?.speed);
-
-            this.dbus_proxy.connectSignal(
-                "NotifyLed",
-                (proxy: any = null, name: string, data: any) => {
-                    if (proxy) {
-                        const aura: AuraEffect = this._parseAuraEffect(data[0]);
-                        this.current_aura_mode = aura.mode;
-                        this.aura_modes.set(aura.mode, aura);
-                        //@ts-ignore
-                        log("LED data has changed to ", aura.mode, aura.zone, aura.colour1.r, aura.speed, aura.direction);
-                        this.notifyAuraModeSubscribers.forEach(sub => {
-                            sub.sync();
-                        });
-                    }
-                }
-            );
-
-            this.dbus_proxy.connectSignal(
-                "NotifyPowerStates",
-                (proxy: any = null, name: string, data: any) => {
-                    if (proxy) {
-                        const power: AuraPowerDev = this._parsePowerStates(data[0]);
-                        this.leds_powered = power;
-                        switch (this.device) {
-                            case AuraDevice.Tuf:
-                                //@ts-ignore
-                                log("LED power has changed to ", this.leds_powered.tuf);
-                                break;
-                            case AuraDevice.X1854:
-                            case AuraDevice.X1869:
-                            case AuraDevice.X18c6:
-                                //@ts-ignore
-                                log("LED power has changed to ", this.leds_powered.old_rog);
-                                break;
-                            case AuraDevice.X19b6:
-                            case AuraDevice.X1a30:
-                                //@ts-ignore
-                                log("LED power has changed to ", this.leds_powered.rog);
-                                break;
-                            default:
-                                break;
-                        }
-                        //@ts-ignore
-                        log("LED power has changed to ", this.leds_powered.rog);
-                        this.notifyAuraPowerSubscribers.forEach(sub => {
-                            sub.sync();
-                        });
-                    }
-                }
-            );
-        } catch (e) {
-            //@ts-ignore
-            log("Supported DBus initialization failed!", e);
-        }
+            log("LED power has changed to ", this.leds_powered.rog);
+            this.notifyAuraPowerSubscribers.forEach((sub) => {
+              sub.sync();
+            });
+          }
+        },
+      );
+    } catch (e) {
+      //@ts-ignore
+      log("Supported DBus initialization failed!", e);
     }
+  }
 
-    async stop() {
-        await super.stop();
-    }
-}
+  async stop() {
+    await super.stop();
+  }
+}

desktop-extensions/gnome-45/src/modules/dbus/base.ts

@@ -1,49 +0,0 @@
-import * as Resources from "../resources";
-import Gio from 'gi://Gio';
-
-export class DbusBase {
-    dbus_proxy: any = null; // type: Gio.DbusProxy
-    connected = false;
-    xml_resource = "";
-    dbus_path = "";
-
-    constructor(resource: string, dbus_path: string) {
-        this.xml_resource = resource;
-        this.dbus_path = dbus_path;
-    }
-
-    async start() {
-        //@ts-ignore
-        log(`Starting ${this.dbus_path} dbus module`);
-        try {
-            const xml = Resources.File.DBus(this.xml_resource);
-            this.dbus_proxy = new Gio.DBusProxy.makeProxyWrapper(xml)(
-                Gio.DBus.system,
-                "org.asuslinux.Daemon",
-                this.dbus_path,
-            );
-
-            this.connected = true;
-            //@ts-ignore
-            log(`${this.dbus_path} client started successfully.`);
-        } catch (e) {
-            //@ts-ignore
-            logError(`${this.xml_resource} dbus init failed!`, e);
-        }
-    }
-
-    async stop() {
-        //@ts-ignore
-        log(`Stopping ${this.xml_resource} dbus module`);
-
-        if (this.connected) {
-            this.dbus_proxy.destroy();
-            this.connected = false;
-            this.dbus_proxy = null;
-        }
-    }
-
-    isRunning(): boolean {
-        return this.connected;
-    }
-}

desktop-extensions/gnome-45/src/modules/dbus/platform.ts

@@ -1,202 +0,0 @@
-import * as bios from "../../bindings/platform";
-import { DbusBase } from "./base";
-
-// TODO: add callbacks for notifications
-export class Platform extends DbusBase {
-    bios: bios.RogBiosSupportedFunctions = {
-        post_sound: false,
-        gpu_mux: false,
-        panel_overdrive: false,
-        dgpu_disable: false,
-        egpu_enable: false,
-        mini_led_mode: false
-    };
-
-    // TODO: interface or something to enforce requirement of "sync()" method
-    public notifyPanelOdSubscribers: any[] = [];
-    public notifyPostBootSoundSubscribers: any[] = [];
-    public notifyMiniLedSubscribers: any[] = [];
-    public notifyGpuMuxSubscribers: any[] = [];
-
-    constructor() {
-        super("org-asuslinux-platform-4", "/org/asuslinux/Platform");
-    }
-
-    public getPostBootSound() {
-        if (this.isRunning()) {
-            try {
-                this.bios.post_sound = this.dbus_proxy.PostBootSoundSync() == "true" ? true : false;
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to get POST Boot Sound state!", e);
-            }
-        }
-        return this.bios.post_sound;
-    }
-
-    public setPostBootSound(state: boolean) {
-        if (this.isRunning()) {
-            try {
-                if (state !== this.bios.post_sound) {
-                    this.bios.post_sound = state;
-                }
-                return this.dbus_proxy.SetPostBootSoundSync(state);
-            } catch (e) {
-                //@ts-ignore
-                log("Platform DBus set Post Boot Sound failed!", e);
-            }
-        }
-    }
-
-    public getGpuMuxMode() {
-        if (this.isRunning()) {
-            try {
-                this.bios.gpu_mux = this.dbus_proxy.GpuMuxModeSync() == "true" ? true : false;
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to get MUX state!", e);
-            }
-        }
-        return this.bios.gpu_mux;
-    }
-
-    public setGpuMuxMode(state: boolean) {
-        if (this.isRunning()) {
-            try {
-                if (!state !== this.bios.gpu_mux) {
-                    this.bios.gpu_mux = !state;
-                }
-                return this.dbus_proxy.SetGpuMuxModeSync(!state);
-            } catch (e) {
-                //@ts-ignore
-                log("Switching the MUX failed!", e);
-            }
-        }
-    }
-
-    public getPanelOd() {
-        if (this.isRunning()) {
-            try {
-                this.bios.panel_overdrive = this.dbus_proxy.PanelOdSync() == "true" ? true : false;
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to get Overdrive state!", e);
-            }
-        }
-        return this.bios.panel_overdrive;
-    }
-
-    public setPanelOd(state: boolean) {
-        if (this.isRunning()) {
-            try {
-                if (state !== this.bios.panel_overdrive) {
-                    this.bios.panel_overdrive = state;
-                }
-                return this.dbus_proxy.SetPanelOdSync(state);
-            } catch (e) {
-                //@ts-ignore
-                log("Overdrive DBus set overdrive state failed!", e);
-            }
-        }
-    }
-
-    public getMiniLedMode() {
-        if (this.isRunning()) {
-            try {
-                this.bios.mini_led_mode = this.dbus_proxy.MiniLedModeSync() == "true" ? true : false;
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to get Overdrive state!", e);
-            }
-        }
-        return this.bios.mini_led_mode;
-    }
-
-    public setMiniLedMode(state: boolean) {
-        if (this.isRunning()) {
-            try {
-                if (state !== this.bios.mini_led_mode) {
-                    this.bios.mini_led_mode = state;
-                }
-                return this.dbus_proxy.SetMiniLedModeSync(state);
-            } catch (e) {
-                //@ts-ignore
-                log("setMiniLedMode failed!", e);
-            }
-        }
-    }
-
-    async start() {
-        try {
-            await super.start();
-
-            this.getPostBootSound();
-            this.dbus_proxy.connectSignal(
-                "NotifyPostBootSound",
-                (proxy: any = null, _name: string, data: boolean) => {
-                    if (proxy) {
-                        //@ts-ignore
-                        log(`PostBootSound changed to ${data}`);
-                        this.notifyPostBootSoundSubscribers.forEach(sub => {
-                            sub.sync();
-                        });
-                    }
-                }
-            );
-
-            this.getPanelOd();
-            this.dbus_proxy.connectSignal(
-                "NotifyPanelOd",
-                (proxy: any = null, _name: string, data: boolean) => {
-                    if (proxy) {
-                        //@ts-ignore
-                        log(`NotifyPanelOd has changed to ${data}.`);
-                        this.notifyPanelOdSubscribers.forEach(sub => {
-                            sub.sync();
-                        });
-                    }
-                }
-            );
-
-            this.getMiniLedMode();
-            this.dbus_proxy.connectSignal(
-                "NotifyMiniLedMode",
-                (proxy: any = null, _name: string, data: boolean) => {
-                    if (proxy) {
-                        //@ts-ignore
-                        log(`MiniLedMode has changed to ${data}.`);
-                        this.notifyMiniLedSubscribers.forEach(sub => {
-                            sub.sync();
-                        });
-                    }
-                }
-            );
-
-            this.getGpuMuxMode();
-            this.dbus_proxy.connectSignal(
-                "NotifyGpuMuxMode",
-                (proxy: any = null, _name: string, data: boolean) => {
-                    if (proxy) {
-                        //@ts-ignore
-                        log(`MUX has changed to ${data}.`);
-                        this.notifyGpuMuxSubscribers.forEach(sub => {
-                            sub.sync();
-                        });
-                    }
-                }
-            );
-
-        } catch (e) {
-            //@ts-ignore
-            log("Platform DBus init failed!", e);
-        }
-    }
-
-    async stop() {
-        await super.stop();
-        this.bios.post_sound = false;
-        this.bios.panel_overdrive = false;
-        this.bios.mini_led_mode = false;
-        this.bios.gpu_mux = false;
-    }
-}

desktop-extensions/gnome-45/src/modules/dbus/power.ts

@@ -1,99 +0,0 @@
-import { DbusBase } from "./base";
-
-// function getMethods(obj: { [x: string]: { toString: () => string; }; }) {
-//     var result = [];
-//     for (var id in obj) {
-//       try {
-//         if (typeof(obj[id]) == "function") {
-//           result.push(id + ": " + obj[id].toString());
-//         }
-//       } catch (err) {
-//         result.push(id + ": inaccessible");
-//       }
-//     }
-//     return result;
-//   }
-
-export class Power extends DbusBase {
-    chargeLimit = 100;
-    mainsOnline = false;
-
-    constructor() {
-        super("org-asuslinux-power-4", "/org/asuslinux/Power");
-    }
-
-    public getChargingLimit() {
-        if (this.isRunning()) {
-            try {
-                this.chargeLimit = this.dbus_proxy.ChargeControlEndThresholdSync();
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to fetch Charging Limit!", e);
-            }
-        }
-        return this.chargeLimit;
-    }
-
-    public setChargingLimit(limit: number) {
-        if (this.isRunning()) {
-            try {
-                if (limit > 0 && this.chargeLimit !== limit) {
-                    // update state
-                    this.chargeLimit = limit;
-                }
-                return this.dbus_proxy.SetChargeControlEndThresholdSync(limit);
-            } catch (e) {
-                //@ts-ignore
-                log("Profile DBus set power profile failed!", e);
-            }
-        }
-    }
-
-    public getMainsOnline() {
-        if (this.isRunning()) {
-            try {
-                this.mainsOnline = this.dbus_proxy.MainsOnlineSync();
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to fetch MainsLonline!", e);
-            }
-        }
-        return this.mainsOnline;
-    }
-
-    async start() {
-        try {
-            await super.start();
-            this.getChargingLimit();
-
-            this.dbus_proxy.connectSignal(
-                "NotifyChargeControlEndThreshold",
-                (proxy: any = null, name: string, data: string) => {
-                    if (proxy) {
-                        //@ts-ignore
-                        log(`Charging Limit has changed to ${data}% (${name}).`);
-                        this.chargeLimit = parseInt(data);
-                    }
-                }
-            );
-
-            this.dbus_proxy.connectSignal(
-                "NotifyMainsOnline",
-                (proxy: any = null, name: string, data: string) => {
-                    if (proxy) {
-                        //@ts-ignore
-                        log(`NotifyMainsOnline has changed to ${data}% (${name}).`);
-                        this.mainsOnline = parseInt(data) == 1 ? true : false;
-                    }
-                }
-            );
-        } catch (e) {
-            //@ts-ignore
-            log("Charging Limit DBus initialization failed!", e);
-        }
-    }
-
-    async stop() {
-        await super.stop();
-    }
-}

desktop-extensions/gnome-45/src/modules/dbus/supported.ts

@@ -1,107 +0,0 @@
-import { SupportedFunctions, AdvancedAura } from "../../bindings/platform";
-import { AuraDevice, AuraModeNum, AuraZone, PowerZones } from "../../bindings/aura";
-import { DbusBase } from "./base";
-
-export class Supported extends DbusBase {
-    // False,
-    // (True,),
-    // (True, True),
-    //   ('X19b6',
-    //   True,
-    //   ['Static',
-    //   'Breathe',
-    //   'Strobe',
-    //   'Rainbow',
-    //   'Star',
-    //   'Rain',
-    //   'Highlight',
-    //   'Laser',
-    //   'Ripple',
-    //   'Pulse',
-    //   'Comet',
-    //   'Flash'],
-    //   [],
-    //   'PerKey',
-    //   ['Keyboard', 'Lightbar', 'Logo', 'RearGlow']),
-    // (False, True, True, True, False, True)
-
-    supported: SupportedFunctions = {
-        anime_ctrl: false,
-        charge_ctrl: {
-            charge_level_set: false
-        },
-        platform_profile: {
-            platform_profile: false,
-            fan_curves: false
-        },
-        keyboard_led: {
-            dev_id: AuraDevice.Unknown,
-            brightness: false,
-            basic_modes: [],
-            basic_zones: [],
-            advanced_type: AdvancedAura.None,
-            power_zones: [],
-        },
-        rog_bios_ctrl: {
-            post_sound: false,
-            gpu_mux: false,
-            panel_overdrive: false,
-            dgpu_disable: false,
-            egpu_enable: false,
-            mini_led_mode: false
-        }
-    };
-
-    constructor() {
-        super("org-asuslinux-supported-4", "/org/asuslinux/Supported");
-    }
-
-    public getSupported() {
-        if (this.isRunning()) {
-            try {
-                const _data = this.dbus_proxy.SupportedFunctionsSync();
-                this.supported.anime_ctrl = _data[0];
-                this.supported.charge_ctrl.charge_level_set = _data[1];
-                this.supported.platform_profile.platform_profile = _data[2][0];
-                this.supported.platform_profile.fan_curves = _data[2][1];
-                this.supported.keyboard_led.dev_id = AuraDevice[_data[3][0] as AuraDevice];
-                this.supported.keyboard_led.brightness = _data[3][1];
-
-                this.supported.keyboard_led.basic_modes = _data[3][2].map(function (value: string) {
-                    return AuraModeNum[value as AuraModeNum];
-                });
-                this.supported.keyboard_led.basic_zones = _data[3][3].map(function (value: string) {
-                    return AuraZone[value as AuraZone];
-                });
-                this.supported.keyboard_led.advanced_type = AdvancedAura[_data[3][4] as AdvancedAura];
-                this.supported.keyboard_led.power_zones = _data[3][5].map(function (value: string) {
-                    return PowerZones[value as PowerZones];
-                });
-
-                this.supported.rog_bios_ctrl.post_sound = _data[4][0];
-                this.supported.rog_bios_ctrl.gpu_mux = _data[4][1];
-                this.supported.rog_bios_ctrl.panel_overdrive = _data[4][2];
-                this.supported.rog_bios_ctrl.dgpu_disable = _data[4][3];
-                this.supported.rog_bios_ctrl.egpu_enable = _data[4][4];
-                this.supported.rog_bios_ctrl.mini_led_mode = _data[4][5];
-            } catch (e) {
-                //@ts-ignore
-                log("Failed to fetch supported functionalities", e);
-            }
-        }
-    }
-
-    async start() {
-        try {
-            await super.start();
-            this.getSupported();
-        } catch (e) {
-            //@ts-ignore
-            log("Supported DBus initialization failed!", e);
-        }
-    }
-
-    async stop() {
-        await super.stop();
-    }
-}

desktop-extensions/gnome-45/src/modules/dbus_proxy.ts

@@ -0,0 +1,64 @@
+import { Extension, gettext as _ } from "@girs/gnome-shell/extensions/extension";
+import { Gio } from "@girs/gio-2.0";
+import { GLib } from "@girs/glib-2.0";
+import { imports } from "@girs/gjs";
+
+// Reads the contents of a file contained in the global resources archive. The data
+// is returned as a string.
+export function getStringResource(path: string | null) {
+  const data = Gio.resources_lookup_data(path, 0);
+  return new TextDecoder().decode(data.get_data()?.buffer);
+}
+
+export class DbusBase {
+  proxy!: Gio.DBusProxy;
+  connected = false;
+  ifaceXml = "";
+  dbus_path = "";
+
+  constructor(file_name: string, dbus_path: string) {
+    let extensionObject = Extension.lookupByUUID("asusctl-gnome@asus-linux.org");
+    const path = extensionObject?.path + "/resources/dbus/" + file_name;
+    const [ok, data] = GLib.file_get_contents(path);
+    if (!ok) {
+      throw new Error("could not read interface file");
+    }
+    this.ifaceXml = imports.byteArray.toString(data);
+    this.dbus_path = dbus_path;
+  }
+
+  async start() {
+    //@ts-ignore
+    log(`Starting ${this.dbus_path} dbus module`);
+    try {
+      log(this.ifaceXml);
+      this.proxy = Gio.DBusProxy.makeProxyWrapper(this.ifaceXml)(
+        Gio.DBus.system,
+        "org.asuslinux.Daemon",
+        this.dbus_path,
+      );
+
+      this.connected = true;
+      //@ts-ignore
+      log(`${this.dbus_path} client started successfully.`);
+    } catch (e) {
+      //@ts-ignore
+      logError(`${this.xml_resource} dbus init failed!`, e);
+    }
+  }
+
+  async stop() {
+    //@ts-ignore
+    log(`Stopping ${this.xml_resource} dbus module`);
+
+    if (this.connected && this.proxy != undefined) {
+      this.proxy.run_dispose();
+      this.proxy = undefined;
+      this.connected = false;
+    }
+  }
+
+  isRunning(): boolean {
+    return this.connected;
+  }
+}