New release

Closes #423

.cargo-husky/hooks/pre-commit

@@ -0,0 +1,12 @@
+#!/bin/sh
+
+set -e
+
+echo '+cargo +nightly fmt --all -- --check'
+cargo +nightly fmt --all -- --check
+echo '+cargo clippy --all -- -D warnings'
+cargo clippy --all -- -D warnings
+echo '+cargo test --all'
+cargo test --all
+echo '+cargo cranky'
+cargo cranky

.cargo-husky/hooks/pre-push

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+set -e
+
+echo '+cargo +nightly fmt --all -- --check'
+cargo +nightly fmt --all -- --check
+echo '+cargo clippy --all -- -D warnings'
+cargo clippy --all -- -D warnings
+echo '+cargo cranky'
+cargo cranky

.editorconfig

@@ -0,0 +1,23 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 2
+indent_style = space
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.rs]
+indent_size = 4
+
+[tests/**/*.rs]
+charset = utf-8
+end_of_line = unset
+indent_size = unset
+indent_style = unset
+trim_trailing_whitespace = unset
+insert_final_newline = unset

.gitignore

@@ -6,4 +6,16 @@ vendor
 vendor-*
 vendor_*
 .vscode-ctags
-.vscode
+.vscode
+.~lock.*
+*.ods#
+
+# gnome extension
+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

@@ -1,15 +1,15 @@
 image: rust:latest
 
-cache:
-  key: "$CI_JOB_NAME-$CI_COMMIT_REF_SLUG"
-  paths:
+.rust_cache: &rust_cache
+  cache:
+    # key: $CI_COMMIT_REF_SLUG
+    paths:
       # Don't include `incremental` to save space
       # Debug
       - target/debug/build/
       - target/debug/deps/
       - target/debug/.fingerprint/
       - target/debug/.cargo-lock
-      - target/debug/df_storyteller
       # Release
       - target/release/build/
       - target/release/deps/
@@ -17,17 +17,19 @@ cache:
       - target/release/.cargo-lock
 
 before_script:
-  - apt-get update -qq && apt-get install -y -qq libudev-dev libgtk-3-dev grep llvm clang libclang-dev
+  - apt-get update -qq && apt-get install -y -qq libudev-dev libgtk-3-dev grep llvm clang libclang-dev libsdl2-dev libsdl2-gfx-dev
 
 stages:
-    - format
-    - check
-    - test
-    - release
+  - format
+  - check
+  - test
+  - release
+  - deploy
 
 format:
   except:
     - tags
+  <<: *rust_cache
   script:
     - echo "nightly" > rust-toolchain
     - rustup component add rustfmt
@@ -36,6 +38,7 @@ format:
 check:
   except:
     - tags
+  <<: *rust_cache
   script:
     - rustup component add clippy
     - cargo check
@@ -46,18 +49,36 @@ check:
 test:
   except:
     - tags
+  <<: *rust_cache
   script:
-    - cargo test
+    - mkdir -p .git/hooks > /dev/null
+    - cargo test --all
 
 release:
   only:
     - tags
+  <<: *rust_cache
   script:
     - make && make vendor
   artifacts:
     paths:
-    - vendor_asusctl_*.tar.xz
+    - vendor_asusctl*.tar.xz
     - cargo-config
 
+pages:
+  stage: deploy
+  only:
+    - tags
+  <<: *rust_cache
+  script:
+    - cargo doc --document-private-items --no-deps --workspace
+    - rm -rf public
+    - mkdir public
+    - cp -R target/doc/* public
+    - cp extra/index.html public
+  artifacts:
+    paths:
+      - public
+
 variables:
   GIT_SUBMODULE_STRATEGY: normal

CHANGELOG.md

@@ -5,10 +5,170 @@ 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.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
+- Support for G713RC LED modes
+
+### Changed
+- Fix loading of fan curves from stored settings
+
+## [v4.7.1]
+### Changed
+- Fixes to asusctl CLI tool to show fan curves
+- Fixes to asusd to ensure fan curve defaults are loaded if the config file fails
+- Further refine the asusctl CLI for fan-curve control
+- Fixes to AniMe detection
+- Fixes to aura config creation/loading
+
+### Added
+- Support for GV601V LED modes
+
+## [v4.7.0]
+### Added
+- Support for FX507Z LED modes
+- Support for GL503V LED modes
+- Support for G733C LED modes
+- Support for GV601VI LED modes
+- Support for FX505G LED modes
+- Support for GA402X LED modes
+- Support for G634J LED modes (layout is in progress)
+- Support the Rear Glow on some laptops
+- Added field to aura_support to determine which LED power zones are supported. This will need folks to contribute data.
+- Support M16 matrix display
+  - Custom images
+  - Pixel gifs
+  - Power options
+  - Builtin animations
+- In-progress simulators for GA402, GU604 animatrix, optional build and takes a single arg
+- Add `model_override` option to anime config, this is handy for forcing a model for "Unknown" anime, and for simulators
+- Add `mini_led_mode` support to asusd and zbus crates (requires kernel patch https://lkml.org/lkml/2023/6/19/1264)
+- Add `mini_led_mode` toggle to rog-control-center GUI, tray, notifications
+- Add generation of typescript types from the rust types used via dbus using typeshare
+- Add generation of introspection XML from asusd dbus
+- Add a reworked gnome extension to the main repo under `desktop-extensions/gnome/`. This was done to better keep the extension in sync with work done on asusd, especially around breaking dbus
+- Add support for the mid fan custom curves on some laptops
+### Changed
+- Move FX506HC to FX506H in arua DB to catch full series of this range
+- Move FX506LH to FX506L in arua DB to catch full series of this range
+- Move G513I* to G513I in arua DB to catch full series of this range
+- Remove notification handle tracking limit, fixes KDE issue with profile notif
+- Rename daemon and daemon-user crates to asusd and asusd-user to not be confusing in workspace naming
+- Prevent the multiple notifications from a profile change from occuring (too many functions with side effects!)
+- Apply keyboard brightness when setting a mode
+- Update GL503 led config
+- Arua LED power control has been heavily refactored for 0x19b6+ devices
+- Rog Control Center:
+  - Added option to enable/disable system tray
+  - Added button to fully quit app (exits from background)
+  - Moved application settings to new page
+  - Aura LED power refactor is now taken advantage of in RCC, exposing all settings
+### BREAKING
+- All Anime related DBUS methods/notifs are changed
+- All dbus interfaces that handled an enum have now been forced to use the enum as String type, not uint or similar, this unfortunately breaks a heap of stuff but has the benefit of allowing asusctl to use crates to generate a typescript (or other) binding to the types being used by zbus for the proxies. The implication here is that there will be an eventual tighter integration with the gnome extension and maybe KDE also.
+
+## [v4.6.2]
+- Fix rog-control-center not reopening if `startup_in_background` is set
+
+## [v4.6.1]
+### Added
+- Support for G733Z LED modes
+- Support for GU604V LED modes
+- Support for GX650P LED modes
+- Support for GV604I LED modes
+- Support for FX516P LED modes (this laptop still has further issues, will require a patched kernel when patch is ready)
+- Add device code for the Z13 ACRNM keyboard (requires kernel patch, in progress)
+- Support for GV301VIC LED modes
+- Add device code for the plain Z13 keyboard (requires kernel patch, in progress)
+- Support for GV301V LED modes
+### Changed
+- Adjustments to Anime system events thread
+- Add "sleep" animetion config options to anime config
+- rog-control-center dark/light mode persistency
+- Adjustments to keyboard detection
+- Better support of using supergfxctl when available (tray icon and menu)
+- Check supergfx version before enabling use in tray (require 5.1.0+)
+- Update allowed Aura modes on asusd restart if changed
+- Set tray icon for dgpu to "On" if in Vfio mode to prevent confusion
+- Add support for Logout/Reboot in notification for KDE
+
+## [v4.6.0]
+### Added
+- Support for GL703GE keyboard layout
+- Support for G533Z modes and keyboard layout
+### Changed
+- Better handling of `/etc/asusd` not existing
+- Better handling of non-existant config files
+- Move all config handling to generic traits for better consistency
+- Re-parse all configs to RON format
+- Move fan-curve config to own config file
+- Added option to set `disable_nvidia_powerd_on_battery`
+- Add short log entry to throttle_thermal_policy change detection
+- ROGCC: Don't notify user if changing to same mux mode
+- ROGCC: Add CLI opt for loading a keyboard layout for testing, with live-reload on file change
+- ROGCC: Add CLI opt for viewing all layout files + filenames to help find a layout matching your laptop
+  + Both of these options would hopefully be temporary and replaced with a "wizard" GUI helper
+- Fix profile controller not detecting if platform_profile is changed
+- Fix remove the leftover initial config writes on `new()` for some controllers to prevent resetting settings on startup
+  + refactor the loading of systemd curve defaults and config file
+### BREAKING
+- Rename aura dbus method from `per_key_raw` to `direct_addressing_raw` and add doc comment
+- Changes to aura.conf:
+- Changes to asusd-ledmodes.toml:
+  + Rename `standard` to `basic_modes`
+  + Rename `multizone` to `basic_zones`
+  + Raname `per_key` to `advanced` and change type from `bool` to `AdvancedAuraType`
+  + Removed `prod_family`
+  + Split all entries to `board_name` (separating `board_names`) (now a huge file)
+  + removed `asusd-ledmodes.toml` in favour of `aura_support.ron` due to an unsupported type in toml
+- Rename and adjust `LedSupportedFunctions` to closely match the above
+
 ## [v4.5.8]
 ### Changed
 - Fix incorrect stop/start order of nvidia-powerd on AC plug/unplug
 
+## [v4.5.7]
+### Changed
+- ROGCC: Don't notify user if changing to same mux mode
+-
+
 ## [v4.5.7]
 ### Changed
 - ROGCC: Don't notify user if changing to same mux mode
@@ -572,6 +732,4 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Fix small deadlock with awaits
 
-## [1.0.0] - 2020-08-13
-
-- Major fork and refactor to use asus-hid patch for ASUS N-Key device
+## [1.0.0]

Cargo.toml

@@ -1,23 +1,27 @@
 [workspace]
-members = ["asusctl", "daemon", "daemon-user", "rog-platform", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles", "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.5.8"
+version = "5.0.1"
 
 [workspace.dependencies]
 async-trait = "^0.1"
-tokio = { version = "^1.22.0", features = ["macros", "rt-multi-thread", "time", "sync"]}
+tokio = { version = "^1.23.0", features = ["macros", "sync", "rt-multi-thread"]}
 concat-idents = "^1.1"
 dirs = "^4.0"
 smol = "^1.3"
 
-zbus = "^3.5"
-logind-zbus = { version = "^3.0.3" } #, default-features = false, features = ["non_blocking"] }
+zbus = "~3.14.1"
+logind-zbus = { version = "~3.1" } #, default-features = false, features = ["non_blocking"] }
 
 serde = "^1.0"
 serde_derive = "^1.0"
 serde_json = "^1.0"
-toml = "^0.5.9"
+toml = "^0.5.10"
+ron = "*"
+typeshare = "1.0.0"
 
 log = "^0.4"
 env_logger = "^0.10.0"
@@ -26,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"
@@ -34,6 +37,8 @@ pix = "^0.13"
 tinybmp = "^0.4.0"
 gif = "^0.12.0"
 
+versions = "4.1"
+
 notify-rust = { git = "https://github.com/flukejones/notify-rust.git", default-features = false, features = ["z"] }
 
 [profile.release]
@@ -43,6 +48,7 @@ lto = "fat"
 debug = false
 opt-level = 3
 panic = "abort"
+#codegen-units = 1
 
 [profile.dev]
 debug = true
@@ -51,3 +57,8 @@ opt-level = 1
 [profile.bench]
 debug = false
 opt-level = 3
+
+[workspace.dependencies.cargo-husky]
+version = "1"
+default-features = false
+features = ["user-hooks"]

Cranky.toml

@@ -1,7 +1,7 @@
 # https://github.com/ericseppanen/cargo-cranky
 # cargo install cargo-cranky && cargo cranky
 
-warn = [
+error = [
   "clippy::all",
   "clippy::await_holding_lock",
   "clippy::bool_to_int_with_if",

MANUAL.md

@@ -47,35 +47,7 @@ The LED controller (e.g, aura) enables setting many of the factory modes availab
 
 #### Supported laptops
 
-Models GA401, GA502, GU502 support LED brightness change only (no RGB). However the GA401Q model can actually use three modes; static, breathe, and pulse, plus also use red to control the LED brightness intensity.
-
-All models that have any form of LED mode control need to be enabled via the config file at `/etc/asusd/asusd-ledmodes.toml`. Unfortunately ASUS doesn't provide any easy way to find all the supported modes for all laptops (not even through Armory Crate and its various files, that progrma downloads only the required settings for the laptop it runs on) so each model must be added as needed.
-
-#### Config options
-
-The defaults are located at `/etc/asusd/asusd-ledmodes.toml`, and on `asusd` start it creates `/etc/asusd/aura.conf` whcih stores the per-mode settings. If you edit the defaults file you must remove `/etc/asusd/aura.conf` and restart `asusd.service` with `systemctl restart asusd`.
-
-##### /etc/asusd/asusd-ledmodes.toml
-
-Example:
-```toml
-[[led_data]]
-prod_family = "Strix"
-board_names = ["GL504G"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = ["Key1", "Key2", "Key3", "Key4", "Logo", "BarLeft", "BarRight"]
-per_key = false
-```
-
-1. `prod_family`: you can find this in `journalctl -b -u asusd`, or `cat /sys/class/dmi/id/product_name`. It should be copied as written. There can be multiple `led-data` groups of the same `prod_family` with differing `board_names`.
-2. `board_names`: is an array of board names in this product family. Find this in the journal as above or by `cat /sys/class/dmi/id/board_name`.
-3. `standard` are the factory preset modes, the names should corrospond to Armory Crate names
-4. `multizone`: some models have 4 to 7 zones of LED control as shown in the example. If the laptop has no zones then an empty array will suffice.
-5. `per_key`: enable per-key RGB effects. The keyboard must support this or it has no effect.
-
-##### /etc/asusd/aura.conf
-
-This file can be manually edited if desired, but the `asusctl` CLI tool, or dbus methods are the preferred method. Any manual changes to this file mean that the `asusd.service` will need to be restarted, or you need to cycle between modes to force a reload.
+There are over 60 supported laptops as of 01-01-2023. Please see [the rog-aura crate readme for further details](/rog-aura/README.md).
 
 ### Charge control
 
@@ -145,87 +117,100 @@ I'm unsure of how many laptops this works on, so please try it.
 
 An Aura config itself is a file with contents:
 
-```json
-{
-  "name": "aura-default",
-  "aura": [
-    {
-      "Breathe": {
-        "led_type": {
-          "Key": "W"
-        },
-        "start_colour1": [
-          255,
-          0,
-          20
+```ron
+(
+    name: "aura-default",
+    aura: (
+        effects: [
+            Breathe((
+                led: W,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: A,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: S,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: D,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: F,
+                start_colour1: (255, 0, 0),
+                start_colour2: (255, 0, 0),
+                speed: High,
+            )),
+            Static((
+                led: RCtrl,
+                colour: (0, 0, 255),
+            )),
+            Static((
+                led: LCtrl,
+                colour: (0, 0, 255),
+            )),
+            Static((
+                led: Esc,
+                colour: (0, 0, 255),
+            )),
+            DoomFlicker((
+                led: N9,
+                start_colour: (0, 0, 255),
+                max_percentage: 80,
+                min_percentage: 40,
+            )),
         ],
-        "start_colour2": [
-          20,
-          255,
-          0
-        ],
-        "speed": "Low"
-      }
-    },
-    {
-      "Static": {
-        "led_type": {
-          "Key": "Esc"
-        },
-        "colour": [
-          0,
-          0,
-          255
-        ]
-      }
-    },
-    {
-      "Flicker": {
-        "led_type": {
-          "Key": "N9"
-        },
-        "start_colour": [
-          0,
-          0,
-          255
-        ],
-        "max_percentage": 80,
-        "min_percentage": 40
-      }
-    }
-  ]
-}
+        zoned: false,
+    ),
+)
 ```
 
-If your laptop supports multizone, `"led_type"` can also be `"Zone": <one of the following>`
-- `"None"`
-- `"KeyboardLeft"`
-- `"KeyboardCenterLeft"`
-- `"KeyboardCenterRight"`
-- `"KeyboardRight"`
-- `"LightbarRight"`
-- `"LightbarRightCorner"`
-- `"LightbarRightBottom"`
-- `"LightbarLeftBottom"`
-- `"LightbarLeftCorner"`
-- `"LightbarLeft"`
+If your laptop supports multizone, `"led"` can also be `"Zone": <one of the following>`
+- `SingleZone` // Keyboards with only one zone
+- `ZonedKbLeft` // keyboard left
+- `ZonedKbLeftMid` // keyboard left-middle
+- `ZonedKbRightMid` // etc
+- `ZonedKbRight`
+- `LightbarRight`
+- `LightbarRightCorner`
+- `LightbarRightBottom`
+- `LightbarLeftBottom`
+- `LightbarLeftCorner`
+- `LightbarLeft`
+
+Single zone example:
+
+```ron
+(
+    name: "aura-default",
+    aura: (
+        effects: [
+            DoomFlicker((
+                led: SingleZone,
+                start_colour: (200, 40, 5),
+                max_percentage: 80,
+                min_percentage: 40,
+            )),
+        ],
+        zoned: true,
+    ),
+)
+```
 
 At the moment there are only three effects available as shown in the example. More will come in the future
 but this may take me some time.
 
-**Aura layouts**: `asusd-user` does its best to find a suitable layout to use based on `/sys/class/dmi/id/board_name`.
-It looks at each of the files in `/usr/share/rog-gui/layouts/` and matches against the toml block looking like:
-```toml
-matches = [
-    'GX502',
-    'GU502',
-]
-```
-
-My laptop is a `GX502GW`, so `GX502` is a match. Note that these layouts are the physical representation of
-the keyboard and are used in the GUI also. The config that tells if per-key is supported is located in
-`/etc/asusd/asusd-ledmodes.toml`
-
 #### Config options: AniMe
 
 `~/.config/rog/rog-user.cfg` contains a setting `"active_anime": "<FILENAME>"` where `<FILENAME>` is the name of the AniMe config to use, located in the same directory and without the file postfix, e.g, `"active_anime": "anime-doom"`

Makefile

@@ -15,14 +15,19 @@ BIN_ROG := rog-control-center
 BIN_C := asusctl
 BIN_D := asusd
 BIN_U := asusd-user
-LEDCFG := asusd-ledmodes.toml
+LEDCFG := aura_support.ron
 
 SRC := Cargo.toml Cargo.lock Makefile $(shell find -type f -wholename '**/src/*.rs')
 
+STRIP_BINARIES ?= 0
+
 DEBUG ?= 0
 ifeq ($(DEBUG),0)
 	ARGS += --release
 	TARGET = release
+else
+	ARGS += --profile dev
+	TARGET = debug
 endif
 
 VENDORED ?= 0
@@ -38,18 +43,20 @@ clean:
 distclean:
 	rm -rf .cargo vendor vendor.tar.xz
 
-install:
-	$(INSTALL_PROGRAM) "./target/release/$(BIN_ROG)" "$(DESTDIR)$(bindir)/$(BIN_ROG)"
+install-program:
+	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_ROG)" "$(DESTDIR)$(bindir)/$(BIN_ROG)"
+
+	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_C)" "$(DESTDIR)$(bindir)/$(BIN_C)"
+	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_D)" "$(DESTDIR)$(bindir)/$(BIN_D)"
+	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_U)" "$(DESTDIR)$(bindir)/$(BIN_U)"
+
+install-data:
 	$(INSTALL_DATA) "./rog-control-center/data/$(BIN_ROG).desktop" "$(DESTDIR)$(datarootdir)/applications/$(BIN_ROG).desktop"
 	$(INSTALL_DATA) "./rog-control-center/data/$(BIN_ROG).png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/$(BIN_ROG).png"
-	cd rog-aura/data/layouts && find . -type f -name "*.toml" -exec $(INSTALL_DATA) "{}" "$(DESTDIR)$(datarootdir)/rog-gui/layouts/{}" \;
-
-	$(INSTALL_PROGRAM) "./target/release/$(BIN_C)" "$(DESTDIR)$(bindir)/$(BIN_C)"
-	$(INSTALL_PROGRAM) "./target/release/$(BIN_D)" "$(DESTDIR)$(bindir)/$(BIN_D)"
-	$(INSTALL_PROGRAM) "./target/release/$(BIN_U)" "$(DESTDIR)$(bindir)/$(BIN_U)"
+	cd rog-aura/data/layouts && find . -type f -name "*.ron" -exec $(INSTALL_DATA) "{}" "$(DESTDIR)$(datarootdir)/rog-gui/layouts/{}" \;
 
 	$(INSTALL_DATA) "./data/$(BIN_D).rules" "$(DESTDIR)$(libdir)/udev/rules.d/99-$(BIN_D).rules"
-	$(INSTALL_DATA) "./data/$(LEDCFG)" "$(DESTDIR)/etc/asusd/$(LEDCFG)"
+	$(INSTALL_DATA) "./rog-aura/data/$(LEDCFG)" "$(DESTDIR)$(datarootdir)/asusd/$(LEDCFG)"
 	$(INSTALL_DATA) "./data/$(BIN_D).conf" "$(DESTDIR)$(datarootdir)/dbus-1/system.d/$(BIN_D).conf"
 
 	$(INSTALL_DATA) "./data/$(BIN_D).service" "$(DESTDIR)$(libdir)/systemd/system/$(BIN_D).service"
@@ -71,6 +78,8 @@ install:
 
 	cd rog-anime/data && find "./anime" -type f -exec $(INSTALL_DATA) "{}" "$(DESTDIR)$(datarootdir)/asusd/{}" \;
 
+install: install-program install-data
+
 uninstall:
 	rm -f "$(DESTDIR)$(bindir)/$(BIN_ROG)"
 	rm -r "$(DESTDIR)$(datarootdir)/applications/$(BIN_ROG).desktop"
@@ -103,18 +112,39 @@ 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
 
+bindings:
+	typeshare ./rog-anime/src/ --lang=typescript --output-file=bindings/ts/anime.ts
+	typeshare ./rog-aura/src/ --lang=typescript --output-file=bindings/ts/aura.ts
+	typeshare ./rog-profiles/src/ --lang=typescript --output-file=bindings/ts/profiles.ts
+	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/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
 	cargo build $(ARGS)
-	strip -s ./target/release/$(BIN_C)
-	strip -s ./target/release/$(BIN_D)
-	strip -s ./target/release/$(BIN_U)
-	strip -s ./target/release/$(BIN_ROG)
+ifneq ($(STRIP_BINARIES),0)
+	strip -s ./target/$(TARGET)/$(BIN_C)
+	strip -s ./target/$(TARGET)/$(BIN_D)
+	strip -s ./target/$(TARGET)/$(BIN_U)
+	strip -s ./target/$(TARGET)/$(BIN_ROG)
+endif
 
-.PHONY: all clean distclean install uninstall update build
+
+.PHONY: all clean distclean install uninstall update build bindings

README.md

@@ -1,6 +1,6 @@
 # `asusctl` for ASUS ROG
 
-[![](https://www.paypalobjects.com/en_US/i/btn/btn_donate_LG.gif)](https://www.paypal.com/donate/?hosted_button_id=4V2DEPS7K6APC) - [Asus Linux Website](https://asus-linux.org/)
+[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.
 
@@ -13,6 +13,8 @@ Now includes a GUI, `rog-control-center`.
 
 **The minimum supported kernel version is 5.17**
 
+**For TUF laptops, the minimum supported kernel version is 6.1**
+
 ## 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.
@@ -29,7 +31,7 @@ a system-level daemon should.
 
 ## Discord
 
-[Discord server link](https://discord.gg/4ZKGd7Un5t)
+[Discord server link](https://discord.gg/WTHnqabm)
 
 ## SUPPORTED LAPTOPS
 
@@ -43,18 +45,14 @@ Bus 001 Device 002: ID 0b05:1866 ASUSTek Computer, Inc. N-KEY Device
 then it may work without tweaks. Technically all other functions except the LED
 and AniMe parts should work regardless of your latop make.
 
-**TUF Laptops**: now supported provided the kernel is patched. These patches are submitted upstream and will be in version 6.1.x of the kernel (or thereabouts). See the blog on asus-linux.org for more info.
-
 ## Implemented
 
 - [X] System daemon
-- [X] GUI app
-- [X] User notifications daemon
+- [X] GUI app (includes tray and notifications)
 - [X] Setting/modifying built-in LED modes
 - [X] Per-key LED setting
 - [X] Fancy LED modes (See examples) (currently being reworked)
-- [X] Saving settings for reload
-- [X] AniMatrix display on G14 models that include it
+- [X] AniMatrix display on G14 and M16 models that include it
 - [X] Set battery charge limit (with kernel supporting this)
 - [X] Fan curve control on supported laptops (G14/G15, some TUF like FA507)
 - [X] Toggle bios setting for boot/POST sound
@@ -74,14 +72,24 @@ Requirements are rust >= 1.57 installed from rustup.io if the distro provided ve
 
 **Ubuntu (unsuported):**
 
-    apt install libclang-dev libudev-dev
+    apt install libgtk-3-dev libpango1.0-dev libgdk-pixbuf-2.0-dev libglib2.0-dev cmake libclang-dev libudev-dev libayatana-appindicator3-1
     curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+    source "$HOME/.cargo/env"
     make
     sudo make install
 
+**popos (unsuported):**
+
+    sudo apt install cmake libclang-dev libudev-dev libgtk-3-dev libclang-dev libglib2.0-dev libatkmm-1.6-dev libpangomm-1.4-dev librust-gdk-pixbuf-dev
+    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+    source "$HOME/.cargo/env"
+    make
+    sudo make install
+
+
 **fedora:**
 
-    dnf install cmake clang-devel systemd-devel gtk3-devel cargo
+    dnf install cmake clang-devel systemd-devel glib2-devel cairo-devel atkmm-devel pangomm-devel gdk-pixbuf2-devel gtk3-devel libappindicator-gtk3
     make
     sudo make install
 
@@ -90,7 +98,7 @@ Requirements are rust >= 1.57 installed from rustup.io if the distro provided ve
 Works with KDE Plasma (without GTK packages)
 
     zypper in -t pattern devel_basis
-    zypper in rustup cmake clang-devel systemd-devel glib2-devel cairo-devel atkmm-devel pangomm-devel gdk-pixbuf-devel gtk3-devel
+    zypper in rustup make cmake systemd-devel clang-devel llvm-devel gdk-pixbuf-devel cairo-devel pango-devel freetype-devel gtk3-devel libexpat-devel libayatana-indicator3-7
     make
     sudo make install
 
@@ -116,8 +124,20 @@ You may also need to activate the service for debian install. If running Pop!_OS
 
 Run `sudo make uninstall` in the source repo, and remove `/etc/asusd/`.
 
+# Contributing
+
+See `CONTRIBUTING.md`. Additionally, also do `cargo clean` and `cargo test` on first checkout to ensure the commit hooks are used (via `cargo-husky`).
+
+Generation of the bindings with `make bindings` requires `typeshare` to be installed.
+
+Dbus introsepction XML requires with `make introspection` requires `anime_sim` to be running before starting `asusd`.
+
 # OTHER
 
+## AniMe Matrix simulator
+
+A simulator using SDL2 can be built using `cargo build --package rog_simulators` and run with `./target/debug/anime_sim`. Once started `asusd` will need restarting to pick it up. If running this sim on a laptop *with* the display, the simulated display will be used instead of the physical display.
+
 ## Supporting more laptops
 
 Please file a support request.

asusctl/Cargo.toml

@@ -11,14 +11,16 @@ rog_aura = { path = "../rog-aura" }
 rog_dbus = { path = "../rog-dbus" }
 rog_profiles = { path = "../rog-profiles" }
 rog_platform = { path = "../rog-platform" }
-daemon = { path = "../daemon" }
+asusd = { path = "../asusd" }
+dmi_id = { path = "../dmi-id" }
 
 gumdrop.workspace = true
 toml.workspace = true
-sysfs-class.workspace = true
 
 [dev-dependencies]
 gif.workspace = true
 tinybmp.workspace = true
 glam.workspace = true
 rog_dbus = { path = "../rog-dbus" }
+
+cargo-husky.workspace = true

asusctl/examples/anime-diag-png.rs

@@ -1,12 +1,16 @@
-use std::{env, error::Error, path::Path, process::exit};
+use std::env;
+use std::error::Error;
+use std::path::Path;
+use std::process::exit;
 
-use rog_anime::{usb::get_anime_type, AnimeDiagonal, AnimeType};
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDiagonal, AnimeType};
 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

@@ -1,6 +1,8 @@
-use std::{thread::sleep, time::Duration};
+use std::thread::sleep;
+use std::time::Duration;
 
-use rog_anime::{usb::get_anime_type, AnimeDiagonal, AnimeType};
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDiagonal, AnimeType};
 use rog_dbus::RogDbusClientBlocking;
 
 // In usable data:
@@ -13,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

@@ -1,12 +1,15 @@
-use std::{env, path::Path, thread::sleep};
+use std::env;
+use std::path::Path;
+use std::thread::sleep;
 
-use rog_anime::{usb::get_anime_type, ActionData, ActionLoader, Sequences};
+use rog_anime::usb::get_anime_type;
+use rog_anime::{ActionData, ActionLoader, Sequences};
 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-grid.rs

@@ -1,7 +1,9 @@
-use rog_anime::{usb::get_anime_type, AnimeDataBuffer, AnimeGrid};
-use rog_dbus::RogDbusClientBlocking;
 use std::convert::TryFrom;
 
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDataBuffer, AnimeGrid};
+use rog_dbus::RogDbusClientBlocking;
+
 // In usable data:
 // Top row start at 1, ends at 32
 

asusctl/examples/anime-outline.rs

@@ -1,4 +1,5 @@
-use rog_anime::{usb::get_anime_type, AnimeDataBuffer};
+use rog_anime::usb::get_anime_type;
+use rog_anime::AnimeDataBuffer;
 use rog_dbus::RogDbusClientBlocking;
 
 // In usable data:

asusctl/examples/anime-png.rs

@@ -1,16 +1,17 @@
 use std::convert::TryFrom;
-use std::{env, error::Error, path::Path, process::exit};
+use std::env;
+use std::error::Error;
+use std::path::Path;
+use std::process::exit;
 
-use rog_anime::{
-    usb::get_anime_type,
-    AnimeDataBuffer, {AnimeImage, Vec2},
-};
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDataBuffer, AnimeImage, Vec2};
 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

@@ -1,18 +1,20 @@
 use std::convert::TryFrom;
-use std::{
-    env, error::Error, f32::consts::PI, path::Path, process::exit, thread::sleep, time::Duration,
-};
+use std::env;
+use std::error::Error;
+use std::f32::consts::PI;
+use std::path::Path;
+use std::process::exit;
+use std::thread::sleep;
+use std::time::Duration;
 
-use rog_anime::{
-    usb::get_anime_type,
-    AnimeDataBuffer, {AnimeImage, Vec2},
-};
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDataBuffer, AnimeImage, Vec2};
 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-rgb-ball.rs-

@@ -106,7 +106,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 c[2] = 255;
             };
         }
-        dbus.proxies().led().per_key_raw(colours.get())?;
+        dbus.proxies().led().direct_addressing_raw(colours.get())?;
 
         std::thread::sleep(std::time::Duration::from_millis(150));
     }

asusctl/examples/aura-rgb-breathe.rs

@@ -1,59 +0,0 @@
-//! Using a combination of key-colour array plus a key layout to generate outputs.
-
-use rog_aura::{keys::Key, layouts::KeyLayout, Breathe, Colour, Effect, LedType, Sequences, Speed};
-use rog_dbus::RogDbusClientBlocking;
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let layout = KeyLayout::gx502_layout();
-
-    let (client, _) = RogDbusClientBlocking::new().unwrap();
-
-    let mut seq = Sequences::new();
-    let mut key = Effect::Breathe(Breathe::new(
-        LedType::Key(Key::W),
-        Colour(255, 127, 0),
-        Colour(127, 0, 255),
-        Speed::Med,
-    ));
-
-    seq.push(key.clone());
-    key.set_led_type(LedType::Key(Key::A));
-    seq.push(key.clone());
-    key.set_led_type(LedType::Key(Key::S));
-    seq.push(key.clone());
-    key.set_led_type(LedType::Key(Key::D));
-    seq.push(key.clone());
-
-    let mut key = Effect::Breathe(Breathe::new(
-        LedType::Key(Key::Q),
-        Colour(127, 127, 127),
-        Colour(127, 255, 255),
-        Speed::Low,
-    ));
-    seq.push(key.clone());
-    key.set_led_type(LedType::Key(Key::E));
-    seq.push(key.clone());
-
-    let mut key = Effect::Breathe(Breathe::new(
-        LedType::Key(Key::N1),
-        Colour(166, 127, 166),
-        Colour(127, 155, 20),
-        Speed::High,
-    ));
-    key.set_led_type(LedType::Key(Key::Tilde));
-    seq.push(key.clone());
-    key.set_led_type(LedType::Key(Key::N2));
-    seq.push(key.clone());
-    key.set_led_type(LedType::Key(Key::N3));
-    seq.push(key.clone());
-    key.set_led_type(LedType::Key(Key::N4));
-    seq.push(key.clone());
-
-    loop {
-        seq.next_state(&layout);
-        let packets = seq.create_packets();
-
-        client.proxies().led().per_key_raw(packets)?;
-        std::thread::sleep(std::time::Duration::from_millis(60));
-    }
-}

asusctl/examples/aura-rgb-iterate-keys.rs

@@ -1,34 +0,0 @@
-//! Using a combination of key-colour array plus a key layout to generate outputs.
-
-use rog_aura::{layouts::KeyLayout, KeyColourArray};
-use rog_dbus::RogDbusClientBlocking;
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let (client, _) = RogDbusClientBlocking::new().unwrap();
-    let layout = KeyLayout::gx502_layout();
-    loop {
-        let mut key_colours = KeyColourArray::new();
-        for row in layout.rows() {
-            for (k, key) in row.row().enumerate() {
-                if k != 0 {
-                    if let Some(prev) = row.row().nth(k - 1) {
-                        if let Some(c) = key_colours.rgb_for_key(*prev) {
-                            c[0] = 0;
-                        };
-                    }
-                }
-
-                if key.is_placeholder() {
-                    continue;
-                }
-
-                if let Some(c) = key_colours.rgb_for_key(*key) {
-                    c[0] = 255;
-                };
-
-                client.proxies().led().per_key_raw(key_colours.get())?;
-                std::thread::sleep(std::time::Duration::from_millis(100));
-            }
-        }
-    }
-}

asusctl/examples/aura-zoned-breathe.rs

@@ -1,44 +1,68 @@
-//! Using a combination of key-colour array plus a key layout to generate outputs.
+//! Using a combination of key-colour array plus a key layout to generate
+//! outputs.
 
-use rog_aura::{layouts::KeyLayout, Breathe, Colour, Effect, LedType, PerZone, Sequences, Speed};
+use rog_aura::advanced::LedCode;
+use rog_aura::effects::{AdvancedEffects, Effect};
+use rog_aura::layouts::KeyLayout;
+use rog_aura::Colour;
 use rog_dbus::RogDbusClientBlocking;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let layout = KeyLayout::gx502_layout();
+    let layout = KeyLayout::default_layout();
 
     let (client, _) = RogDbusClientBlocking::new().unwrap();
 
-    let mut seq = Sequences::new();
+    let mut seq = AdvancedEffects::new(true);
 
-    let zone = Effect::Breathe(Breathe::new(
-        LedType::Zone(PerZone::KeyboardLeft),
-        Colour(166, 127, 166),
-        Colour(127, 155, 20),
-        Speed::High,
+    // let zone = Effect::Breathe(rog_aura::effects::Breathe::new(
+    //     RgbAddress::Single,
+    //     Colour(166, 127, 166),
+    //     Colour(127, 155, 20),
+    //     rog_aura::Speed::High,
+    // ));
+    // seq.push(zone);
+
+    // let zone = Effect::DoomLightFlash(rog_aura::effects::DoomLightFlash::new(
+    //     RgbAddress::Single,
+    //     Colour(200, 0, 0),
+    //     80,
+    //     10,
+    // ));
+    // seq.push(zone);
+
+    let zone = Effect::DoomFlicker(rog_aura::effects::DoomFlicker::new(
+        LedCode::SingleZone,
+        Colour {
+            r: 200,
+            g: 110,
+            b: 0,
+        },
+        100,
+        10,
     ));
     seq.push(zone);
 
-    let zone = Effect::Breathe(Breathe::new(
-        LedType::Zone(PerZone::KeyboardCenterLeft),
-        Colour(16, 127, 255),
-        Colour(127, 15, 20),
-        Speed::Low,
-    ));
-    seq.push(zone);
+    // let zone = Effect::Breathe(rog_aura::effects::Breathe::new(
+    //     RgbAddress::KeyboardCenterLeft,
+    //     Colour(16, 127, 255),
+    //     Colour(127, 15, 20),
+    //     rog_aura::Speed::Low,
+    // ));
+    // seq.push(zone);
 
-    let zone = Effect::Breathe(Breathe::new(
-        LedType::Zone(PerZone::LightbarRightCorner),
-        Colour(0, 255, 255),
-        Colour(255, 0, 255),
-        Speed::Med,
-    ));
-    seq.push(zone);
+    // let zone = Effect::Breathe(rog_aura::effects::Breathe::new(
+    //     RgbAddress::LightbarRightCorner,
+    //     Colour(0, 255, 255),
+    //     Colour(255, 0, 255),
+    //     rog_aura::Speed::Med,
+    // ));
+    // seq.push(zone);
 
     loop {
         seq.next_state(&layout);
         let packets = seq.create_packets();
 
-        client.proxies().led().per_key_raw(packets)?;
-        std::thread::sleep(std::time::Duration::from_millis(60));
+        client.proxies().aura().direct_addressing_raw(packets)?;
+        std::thread::sleep(std::time::Duration::from_millis(33));
     }
 }

asusctl/src/anime_cli.rs

@@ -1,23 +1,44 @@
 use gumdrop::Options;
+use rog_anime::usb::{AnimAwake, AnimBooting, AnimShutdown, AnimSleeping, Brightness};
+use rog_anime::AnimeType;
 
 #[derive(Options)]
 pub struct AnimeCommand {
     #[options(help = "print help message")]
     pub help: bool,
+    #[options(meta = "", help = "override the display type")]
+    pub override_type: Option<AnimeType>,
+    #[options(meta = "", help = "enable/disable the display")]
+    pub enable_display: Option<bool>,
+    #[options(meta = "", help = "enable/disable the builtin run/powersave animation")]
+    pub enable_powersave_anim: Option<bool>,
     #[options(
         meta = "",
-        help = "enable/disable the panel LEDs (does not erase last image)"
+        help = "set global base brightness value <Off, Low, Med, High>"
     )]
-    pub enable: Option<bool>,
-    #[options(
-        meta = "",
-        help = "enable/disable system animations (boot/sleep/shutdown)"
-    )]
-    pub boot_enable: Option<bool>,
-    #[options(meta = "", help = "set global AniMe brightness value")]
-    pub brightness: Option<f32>,
+    pub brightness: Option<Brightness>,
     #[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>,
 }
@@ -32,6 +53,36 @@ pub enum AnimeActions {
     Gif(AnimeGif),
     #[options(help = "display an animated diagonal/pixel-perfect GIF")]
     PixelGif(AnimeGifDiagonal),
+    #[options(help = "change which builtin animations are shown")]
+    SetBuiltins(Builtins),
+}
+
+#[derive(Options)]
+pub struct Builtins {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(
+        meta = "",
+        help = "Default is used if unspecified, <default:GlitchConstruction, StaticEmergence>"
+    )]
+    pub boot: AnimBooting,
+    #[options(
+        meta = "",
+        help = "Default is used if unspecified, <default:BinaryBannerScroll, RogLogoGlitch>"
+    )]
+    pub awake: AnimAwake,
+    #[options(
+        meta = "",
+        help = "Default is used if unspecified, <default:BannerSwipe, Starfield>"
+    )]
+    pub sleep: AnimSleeping,
+    #[options(
+        meta = "",
+        help = "Default is used if unspecified, <default:GlitchOut, SeeYa>"
+    )]
+    pub shutdown: AnimShutdown,
+    #[options(meta = "", help = "set/apply the animations <true/false>")]
+    pub set: Option<bool>,
 }
 
 #[derive(Options)]

asusctl/src/aura_cli.rs

@@ -1,8 +1,10 @@
-use gumdrop::Options;
-use rog_aura::{error::Error, AuraEffect, AuraModeNum, AuraZone, Colour, Direction, Speed};
 use std::str::FromStr;
 
-#[derive(Options)]
+use gumdrop::Options;
+use rog_aura::error::Error;
+use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour, Direction, Speed};
+
+#[derive(Options, Debug)]
 pub struct LedPowerCommand1 {
     #[options(help = "print help message")]
     pub help: bool,
@@ -18,65 +20,53 @@ pub struct LedPowerCommand1 {
     pub sleep: Option<bool>,
 }
 
-#[derive(Options)]
+#[derive(Options, Debug)]
 pub struct LedPowerCommand2 {
     #[options(help = "print help message")]
     pub help: bool,
     #[options(command)]
-    pub command: Option<SetAuraEnabled>,
+    pub command: Option<SetAuraZoneEnabled>,
 }
 
-#[derive(Options)]
-pub enum SetAuraEnabled {
+#[derive(Options, Debug)]
+pub enum SetAuraZoneEnabled {
     /// Applies to both old and new models
-    #[options(help = "set <keyboard, logo, lightbar> to enabled while device is awake")]
-    Awake(AuraEnabled),
-    #[options(help = "set <keyboard, logo, lightbar> to enabled while the device is booting")]
-    Boot(AuraEnabled),
-    #[options(help = "set <keyboard, logo, lightbar> to animate while the device is suspended")]
-    Sleep(AuraEnabled),
-    #[options(help = "set <keyboard, logo, lightbar> to animate while the device is shutdown")]
-    Shutdown(AuraEnabled),
+    #[options(help = "")]
+    Keyboard(AuraPowerStates),
+    #[options(help = "")]
+    Logo(AuraPowerStates),
+    #[options(help = "")]
+    Lightbar(AuraPowerStates),
+    #[options(help = "")]
+    Lid(AuraPowerStates),
+    #[options(help = "")]
+    RearGlow(AuraPowerStates),
 }
 
-#[derive(Debug, Clone, Default, Options)]
-pub struct AuraEnabled {
+#[derive(Debug, Clone, Options)]
+pub struct AuraPowerStates {
     #[options(help = "print help message")]
     pub help: bool,
-    #[options(meta = "", help = "<true/false>")]
-    pub keyboard: Option<bool>,
-    #[options(meta = "", help = "<true/false>")]
-    pub logo: Option<bool>,
-    #[options(meta = "", help = "<true/false>")]
-    pub lightbar: Option<bool>,
-    #[options(meta = "", help = "<true/false>")]
-    pub lid: Option<bool>,
+    #[options(help = "defaults to false if option unused")]
+    pub boot: bool,
+    #[options(help = "defaults to false if option unused")]
+    pub awake: bool,
+    #[options(help = "defaults to false if option unused")]
+    pub sleep: bool,
+    #[options(help = "defaults to false if option unused")]
+    pub shutdown: bool,
 }
 
-// impl FromStr for AuraEnabled {
-//     type Err = Error;
-
-//     fn from_str(s: &str) -> Result<Self, Self::Err> {
-//         let s = s.to_lowercase();
-//         Ok(Self {
-//             help: false,
-//             keyboard: None,
-//             logo: None,
-//             lightbar: None,
-//         })
-//     }
-// }
-
 #[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
     }
 }
@@ -220,7 +210,6 @@ pub struct MultiColourSpeed {
 /// Byte value for setting the built-in mode.
 ///
 /// Enum corresponds to the required integer value
-///
 // NOTE: The option names here must match those in rog-aura crate
 #[derive(Options)]
 pub enum SetAuraBuiltin {

asusctl/src/cli_opts.rs

@@ -1,9 +1,9 @@
-use crate::{
-    anime_cli::AnimeCommand,
-    aura_cli::{LedBrightness, LedPowerCommand1, LedPowerCommand2, SetAuraBuiltin},
-    profiles_cli::{FanCurveCommand, ProfileCommand},
-};
 use gumdrop::Options;
+use rog_platform::platform::PlatformPolicy;
+
+use crate::anime_cli::AnimeCommand;
+use crate::aura_cli::{LedBrightness, LedPowerCommand1, LedPowerCommand2, SetAuraBuiltin};
+use crate::fan_curve_cli::FanCurveCommand;
 
 #[derive(Default, Options)]
 pub struct CliStart {
@@ -45,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")]
@@ -71,7 +89,7 @@ pub struct BiosCommand {
         meta = "",
         short = "S",
         no_long,
-        help = "set bios POST sound: asusctl -p <true/false>"
+        help = "set bios POST sound: asusctl -S <true/false>"
     )]
     pub post_sound_set: Option<bool>,
     #[options(no_long, short = "s", help = "read bios POST sound")]

asusctl/src/fan_curve_cli.rs

@@ -0,0 +1,49 @@
+use gumdrop::Options;
+use rog_platform::platform::PlatformPolicy;
+use rog_profiles::fan_curve_set::CurveData;
+use rog_profiles::FanCurvePU;
+
+#[derive(Debug, Clone, Options)]
+pub struct FanCurveCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+
+    #[options(help = "get enabled fan profiles")]
+    pub get_enabled: bool,
+
+    #[options(help = "set the active profile's fan curve to default")]
+    pub default: bool,
+
+    #[options(
+        meta = "",
+        help = "profile to modify fan-curve for. Shows data if no options provided"
+    )]
+    pub mod_profile: Option<PlatformPolicy>,
+
+    #[options(
+        meta = "",
+        help = "enable or disable <true/false> fan all curves for a profile. `--mod_profile` \
+                required"
+    )]
+    pub enable_fan_curves: Option<bool>,
+
+    #[options(
+        meta = "",
+        help = "enable or disable <true/false> a single fan curve for a profile. `--mod_profile` \
+                and `--fan` required"
+    )]
+    pub enable_fan_curve: Option<bool>,
+
+    #[options(
+        meta = "",
+        help = "select fan <cpu/gpu/mid> to modify. `--mod_profile` required"
+    )]
+    pub fan: Option<FanCurvePU>,
+
+    #[options(
+        meta = "",
+        help = "data format = 30c:1%,49c:2%,59c:3%,69c:4%,79c:31%,89c:49%,99c:56%,109c:58%. \
+                `--mod-profile` required. If '%' is omitted the fan range is 0-255"
+    )]
+    pub data: Option<CurveData>,
+}

asusctl/src/main.rs

@@ -1,30 +1,33 @@
 use std::convert::TryFrom;
+use std::env::args;
+use std::path::Path;
 use std::process::Command;
 use std::thread::sleep;
-use std::{env::args, path::Path};
-
-use aura_cli::{LedPowerCommand1, LedPowerCommand2};
-use gumdrop::{Opt, Options};
 
 use anime_cli::{AnimeActions, AnimeCommand};
-use profiles_cli::{FanCurveCommand, ProfileCommand};
+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 rog_anime::usb::get_anime_type;
-use rog_anime::{AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, Vec2};
-
-use rog_aura::usb::{AuraDev1866, AuraDev19b6, AuraDevTuf, AuraDevice, AuraPowerDev};
+use rog_anime::{AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, AnimeType, Vec2};
+use rog_aura::power::KbAuraPowerState;
+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::LedBrightness;
+use crate::aura_cli::{AuraPowerStates, LedBrightness};
 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();
@@ -37,70 +40,51 @@ fn main() {
             ..Default::default()
         },
         Err(err) => {
-            eprintln!("source {}", err);
-            std::process::exit(2);
+            println!("Error: {}", err);
+            return;
         }
     };
 
-    let (dbus, _) = RogDbusClientBlocking::new()
-        .map_err(|e| {
-            print_error_help(&e, None);
-            std::process::exit(3);
-        })
-        .unwrap();
+    if let Ok((dbus, _)) = RogDbusClientBlocking::new().map_err(|e| {
+        check_service("asusd");
+        println!("\nError: {e}\n");
+        print_info();
+    }) {
+        let supported_properties = dbus.proxies().platform().supported_properties().unwrap();
+        let supported_interfaces = dbus.proxies().platform().supported_interfaces().unwrap();
 
-    let supported = dbus
-        .proxies()
-        .supported()
-        .supported_functions()
-        .map_err(|e| {
-            print_error_help(&e, None);
-            std::process::exit(4);
-        })
-        .unwrap();
+        if parsed.version {
+            println!("asusctl v{}", env!("CARGO_PKG_VERSION"));
+            println!();
+            print_info();
+        }
 
-    if parsed.version {
-        print_versions();
-        println!();
-        print_laptop_info();
-    }
-
-    if let Err(err) = do_parsed(&parsed, &supported, &dbus) {
-        print_error_help(&*err, Some(&supported));
+        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_versions();
+    print_info();
     println!();
-    print_laptop_info();
-    if let Some(supported) = supported {
-        println!();
-        println!("Supported laptop functions:\n\n{}", supported);
-    }
+    println!("Supported interfaces:\n\n{:#?}\n", supported_interfaces);
+    println!("Supported properties:\n\n{:#?}\n", supported_properties);
 }
 
-fn print_versions() {
-    println!("App and daemon versions:");
-    println!("      asusctl v{}", env!("CARGO_PKG_VERSION"));
-    println!("        asusd v{}", daemon::VERSION);
-    println!("\nComponent crate versions:");
-    println!("    rog-anime v{}", rog_anime::VERSION);
-    println!("     rog-aura v{}", rog_aura::VERSION);
-    println!("     rog-dbus v{}", rog_dbus::VERSION);
-    println!(" rog-profiles v{}", rog_profiles::VERSION);
-    println!("rog-platform v{}", rog_platform::VERSION);
-}
-
-fn print_laptop_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");
-
-    println!("Product family: {}", prod_family.trim());
-    println!("Board name: {}", board_name.trim());
+fn print_info() {
+    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());
 }
 
 fn check_service(name: &str) -> bool {
@@ -122,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()
@@ -149,19 +134,14 @@ fn do_parsed(
                 if let Some(cmdlist) = CliStart::command_list() {
                     let commands: Vec<String> = cmdlist.lines().map(|s| s.to_owned()).collect();
                     for command in commands.iter().filter(|command| {
-                        if !matches!(
-                            supported.keyboard_led.prod_id,
-                            AuraDevice::X1854
-                                | AuraDevice::X1869
-                                | AuraDevice::X1866
-                                | AuraDevice::Tuf
-                        ) && command.trim().starts_with("led-pow-1")
+                        let dev_type = dbus.proxies().aura().device_type().unwrap();
+                        if !dev_type.is_old_style()
+                            && !dev_type.is_tuf_style()
+                            && command.trim().starts_with("led-pow-1")
                         {
                             return false;
                         }
-                        if supported.keyboard_led.prod_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
@@ -180,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)?;
     }
 
@@ -212,19 +195,26 @@ fn do_parsed(
 }
 
 fn do_gfx() {
-    println!("Please use supergfxctl for graphics switching. supergfxctl is the result of making asusctl graphics switching generic so all laptops can use it");
+    println!(
+        "Please use supergfxctl for graphics switching. supergfxctl is the result of making \
+         asusctl graphics switching generic so all laptops can use it"
+    );
     println!("This command will be removed in future");
 }
 
 fn handle_anime(
     dbus: &RogDbusClientBlocking<'_>,
-    _supported: &AnimeSupportedFunctions,
     cmd: &AnimeCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
     if (cmd.command.is_none()
-        && cmd.enable.is_none()
-        && cmd.boot_enable.is_none()
-        && cmd.brightness.is_none())
+        && cmd.enable_display.is_none()
+        && cmd.enable_powersave_anim.is_none()
+        && cmd.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
     {
         println!("Missing arg or command\n\n{}", cmd.self_usage());
@@ -232,25 +222,42 @@ fn handle_anime(
             println!("\n{}", lst);
         }
     }
-    if let Some(anime_turn) = cmd.enable {
-        dbus.proxies().anime().set_on_off(anime_turn)?;
+    if let Some(enable) = cmd.enable_display {
+        dbus.proxies().anime().set_enable_display(enable)?;
     }
-    if let Some(anime_boot) = cmd.boot_enable {
-        dbus.proxies().anime().set_boot_on_off(anime_boot)?;
+    if let Some(enable) = cmd.enable_powersave_anim {
+        dbus.proxies().anime().set_builtins_enabled(enable)?;
     }
     if let Some(bright) = cmd.brightness {
-        verify_brightness(bright);
         dbus.proxies().anime().set_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()?;
+    if let AnimeType::Unknown = anime_type {
+        if let Some(model) = cmd.override_type {
+            anime_type = model;
+        }
+    }
+
     if cmd.clear {
-        let anime_type = get_anime_type()?;
-        let data = vec![0u8; anime_type.data_length()];
+        let data = vec![255u8; anime_type.data_length()];
         let tmp = AnimeDataBuffer::from_vec(anime_type, data)?;
         dbus.proxies().anime().write(tmp)?;
     }
 
     if let Some(action) = cmd.command.as_ref() {
-        let anime_type = get_anime_type()?;
         match action {
             AnimeActions::Image(image) => {
                 if image.help_requested() || image.path.is_empty() {
@@ -258,7 +265,7 @@ fn handle_anime(
                     if let Some(lst) = image.self_command_list() {
                         println!("\n{}", lst);
                     }
-                    std::process::exit(1);
+                    return Ok(());
                 }
                 verify_brightness(image.bright);
 
@@ -281,7 +288,7 @@ fn handle_anime(
                     if let Some(lst) = image.self_command_list() {
                         println!("\n{}", lst);
                     }
-                    std::process::exit(1);
+                    return Ok(());
                 }
                 verify_brightness(image.bright);
 
@@ -302,7 +309,7 @@ fn handle_anime(
                     if let Some(lst) = gif.self_command_list() {
                         println!("\n{}", lst);
                     }
-                    std::process::exit(1);
+                    return Ok(());
                 }
                 verify_brightness(gif.bright);
 
@@ -336,7 +343,7 @@ fn handle_anime(
                     if let Some(lst) = gif.self_command_list() {
                         println!("\n{}", lst);
                     }
-                    std::process::exit(1);
+                    return Ok(());
                 }
                 verify_brightness(gif.bright);
 
@@ -361,6 +368,25 @@ fn handle_anime(
                     }
                 }
             }
+            AnimeActions::SetBuiltins(builtins) => {
+                if builtins.help_requested() || builtins.set.is_none() {
+                    println!("\nAny unspecified args will be set to default (first shown var)\n");
+                    println!("\n{}", builtins.self_usage());
+                    if let Some(lst) = builtins.self_command_list() {
+                        println!("\n{}", lst);
+                    }
+                    return Ok(());
+                }
+
+                dbus.proxies()
+                    .anime()
+                    .set_builtin_animations(rog_anime::Animations {
+                        boot: builtins.boot,
+                        awake: builtins.awake,
+                        sleep: builtins.sleep,
+                        shutdown: builtins.shutdown,
+                    })?;
+            }
         }
     }
     Ok(())
@@ -372,15 +398,19 @@ fn verify_brightness(brightness: f32) {
             "Image and global brightness must be between 0.0 and 1.0 (inclusive), was {}",
             brightness
         );
-        std::process::exit(1);
     }
 }
 
 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");
@@ -389,9 +419,10 @@ fn handle_led_mode(
         println!("Commands available");
 
         if let Some(cmdlist) = LedModeCommand::command_list() {
-            let commands: Vec<String> = cmdlist.lines().map(|s| s.to_string()).collect();
+            let commands: Vec<String> = cmdlist.lines().map(|s| s.to_owned()).collect();
             for command in commands.iter().filter(|command| {
-                for mode in &supported.stock_led_modes {
+                let modes = dbus.proxies().aura().supported_modes().unwrap();
+                for mode in &modes {
                     if command
                         .trim()
                         .starts_with(&<&str>::from(mode).to_lowercase())
@@ -399,9 +430,10 @@ fn handle_led_mode(
                         return true;
                     }
                 }
-                if !supported.multizone_led_mode.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);
@@ -417,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_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_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(())
@@ -435,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()
@@ -451,15 +506,12 @@ fn handle_led_power1(
         return Ok(());
     }
 
-    if matches!(
-        supported.prod_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.prod_id, AuraDevice::Tuf) {
+    if dev_type.is_tuf_style() {
         handle_led_power_1_do_tuf(dbus, power)?;
         return Ok(());
     }
@@ -472,10 +524,10 @@ fn handle_led_power_1_do_1866(
     dbus: &RogDbusClientBlocking<'_>,
     power: &LedPowerCommand1,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    let mut enabled: Vec<AuraDev1866> = Vec::new();
-    let mut disabled: Vec<AuraDev1866> = Vec::new();
+    let mut enabled: Vec<AuraDevRog1> = Vec::new();
+    let mut disabled: Vec<AuraDevRog1> = Vec::new();
 
-    let mut check = |e: Option<bool>, a: AuraDev1866| {
+    let mut check = |e: Option<bool>, a: AuraDevRog1| {
         if let Some(arg) = e {
             if arg {
                 enabled.push(a);
@@ -485,25 +537,23 @@ fn handle_led_power_1_do_1866(
         }
     };
 
-    check(power.awake, AuraDev1866::Awake);
-    check(power.boot, AuraDev1866::Boot);
-    check(power.sleep, AuraDev1866::Sleep);
-    check(power.keyboard, AuraDev1866::Keyboard);
-    check(power.lightbar, AuraDev1866::Lightbar);
+    check(power.awake, AuraDevRog1::Awake);
+    check(power.boot, AuraDevRog1::Boot);
+    check(power.sleep, AuraDevRog1::Sleep);
+    check(power.keyboard, AuraDevRog1::Keyboard);
+    check(power.lightbar, AuraDevRog1::Lightbar);
 
     let data = AuraPowerDev {
-        x1866: enabled,
-        x19b6: vec![],
-        tuf: vec![],
+        old_rog: enabled,
+        ..Default::default()
     };
-    dbus.proxies().led().set_leds_power(data, true)?;
+    dbus.proxies().aura().set_led_power((data, true))?;
 
     let data = AuraPowerDev {
-        x1866: disabled,
-        x19b6: vec![],
-        tuf: vec![],
+        old_rog: disabled,
+        ..Default::default()
     };
-    dbus.proxies().led().set_leds_power(data, false)?;
+    dbus.proxies().aura().set_led_power((data, false))?;
 
     Ok(())
 }
@@ -531,27 +581,34 @@ fn handle_led_power_1_do_tuf(
     check(power.keyboard, AuraDevTuf::Keyboard);
 
     let data = AuraPowerDev {
-        x1866: vec![],
-        x19b6: vec![],
         tuf: enabled,
+        ..Default::default()
     };
-    dbus.proxies().led().set_leds_power(data, true)?;
+    dbus.proxies().aura().set_led_power((data, true))?;
 
     let data = AuraPowerDev {
-        x1866: vec![],
-        x19b6: vec![],
         tuf: disabled,
+        ..Default::default()
     };
-    dbus.proxies().led().set_leds_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");
@@ -576,77 +633,36 @@ fn handle_led_power2(
             return Ok(());
         }
 
-        if supported.prod_id != AuraDevice::X19B6 {
-            println!("This option applies only to keyboards with product ID 0x19b6");
-        }
-
-        let mut enabled: Vec<AuraDev19b6> = Vec::new();
-        let mut disabled: Vec<AuraDev19b6> = Vec::new();
-        let mut check = |e: Option<bool>, a: AuraDev19b6| {
-            if let Some(arg) = e {
-                if arg {
-                    enabled.push(a);
-                } else {
-                    disabled.push(a);
-                }
-            }
+        let set = |power: &mut KbAuraPowerState, set_to: &AuraPowerStates| {
+            power.boot = set_to.boot;
+            power.awake = set_to.awake;
+            power.sleep = set_to.sleep;
+            power.shutdown = set_to.shutdown;
         };
 
-        match pow {
-            aura_cli::SetAuraEnabled::Boot(arg) => {
-                check(arg.keyboard, AuraDev19b6::BootKeyb);
-                check(arg.logo, AuraDev19b6::BootLogo);
-                check(arg.lightbar, AuraDev19b6::BootBar);
-                check(arg.lid, AuraDev19b6::AwakeLid);
-            }
-            aura_cli::SetAuraEnabled::Sleep(arg) => {
-                check(arg.keyboard, AuraDev19b6::SleepKeyb);
-                check(arg.logo, AuraDev19b6::SleepLogo);
-                check(arg.lightbar, AuraDev19b6::SleepBar);
-                check(arg.lid, AuraDev19b6::SleepLid);
-            }
-            aura_cli::SetAuraEnabled::Awake(arg) => {
-                check(arg.keyboard, AuraDev19b6::AwakeKeyb);
-                check(arg.logo, AuraDev19b6::AwakeLogo);
-                check(arg.lightbar, AuraDev19b6::AwakeBar);
-                check(arg.lid, AuraDev19b6::AwakeLid);
-            }
-            aura_cli::SetAuraEnabled::Shutdown(arg) => {
-                check(arg.keyboard, AuraDev19b6::ShutdownKeyb);
-                check(arg.logo, AuraDev19b6::ShutdownLogo);
-                check(arg.lightbar, AuraDev19b6::ShutdownBar);
-                check(arg.lid, AuraDev19b6::ShutdownBar);
+        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),
+                aura_cli::SetAuraZoneEnabled::Logo(l) => set(&mut enabled.rog.logo, l),
+                aura_cli::SetAuraZoneEnabled::Lightbar(l) => set(&mut enabled.rog.lightbar, l),
+                aura_cli::SetAuraZoneEnabled::Lid(l) => set(&mut enabled.rog.lid, l),
+                aura_cli::SetAuraZoneEnabled::RearGlow(r) => set(&mut enabled.rog.rear_glow, r),
             }
         }
 
-        if !enabled.is_empty() {
-            let data = AuraPowerDev {
-                tuf: vec![],
-                x1866: vec![],
-                x19b6: enabled,
-            };
-            dbus.proxies().led().set_leds_power(data, true)?;
-        }
-
-        if !disabled.is_empty() {
-            let data = AuraPowerDev {
-                tuf: vec![],
-                x1866: vec![],
-                x19b6: disabled,
-            };
-            dbus.proxies().led().set_leds_power(data, false)?;
-        }
+        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::DgpuDisable) {
         println!("Profiles not supported by either this kernel or by the laptop.");
         return Err(ProfileError::NotSupported.into());
     }
@@ -660,25 +676,29 @@ fn handle_profile(
         if let Some(lst) = cmd.self_command_list() {
             println!("\n{}", lst);
         }
-        std::process::exit(1);
+        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(())
@@ -686,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.fan_curves {
+    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());
     }
 
@@ -704,51 +723,70 @@ fn handle_fan_curve(
         if let Some(lst) = cmd.self_command_list() {
             println!("\n{}", lst);
         }
-        std::process::exit(1);
+        return Ok(());
     }
 
-    if (cmd.enabled.is_some() || cmd.fan.is_some() || cmd.data.is_some())
+    if (cmd.enable_fan_curves.is_some() || cmd.fan.is_some() || cmd.data.is_some())
         && cmd.mod_profile.is_none()
     {
-        println!("--enabled, --fan, and --data options require --mod-profile");
-        std::process::exit(666);
+        println!(
+            "--enable-fan-curves, --enable-fan-curve, --fan, and --data options require \
+             --mod-profile"
+        );
+        return Ok(());
     }
 
     if cmd.get_enabled {
-        let res = dbus.proxies().profile().enabled_fan_profiles()?;
-        println!("{:?}", res);
+        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.enabled.is_none() && cmd.data.is_none() {
-            let data = dbus.proxies().profile().fan_curve_data(profile)?;
+        if cmd.enable_fan_curves.is_none() && cmd.data.is_none() {
+            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.enabled {
+        if let Some(enabled) = cmd.enable_fan_curves {
             dbus.proxies()
-                .profile()
-                .set_fan_curve_enabled(profile, enabled)?;
+                .fan_curves()
+                .set_fan_curves_enabled(profile, enabled)?;
+        }
+
+        if let Some(enabled) = cmd.enable_fan_curve {
+            if let Some(fan) = cmd.fan {
+                dbus.proxies()
+                    .fan_curves()
+                    .set_profile_fan_curve_enabled(profile, fan, enabled)?;
+            } else {
+                println!(
+                    "--enable-fan-curves, --enable-fan-curve, --fan, and --data options require \
+                     --mod-profile"
+                );
+            }
         }
 
         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>> {
     {
@@ -765,39 +803,42 @@ 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 required change");
+            println!(
+                "The mode change is not active until you reboot, on boot the bios will make the \
+                 required change"
+            );
         }
         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);
         }
     }

asusctl/src/profiles_cli.rs

@@ -1,51 +0,0 @@
-use gumdrop::Options;
-use rog_profiles::{fan_curve_set::CurveData, 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>,
-}
-
-#[derive(Debug, Clone, Options)]
-pub struct FanCurveCommand {
-    #[options(help = "print help message")]
-    pub help: bool,
-
-    #[options(help = "get enabled fan profiles")]
-    pub get_enabled: bool,
-    #[options(help = "set the active profile's fan curve to default")]
-    pub default: bool,
-
-    #[options(
-        meta = "",
-        help = "profile to modify fan-curve for. Shows data if no options provided"
-    )]
-    pub mod_profile: Option<Profile>,
-    #[options(
-        meta = "",
-        help = "enable or disable <true/false> fan curve. `mod-profile` required"
-    )]
-    pub enabled: Option<bool>,
-    #[options(
-        meta = "",
-        help = "select fan <cpu/gpu> to modify. `mod-profile` required"
-    )]
-    pub fan: Option<FanCurvePU>,
-
-    #[options(
-        meta = "",
-        help = "data format = 30c:1%,49c:2%,59c:3%,69c:4%,79c:31%,89c:49%,99c:56%,109c:58%.
-                      `--mod-profile` required. If '%' is omitted the fan range is 0-255"
-    )]
-    pub data: Option<CurveData>,
-}

asusd-user/Cargo.toml

@@ -1,15 +1,11 @@
 [package]
-name = "daemon-user"
+name = "asusd-user"
 license = "MPL-2.0"
 version.workspace = true
 authors = ["Luke D Jones <luke@ljones.dev>"]
 edition = "2021"
 description = "Usermode daemon for user settings, anime, per-key lighting"
 
-[lib]
-name = "rog_user"
-path = "src/lib.rs"
-
 [[bin]]
 name = "asusd-user"
 path = "src/daemon.rs"
@@ -27,5 +23,13 @@ rog_anime = { path = "../rog-anime" }
 rog_aura = { path = "../rog-aura" }
 rog_dbus = { path = "../rog-dbus" }
 rog_platform = { path = "../rog-platform" }
+config-traits = { path = "../config-traits" }
 
 zbus.workspace = true
+
+# cli and logging
+log.workspace = true
+env_logger.workspace = true
+
+[dev-dependencies]
+cargo-husky.workspace = true

asusd-user/src/config.rs

@@ -0,0 +1,232 @@
+use std::path::PathBuf;
+use std::time::Duration;
+
+use config_traits::{StdConfig, StdConfigLoad};
+use rog_anime::{ActionLoader, AnimTime, AnimeType, Fade, Sequences as AnimeSequences, Vec2};
+use rog_aura::advanced::LedCode;
+use rog_aura::effects::{AdvancedEffects as AuraSequences, Breathe, DoomFlicker, Effect, Static};
+use rog_aura::{Colour, Speed};
+use serde_derive::{Deserialize, Serialize};
+
+use crate::error::Error;
+
+const ROOT_CONF_DIR: &str = "rog";
+
+fn root_conf_dir() -> PathBuf {
+    let mut dir = dirs::config_dir().unwrap_or_else(|| PathBuf::from("/tmp"));
+    dir.push(ROOT_CONF_DIR);
+    dir
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct ConfigAnime {
+    pub name: String,
+    pub anime: Vec<ActionLoader>,
+}
+
+impl ConfigAnime {
+    pub fn create(&self, anime_type: AnimeType) -> Result<AnimeSequences, Error> {
+        let mut seq = AnimeSequences::new(anime_type);
+
+        for (idx, action) in self.anime.iter().enumerate() {
+            seq.insert(idx, action)?;
+        }
+
+        Ok(seq)
+    }
+
+    pub fn set_name(mut self, name: String) -> Self {
+        self.name = name;
+        self
+    }
+}
+
+impl Default for ConfigAnime {
+    fn default() -> Self {
+        Self {
+            name: "anime-default".to_owned(),
+            anime: vec![
+                ActionLoader::AsusImage {
+                    file: "/usr/share/asusd/anime/custom/diagonal-template.png".into(),
+                    brightness: 1.0,
+                    time: AnimTime::Fade(Fade::new(
+                        Duration::from_secs(2),
+                        None,
+                        Duration::from_secs(2),
+                    )),
+                },
+                ActionLoader::AsusAnimation {
+                    file: "/usr/share/asusd/anime/asus/rog/Sunset.gif".into(),
+                    brightness: 0.5,
+                    time: AnimTime::Fade(Fade::new(
+                        Duration::from_secs(6),
+                        None,
+                        Duration::from_secs(3),
+                    )),
+                },
+                ActionLoader::ImageAnimation {
+                    file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
+                    scale: 0.9,
+                    angle: 0.65,
+                    translation: Vec2::default(),
+                    brightness: 0.5,
+                    time: AnimTime::Fade(Fade::new(
+                        Duration::from_secs(2),
+                        Some(Duration::from_secs(2)),
+                        Duration::from_secs(2),
+                    )),
+                },
+                ActionLoader::Image {
+                    file: "/usr/share/asusd/anime/custom/rust.png".into(),
+                    scale: 1.0,
+                    angle: 0.0,
+                    translation: Vec2::default(),
+                    time: AnimTime::Fade(Fade::new(
+                        Duration::from_secs(2),
+                        Some(Duration::from_secs(1)),
+                        Duration::from_secs(2),
+                    )),
+                    brightness: 0.6,
+                },
+                ActionLoader::Pause(Duration::from_secs(1)),
+                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: 0.5,
+                    time: AnimTime::Count(2),
+                },
+            ],
+        }
+    }
+}
+
+impl StdConfig for ConfigAnime {
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn file_name(&self) -> String {
+        format!("{}.ron", self.name)
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        root_conf_dir()
+    }
+}
+
+impl StdConfigLoad for ConfigAnime {}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct ConfigAura {
+    pub name: String,
+    pub aura: AuraSequences,
+}
+
+impl ConfigAura {
+    pub fn set_name(mut self, name: String) -> Self {
+        self.name = name;
+        self
+    }
+}
+
+impl Default for ConfigAura {
+    fn default() -> Self {
+        let mut seq = AuraSequences::new(false);
+        let mut key = Effect::Breathe(Breathe::new(
+            LedCode::W,
+            Colour {
+                r: 255,
+                g: 0,
+                b: 20,
+            },
+            Colour {
+                r: 20,
+                g: 255,
+                b: 0,
+            },
+            Speed::Low,
+        ));
+
+        seq.push(key.clone());
+        key.set_led(LedCode::A);
+        seq.push(key.clone());
+        key.set_led(LedCode::S);
+        seq.push(key.clone());
+        key.set_led(LedCode::D);
+        seq.push(key);
+
+        let key = Effect::Breathe(Breathe::new(
+            LedCode::F,
+            Colour { r: 255, g: 0, b: 0 },
+            Colour { r: 255, g: 0, b: 0 },
+            Speed::High,
+        ));
+        seq.push(key);
+
+        let mut key = Effect::Static(Static::new(LedCode::RCtrl, Colour { r: 0, g: 0, b: 255 }));
+        seq.push(key.clone());
+        key.set_led(LedCode::LCtrl);
+        seq.push(key.clone());
+        key.set_led(LedCode::Esc);
+        seq.push(key);
+
+        let key = Effect::DoomFlicker(DoomFlicker::new(
+            LedCode::N9,
+            Colour { r: 0, g: 0, b: 255 },
+            80,
+            40,
+        ));
+        seq.push(key);
+
+        Self {
+            name: "aura-default".to_owned(),
+            aura: seq,
+        }
+    }
+}
+
+impl StdConfig for ConfigAura {
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn file_name(&self) -> String {
+        format!("{}.ron", self.name)
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        root_conf_dir()
+    }
+}
+
+impl StdConfigLoad for ConfigAura {}
+
+#[derive(Debug, Default, Deserialize, Serialize)]
+#[serde(default)]
+pub struct ConfigBase {
+    /// Name of active anime config file in the user config directory
+    pub active_anime: Option<String>,
+    /// Name of active aura config file in the user config directory
+    pub active_aura: Option<String>,
+}
+
+impl StdConfig for ConfigBase {
+    fn new() -> Self {
+        Self {
+            active_anime: Some("anime-default".to_owned()),
+            active_aura: Some("aura-default".to_owned()),
+        }
+    }
+
+    fn file_name(&self) -> String {
+        "rog-user.ron".to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        root_conf_dir()
+    }
+}
+
+impl StdConfigLoad for ConfigBase {}

asusd-user/src/ctrl_anime.rs

@@ -1,46 +1,39 @@
+use std::path::Path;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+use std::thread::sleep;
+use std::time::{Duration, Instant};
+
+use config_traits::StdConfig;
 use rog_anime::error::AnimeError;
 use rog_anime::{ActionData, ActionLoader, AnimTime, Fade, Sequences, Vec2};
 use rog_dbus::RogDbusClientBlocking;
 use serde_derive::{Deserialize, Serialize};
-use std::time::Duration;
-use std::{
-    path::Path,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Mutex,
-    },
-};
-use std::{sync::Arc, thread::sleep, time::Instant};
-use zbus::{
-    dbus_interface,
-    zvariant::{ObjectPath, Type},
-};
+use zbus::dbus_interface;
+use zbus::zvariant::{ObjectPath, Type};
 
-use crate::user_config::ConfigLoadSave;
-use crate::{error::Error, user_config::UserAnimeConfig};
+use crate::config::ConfigAnime;
+use crate::error::Error;
 
 #[derive(Debug, Clone, Deserialize, Serialize, Type)]
 pub struct Timer {
     type_of: TimeType,
-    /// If time type is Timer then this is milliseonds, otherwise it is animation loop count
+    /// If time type is Timer then this is milliseonds, otherwise it is
+    /// animation loop count
     count: u64,
     /// Used only for `TimeType::Timer`, milliseonds to fade the image in for
-    fade_in: Option<u64>,
+    fade_in: u64,
     /// Used only for `TimeType::Timer`, milliseonds to fade the image out for
-    fade_out: Option<u64>,
+    fade_out: u64,
 }
 
 impl From<Timer> for AnimTime {
     fn from(time: Timer) -> Self {
         match time.type_of {
             TimeType::Timer => {
-                if time.fade_in.is_some() || time.fade_out.is_some() {
-                    let fade_in = time
-                        .fade_in
-                        .map_or(Duration::from_secs(0), Duration::from_millis);
-                    let fade_out = time
-                        .fade_out
-                        .map_or(Duration::from_secs(0), Duration::from_millis);
+                if time.fade_in != 0 && time.fade_out != 0 {
+                    let fade_in = Duration::from_millis(time.fade_in);
+                    let fade_out = Duration::from_millis(time.fade_out);
                     let show_for = if time.count != 0 {
                         Some(Duration::from_millis(time.count))
                     } else {
@@ -64,8 +57,8 @@ pub enum TimeType {
     Infinite,
 }
 
-/// The inner object exists to allow the zbus proxy to share it with a runner thread
-/// and a zbus server behind `Arc<Mutex<T>>`
+/// The inner object exists to allow the zbus proxy to share it with a runner
+/// thread and a zbus server behind `Arc<Mutex<T>>`
 pub struct CtrlAnimeInner<'a> {
     sequences: Sequences,
     client: RogDbusClientBlocking<'a>,
@@ -84,7 +77,9 @@ impl<'a> CtrlAnimeInner<'static> {
             do_early_return,
         })
     }
-    /// To be called on each main loop iteration to pump out commands to the anime
+
+    /// To be called on each main loop iteration to pump out commands to the
+    /// anime
     pub fn run(&'a self) -> Result<(), Error> {
         if self.do_early_return.load(Ordering::SeqCst) {
             return Ok(());
@@ -136,7 +131,7 @@ impl<'a> CtrlAnimeInner<'static> {
 }
 
 pub struct CtrlAnime<'a> {
-    config: Arc<Mutex<UserAnimeConfig>>,
+    config: Arc<Mutex<ConfigAnime>>,
     client: RogDbusClientBlocking<'a>,
     inner: Arc<Mutex<CtrlAnimeInner<'a>>>,
     /// Must be the same Atomic as in CtrlAnimeInner
@@ -145,7 +140,7 @@ pub struct CtrlAnime<'a> {
 
 impl CtrlAnime<'static> {
     pub fn new(
-        config: Arc<Mutex<UserAnimeConfig>>,
+        config: Arc<Mutex<ConfigAnime>>,
         inner: Arc<Mutex<CtrlAnimeInner<'static>>>,
         client: RogDbusClientBlocking<'static>,
         inner_early_return: Arc<AtomicBool>,
@@ -208,7 +203,7 @@ impl CtrlAnime<'static> {
                     .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
             }
             config.anime.push(action);
-            config.write()?;
+            config.write();
 
             let json = serde_json::to_string_pretty(&*config).expect("Parse config to JSON failed");
 
@@ -253,7 +248,7 @@ impl CtrlAnime<'static> {
                     .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
             }
             config.anime.push(action);
-            config.write()?;
+            config.write();
 
             let json =
                 serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
@@ -298,7 +293,7 @@ impl CtrlAnime<'static> {
                     .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
             }
             config.anime.push(action);
-            config.write()?;
+            config.write();
 
             let json =
                 serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
@@ -323,7 +318,7 @@ impl CtrlAnime<'static> {
                     .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
             }
             config.anime.push(action);
-            config.write()?;
+            config.write();
 
             let json =
                 serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
@@ -346,7 +341,7 @@ impl CtrlAnime<'static> {
             if (index as usize) < config.anime.len() {
                 config.anime.remove(index as usize);
             }
-            config.write()?;
+            config.write();
 
             let json =
                 serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
@@ -361,13 +356,13 @@ impl CtrlAnime<'static> {
     pub fn set_state(&mut self, on: bool) -> zbus::fdo::Result<()> {
         // Operations here need to be in specific order
         if on {
-            self.client.proxies().anime().set_on_off(on).ok();
+            self.client.proxies().anime().set_enable_display(on).ok();
             // Let the inner loop run
             self.inner_early_return.store(false, Ordering::SeqCst);
         } else {
             // Must make the inner run loop return early
             self.inner_early_return.store(true, Ordering::SeqCst);
-            self.client.proxies().anime().set_on_off(on).ok();
+            self.client.proxies().anime().set_enable_display(on).ok();
         }
         Ok(())
     }

asusd-user/src/daemon.rs

@@ -1,17 +1,17 @@
-use rog_anime::usb::get_anime_type;
-use rog_aura::layouts::KeyLayout;
-use rog_dbus::RogDbusClientBlocking;
-use rog_user::{
-    ctrl_anime::{CtrlAnime, CtrlAnimeInner},
-    user_config::*,
-    DBUS_NAME,
-};
-use smol::Executor;
-use std::sync::Mutex;
-use std::{fs::OpenOptions, io::Read, path::PathBuf, sync::Arc};
-use zbus::Connection;
-
+use std::io::Write;
+use std::path::PathBuf;
 use std::sync::atomic::AtomicBool;
+use std::sync::{Arc, Mutex};
+
+use asusd_user::config::*;
+use asusd_user::ctrl_anime::{CtrlAnime, CtrlAnimeInner};
+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, DBUS_NAME};
+use smol::Executor;
+use zbus::Connection;
 
 #[cfg(not(feature = "local_data"))]
 const DATA_DIR: &str = "/usr/share/rog-gui/";
@@ -20,25 +20,34 @@ const DATA_DIR: &str = env!("CARGO_MANIFEST_DIR");
 const BOARD_NAME: &str = "/sys/class/dmi/id/board_name";
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    println!("  user daemon v{}", rog_user::VERSION);
+    let mut logger = env_logger::Builder::new();
+    logger
+        .parse_default_env()
+        .target(env_logger::Target::Stdout)
+        .format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()))
+        .init();
+
+    println!("  user daemon v{}", asusd_user::VERSION);
     println!("    rog-anime v{}", rog_anime::VERSION);
     println!("     rog-dbus v{}", rog_dbus::VERSION);
     println!("rog-platform v{}", rog_platform::VERSION);
 
     let (client, _) = RogDbusClientBlocking::new()?;
-    let supported = client.proxies().supported().supported_functions()?;
-
-    let mut config = UserConfig::new();
-    config.load()?;
-
+    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 = UserAnimeConfig::load(cfg)?;
+            let anime_config = ConfigAnime::new().set_name(cfg).load();
             let anime = anime_config.create(anime_type)?;
             let anime_config = Arc::new(Mutex::new(anime_config));
 
@@ -69,24 +78,16 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // if supported.keyboard_led.per_key_led_mode {
     if let Some(cfg) = config.active_aura {
-        let mut aura_config = UserAuraConfig::load(cfg)?;
+        let mut aura_config = ConfigAura::new().set_name(cfg).load();
+        // let baord_name = std::fs::read_to_string(BOARD_NAME)?;
 
-        // Find and load a matching layout for laptop
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(PathBuf::from(BOARD_NAME))
-            .map_err(|e| {
-                println!("{BOARD_NAME}, {e}");
-                e
-            })?;
-        let mut board_name = String::new();
-        file.read_to_string(&mut board_name)?;
+        let led_support = LaptopLedData::get_data();
 
-        let layout = KeyLayout::find_layout(board_name.as_str(), PathBuf::from(DATA_DIR))
+        let layout = KeyLayout::find_layout(led_support, PathBuf::from(DATA_DIR))
             .map_err(|e| {
                 println!("{BOARD_NAME}, {e}");
             })
-            .unwrap_or_else(|_| KeyLayout::ga401_layout());
+            .unwrap_or_else(|_| KeyLayout::default_layout());
 
         executor
             .spawn(async move {
@@ -99,7 +100,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                     aura_config.aura.next_state(&layout);
                     let packets = aura_config.aura.create_packets();
 
-                    client.proxies().led().per_key_raw(packets).unwrap();
+                    client
+                        .proxies()
+                        .aura()
+                        .direct_addressing_raw(packets)
+                        .unwrap();
                     std::thread::sleep(std::time::Duration::from_millis(33));
                 }
             })

asusd-user/src/lib.rs

@@ -1,4 +1,4 @@
-pub mod user_config;
+pub mod config;
 
 pub mod error;
 
@@ -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-user/src/zbus_anime.rs

@@ -1,7 +1,8 @@
-//! # DBus interface proxy for: `org.asuslinux.Daemon`
+//! # `DBus` interface proxy for: `org.asuslinux.Daemon`
 //!
-//! This code was generated by `zbus-xmlgen` `1.0.0` from DBus introspection data.
-//! Source: `Interface '/org/asuslinux/Anime' from service 'org.asuslinux.Daemon' on session bus`.
+//! This code was generated by `zbus-xmlgen` `1.0.0` from `DBus` introspection
+//! data. Source: `Interface '/org/asuslinux/Anime' from service
+//! 'org.asuslinux.Daemon' on session bus`.
 //!
 //! You may prefer to adapt it, instead of using it verbatim.
 //!
@@ -9,8 +10,8 @@
 //! [Writing a client proxy](https://dbus.pages.freedesktop.org/zbus/client.html)
 //! section of the zbus documentation.
 //!
-//! This DBus object implements
-//! [standard DBus interfaces](https://dbus.freedesktop.org/doc/dbus-specification.html),
+//! This `DBus` object implements
+//! [standard `DBus` interfaces](https://dbus.freedesktop.org/doc/dbus-specification.html),
 //! (`org.freedesktop.DBus.*`) for which the following zbus proxies can be used:
 //!
 //! * [`zbus::fdo::PeerProxy`]
@@ -22,7 +23,10 @@
 
 use zbus::dbus_proxy;
 
-#[dbus_proxy(interface = "org.asuslinux.Daemon")]
+#[dbus_proxy(
+    interface = "org.asuslinux.Daemon",
+    default_path = "/org/asuslinux/Anime"
+)]
 trait Daemon {
     /// InsertAsusGif method
     fn insert_asus_gif(

asusd/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "daemon"
+name = "asusd"
 license = "MPL-2.0"
 version.workspace = true
 readme = "README.md"
@@ -9,20 +9,18 @@ homepage = "https://gitlab.com/asus-linux/asus-nb-ctrl"
 description = "A daemon app for ASUS GX502 and similar laptops to control missing features"
 edition = "2021"
 
-[lib]
-name = "daemon"
-path = "src/lib.rs"
-
 [[bin]]
 name = "asusd"
 path = "src/daemon.rs"
 
 [dependencies]
+config-traits = { path = "../config-traits" }
 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 = "*"
 
 async-trait.workspace = true
 tokio.workspace = true
@@ -37,12 +35,10 @@ logind-zbus.workspace = true
 # serialisation
 serde.workspace = true
 serde_derive.workspace = true
-serde_json.workspace = true
-toml.workspace = true
-
-# Device control
-sysfs-class.workspace = true # used for backlight control and baord ID
 
 concat-idents.workspace = true
 
-systemd-zbus = "*"
+systemd-zbus = "*"
+
+[dev-dependencies]
+cargo-husky.workspace = true

asusd/src/config.rs

@@ -0,0 +1,100 @@
+use config_traits::{StdConfig, StdConfigLoad2};
+use rog_platform::platform::PlatformPolicy;
+use serde_derive::{Deserialize, Serialize};
+
+const CONFIG_FILE: &str = "asusd.ron";
+
+#[derive(Deserialize, Serialize, Default, Debug)]
+pub struct Config {
+    /// 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 StdConfig for Config {
+    fn new() -> Self {
+        Config {
+            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()
+        }
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+}
+
+impl StdConfigLoad2<Config462, Config472> for Config {}
+
+#[derive(Deserialize, Serialize, Default, Debug)]
+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 {
+    /// Save charge limit for restoring on boot
+    pub bat_charge_limit: u8,
+    pub panel_od: bool,
+    pub disable_nvidia_powerd_on_battery: bool,
+    pub ac_command: String,
+    pub bat_command: String,
+}
+
+impl From<Config462> for Config {
+    fn from(c: Config462) -> Self {
+        Self {
+            charge_control_end_threshold: c.bat_charge_limit,
+            panel_od: c.panel_od,
+            disable_nvidia_powerd_on_battery: true,
+            ac_command: String::new(),
+            bat_command: String::new(),
+            ..Default::default()
+        }
+    }
+}

asusd/src/ctrl_anime/config.rs

@@ -0,0 +1,229 @@
+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, DeviceState, Fade, Vec2,
+};
+use serde_derive::{Deserialize, Serialize};
+
+const CONFIG_FILE: &str = "anime.ron";
+
+#[derive(Deserialize, Serialize)]
+pub struct AnimeConfigV460 {
+    pub system: Vec<ActionLoader>,
+    pub boot: Vec<ActionLoader>,
+    pub wake: Vec<ActionLoader>,
+    pub sleep: Vec<ActionLoader>,
+    pub shutdown: Vec<ActionLoader>,
+    pub brightness: f32,
+}
+
+impl From<AnimeConfigV460> for AnimeConfig {
+    fn from(c: AnimeConfigV460) -> AnimeConfig {
+        AnimeConfig {
+            system: c.system,
+            boot: c.boot,
+            wake: c.wake,
+            shutdown: c.shutdown,
+            ..Default::default()
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+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 display_enabled: bool,
+    pub display_brightness: Brightness,
+    pub builtin_anims_enabled: bool,
+    pub builtin_anims: Animations,
+}
+
+impl From<AnimeConfigV472> for AnimeConfig {
+    fn from(c: AnimeConfigV472) -> AnimeConfig {
+        AnimeConfig {
+            system: c.system,
+            boot: c.boot,
+            wake: c.wake,
+            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()
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize, Default)]
+pub struct AnimeConfigCached {
+    pub system: Vec<ActionData>,
+    pub boot: Vec<ActionData>,
+    pub wake: Vec<ActionData>,
+    pub shutdown: Vec<ActionData>,
+}
+
+impl AnimeConfigCached {
+    pub fn init_from_config(
+        &mut self,
+        config: &AnimeConfig,
+        anime_type: AnimeType,
+    ) -> Result<(), AnimeError> {
+        let mut sys = Vec::with_capacity(config.system.len());
+        for ani in &config.system {
+            sys.push(ActionData::from_anime_action(anime_type, ani)?);
+        }
+        self.system = sys;
+
+        let mut boot = Vec::with_capacity(config.boot.len());
+        for ani in &config.boot {
+            boot.push(ActionData::from_anime_action(anime_type, ani)?);
+        }
+        self.boot = boot;
+
+        let mut wake = Vec::with_capacity(config.wake.len());
+        for ani in &config.wake {
+            wake.push(ActionData::from_anime_action(anime_type, ani)?);
+        }
+        self.wake = wake;
+
+        let mut shutdown = Vec::with_capacity(config.shutdown.len());
+        for ani in &config.shutdown {
+            shutdown.push(ActionData::from_anime_action(anime_type, ani)?);
+        }
+        self.shutdown = shutdown;
+        Ok(())
+    }
+}
+
+/// Config for base system actions for the anime display
+#[derive(Deserialize, Serialize, Debug)]
+pub struct AnimeConfig {
+    pub model_override: Option<AnimeType>,
+    pub system: Vec<ActionLoader>,
+    pub boot: Vec<ActionLoader>,
+    pub wake: Vec<ActionLoader>,
+    pub shutdown: Vec<ActionLoader>,
+    // 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,
+}
+
+impl Default for AnimeConfig {
+    fn default() -> Self {
+        AnimeConfig {
+            model_override: None,
+            system: Vec::new(),
+            boot: Vec::new(),
+            wake: Vec::new(),
+            shutdown: Vec::new(),
+            // 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(),
+        }
+    }
+}
+
+impl StdConfig for AnimeConfig {
+    fn new() -> Self {
+        Self::create_default()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+}
+
+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) {
+    //     if config.brightness < 0.0 || config.brightness > 1.0 {
+    //         warn!(
+    //             "Clamped brightness to [0.0 ; 1.0], was {}",
+    //             config.brightness
+    //         );
+    //         config.brightness = f32::max(0.0, f32::min(1.0, config.brightness));
+    //     }
+    // }
+
+    fn create_default() -> Self {
+        // create a default config here
+        AnimeConfig {
+            system: vec![],
+            boot: vec![ActionLoader::ImageAnimation {
+                file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
+                scale: 0.9,
+                angle: 0.65,
+                translation: Vec2::default(),
+                brightness: 1.0,
+                time: AnimTime::Fade(Fade::new(
+                    Duration::from_secs(2),
+                    Some(Duration::from_secs(2)),
+                    Duration::from_secs(2),
+                )),
+            }],
+            wake: vec![ActionLoader::ImageAnimation {
+                file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
+                scale: 0.9,
+                angle: 0.65,
+                translation: Vec2::default(),
+                brightness: 1.0,
+                time: AnimTime::Fade(Fade::new(
+                    Duration::from_secs(2),
+                    Some(Duration::from_secs(2)),
+                    Duration::from_secs(2),
+                )),
+            }],
+            shutdown: 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,
+            }],
+            ..Default::default()
+        }
+    }
+}

asusd/src/ctrl_anime/mod.rs

@@ -2,29 +2,55 @@ pub mod config;
 /// Implements `CtrlTask`, Reloadable, `ZbusRun`
 pub mod trait_impls;
 
-use self::config::{AnimeConfig, AnimeConfigCached};
-use crate::{error::RogError, GetSupported};
+use std::convert::TryFrom;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::thread::sleep;
+
 use ::zbus::export::futures_util::lock::Mutex;
 use log::{error, info, warn};
-use rog_anime::{
-    error::AnimeError,
-    usb::{get_anime_type, pkt_for_flush, pkts_for_init},
-    ActionData, AnimeDataBuffer, AnimePacketType, AnimeType,
+use rog_anime::error::AnimeError;
+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_platform::{hid_raw::HidRaw, supported::AnimeSupportedFunctions, usb_raw::USBRaw};
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::{convert::TryFrom, error::Error, sync::Arc, thread::sleep};
+use rog_anime::{ActionData, AnimeDataBuffer, AnimePacketType, AnimeType};
+use rog_platform::hid_raw::HidRaw;
+use rog_platform::usb_raw::USBRaw;
 
-impl GetSupported for CtrlAnime {
-    type A = AnimeSupportedFunctions;
+use self::config::{AnimeConfig, AnimeConfigCached};
+use crate::error::RogError;
 
-    fn get_supported() -> Self::A {
-        AnimeSupportedFunctions(HidRaw::new("193b").is_ok())
+enum Node {
+    Usb(USBRaw),
+    Hid(HidRaw),
+}
+
+impl Node {
+    pub fn write_bytes(&self, message: &[u8]) -> Result<(), RogError> {
+        // TODO: map and pass on errors
+        match self {
+            Node::Usb(u) => {
+                u.write_bytes(message).ok();
+            }
+            Node::Hid(h) => {
+                h.write_bytes(message).ok();
+            }
+        }
+        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 {
-    node: USBRaw,
+    // node: HidRaw,
+    node: Node,
     anime_type: AnimeType,
     cache: AnimeConfigCached,
     config: AnimeConfig,
@@ -36,11 +62,26 @@ pub struct CtrlAnime {
 
 impl CtrlAnime {
     #[inline]
-    pub fn new(config: AnimeConfig) -> Result<CtrlAnime, Box<dyn Error>> {
-        let node = USBRaw::new(0x193b)?;
-        let anime_type = get_anime_type()?;
+    pub fn new(config: AnimeConfig) -> Result<CtrlAnime, RogError> {
+        let usb = USBRaw::new(0x193b).ok();
+        let hid = HidRaw::new("193b").ok();
+        let node = if usb.is_some() {
+            unsafe { Node::Usb(usb.unwrap_unchecked()) }
+        } else if hid.is_some() {
+            unsafe { Node::Hid(hid.unwrap_unchecked()) }
+        } else {
+            return Err(RogError::Anime(AnimeError::NoDevice));
+        };
 
-        info!("Device has an AniMe Matrix display");
+        let mut anime_type = get_anime_type()?;
+        if let AnimeType::Unknown = anime_type {
+            if let Some(model) = config.model_override {
+                warn!("Overriding the Animatrix type as {model:?}");
+                anime_type = model;
+            }
+        }
+
+        info!("Device has an AniMe Matrix display: {anime_type:?}");
         let mut cache = AnimeConfigCached::default();
         cache.init_from_config(&config, anime_type)?;
 
@@ -56,26 +97,39 @@ impl CtrlAnime {
 
         Ok(ctrl)
     }
+
     // let device = CtrlAnime::get_device(0x0b05, 0x193b)?;
 
-    /// Start an action thread. This is classed as a singleton and there should be only
-    /// one running - so the thread uses atomics to signal run/exit.
+    /// Start an action thread. This is classed as a singleton and there should
+    /// be only one running - so the thread uses atomics to signal run/exit.
     ///
-    /// Because this also writes to the usb device, other write tries (display only) *must*
-    /// get the mutex lock and set the `thread_exit` atomic.
-    fn run_thread(inner: Arc<Mutex<CtrlAnime>>, actions: Vec<ActionData>, mut once: bool) {
+    /// Because this also writes to the usb device, other write tries (display
+    /// only) *must* get the mutex lock and set the `thread_exit` atomic.
+    async fn run_thread(inner: Arc<Mutex<CtrlAnime>>, actions: Vec<ActionData>, mut once: bool) {
         if actions.is_empty() {
             warn!("AniMe system actions was empty");
             return;
         }
 
-        // Loop rules:
-        // - Lock the mutex **only when required**. That is, the lock must be held for the shortest duration possible.
-        // - An AtomicBool used for thread exit should be checked in every loop, including nested
+        if let Some(lock) = inner.try_lock() {
+            lock.node
+                .write_bytes(&pkt_set_enable_powersave_anim(false))
+                .map_err(|err| {
+                    warn!("rog_anime::run_animation:callback {}", err);
+                })
+                .ok();
+        }
 
-        // The only reason for this outer thread is to prevent blocking while waiting for the
-        // next spawned thread to exit
-        // TODO: turn this in to async task (maybe? COuld still risk blocking main thread)
+        // Loop rules:
+        // - Lock the mutex **only when required**. That is, the lock must be held for
+        //   the shortest duration possible.
+        // - An AtomicBool used for thread exit should be checked in every loop,
+        //   including nested
+
+        // The only reason for this outer thread is to prevent blocking while waiting
+        // for the next spawned thread to exit
+        // TODO: turn this in to async task (maybe? COuld still risk blocking main
+        // thread)
         std::thread::Builder::new()
             .name("AniMe system thread start".into())
             .spawn(move || {
@@ -103,9 +157,8 @@ impl CtrlAnime {
 
                 info!("AniMe no previous system thread running (now)");
                 thread_exit.store(false, Ordering::SeqCst);
-
+                thread_running.store(true, Ordering::SeqCst);
                 'main: loop {
-                    thread_running.store(true, Ordering::SeqCst);
                     for action in &actions {
                         if thread_exit.load(Ordering::SeqCst) {
                             break 'main;
@@ -114,7 +167,7 @@ impl CtrlAnime {
                             ActionData::Animation(frames) => {
                                 rog_anime::run_animation(frames, &|frame| {
                                     if thread_exit.load(Ordering::Acquire) {
-                                        info!("rog-anime: frame-loop was asked to exit");
+                                        info!("rog-anime: animation sub-loop was asked to exit");
                                         return Ok(true); // Do safe exit
                                     }
                                     inner
@@ -138,6 +191,10 @@ impl CtrlAnime {
                                             Ok,
                                         )
                                 });
+                                if thread_exit.load(Ordering::Acquire) {
+                                    info!("rog-anime: sub-loop exited and main loop exiting now");
+                                    break 'main;
+                                }
                             }
                             ActionData::Image(image) => {
                                 once = false;
@@ -173,6 +230,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);
@@ -186,7 +251,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;
             }
@@ -196,7 +261,7 @@ impl CtrlAnime {
         for row in &data {
             self.node.write_bytes(row)?;
         }
-        self.node.write_bytes(&pkt_for_flush())?;
+        self.node.write_bytes(&pkt_flush())?;
         Ok(())
     }
 

asusd/src/ctrl_anime/trait_impls.rs

@@ -0,0 +1,407 @@
+use std::sync::atomic::Ordering;
+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, Brightness,
+};
+use rog_anime::{Animations, AnimeDataBuffer, DeviceState};
+use zbus::export::futures_util::lock::Mutex;
+use zbus::{dbus_interface, CacheProperties, Connection, SignalContext};
+
+use super::CtrlAnime;
+use crate::error::RogError;
+
+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>>);
+
+/// The struct with the main dbus methods requires this trait
+#[async_trait]
+impl crate::ZbusRun for CtrlAnimeZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, ANIME_ZBUS_PATH, server).await;
+    }
+}
+
+// None of these calls can be guarnateed to succeed unless we loop until okay
+// If the try_lock *does* succeed then any other thread trying to lock will not
+// grab it until we finish.
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl CtrlAnimeZbus {
+    /// Writes a data stream of length. Will force system thread to exit until
+    /// it is restarted
+    async fn write(&self, input: AnimeDataBuffer) -> zbus::fdo::Result<()> {
+        let lock = self.0.lock().await;
+        lock.thread_exit.store(true, Ordering::SeqCst);
+        lock.write_data_buffer(input).map_err(|err| {
+            warn!("ctrl_anime::run_animation:callback {}", err);
+            err
+        })?;
+        Ok(())
+    }
+
+    /// 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
+    #[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!("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();
+    }
+
+    #[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
+    #[dbus_interface(property)]
+    async fn set_builtins_enabled(&self, enabled: bool) {
+        let mut lock = self.0.lock().await;
+        lock.node
+            .set_builtins_enabled(enabled, lock.config.display_brightness)
+            .map_err(|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);
+        }
+    }
+
+    #[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
+    #[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!("ctrl_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        lock.config.display_enabled = true;
+        lock.config.builtin_anims = settings;
+        lock.config.write();
+    }
+
+    #[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
+    #[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!("ctrl_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        lock.config.display_enabled = enabled;
+        lock.config.write();
+    }
+
+    #[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
+    /// the user daemon
+    async fn run_main_loop(&self, start: bool) {
+        if start {
+            let lock = self.0.lock().await;
+            lock.thread_exit.store(true, Ordering::SeqCst);
+            CtrlAnime::run_thread(self.0.clone(), lock.cache.system.clone(), false).await;
+        }
+    }
+
+    /// Get the device state as stored by asusd
+    // #[dbus_interface(property)]
+    async fn device_state(&self) -> DeviceState {
+        let lock = self.0.lock().await;
+        DeviceState::from(&lock.config)
+    }
+}
+
+#[async_trait]
+impl crate::CtrlTask for CtrlAnimeZbus {
+    fn zbus_path() -> &'static str {
+        ANIME_ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, _: SignalContext<'static>) -> Result<(), RogError> {
+        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(
+            move |sleeping| {
+                // on_sleep
+                let inner = inner1.clone();
+                async move {
+                    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 !sleeping && !lock.config.builtin_anims_enabled {
+                            CtrlAnime::run_thread(inner.clone(), lock.cache.wake.clone(), true)
+                                .await;
+                        }
+                    }
+                }
+            },
+            move |shutting_down| {
+                // on_shutdown
+                let inner = inner2.clone();
+                async move {
+                    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 |lid_closed| {
+                let inner = inner3.clone();
+                // on lid change
+                async move {
+                    let lock = inner.lock().await;
+                    if lock.config.off_when_lid_closed {
+                        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 {
+                        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();
+                    }
+                }
+            },
+        )
+        .await;
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+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;
+            // 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.config.display_brightness,
+            )?;
+
+            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;
+            }
+        }
+        Ok(())
+    }
+}

asusd/src/ctrl_aura/config.rs

@@ -1,15 +1,15 @@
-use crate::laptops::{LaptopLedData, ASUS_KEYBOARD_DEVICES};
-use log::{error, warn};
-use rog_aura::usb::{AuraDev1866, AuraDev19b6, AuraDevTuf, AuraDevice, AuraPowerDev};
+use std::collections::{BTreeMap, HashSet};
+
+use config_traits::{StdConfig, StdConfigLoad};
+use log::{debug, warn};
+use rog_aura::aura_detection::{LaptopLedData, ASUS_KEYBOARD_DEVICES};
+use rog_aura::power::AuraPower;
+use rog_aura::usb::{AuraDevRog1, AuraDevTuf, AuraDevice, AuraPowerDev};
 use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Direction, LedBrightness, Speed, GRADIENT};
 use rog_platform::hid_raw::HidRaw;
-use rog_platform::keyboard_led::KeyboardLed;
 use serde_derive::{Deserialize, Serialize};
-use std::collections::{BTreeMap, HashSet};
-use std::fs::{File, OpenOptions};
-use std::io::{Read, Write};
 
-pub static AURA_CONFIG_PATH: &str = "/etc/asusd/aura.conf";
+const CONFIG_FILE: &str = "aura.ron";
 
 /// Enable/disable LED control in various states such as
 /// when the device is awake, suspended, shutting down or
@@ -17,23 +17,20 @@ pub static AURA_CONFIG_PATH: &str = "/etc/asusd/aura.conf";
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum AuraPowerConfig {
     AuraDevTuf(HashSet<AuraDevTuf>),
-    AuraDev1866(HashSet<AuraDev1866>),
-    AuraDev19b6(HashSet<AuraDev19b6>),
+    AuraDevRog1(HashSet<AuraDevRog1>),
+    AuraDevRog2(AuraPower),
 }
 
 impl AuraPowerConfig {
     /// Invalid for TUF laptops
-    pub fn to_bytes(control: &Self) -> [u8; 3] {
+    pub fn to_bytes(control: &Self) -> [u8; 4] {
         match control {
-            AuraPowerConfig::AuraDevTuf(_) => [0, 0, 0],
-            AuraPowerConfig::AuraDev1866(c) => {
-                let c: Vec<AuraDev1866> = c.iter().copied().collect();
-                AuraDev1866::to_bytes(&c)
-            }
-            AuraPowerConfig::AuraDev19b6(c) => {
-                let c: Vec<AuraDev19b6> = c.iter().copied().collect();
-                AuraDev19b6::to_bytes(&c)
+            AuraPowerConfig::AuraDevTuf(_) => [0, 0, 0, 0],
+            AuraPowerConfig::AuraDevRog1(c) => {
+                let c: Vec<AuraDevRog1> = c.iter().copied().collect();
+                AuraDevRog1::to_bytes(&c)
             }
+            AuraPowerConfig::AuraDevRog2(c) => c.to_bytes(),
         }
     }
 
@@ -48,13 +45,13 @@ impl AuraPowerConfig {
             ]);
         }
 
-        if let Self::AuraDev1866(c) = control {
+        if let Self::AuraDevRog1(c) = control {
             return Some([
                 true,
-                c.contains(&AuraDev1866::Boot),
-                c.contains(&AuraDev1866::Awake),
-                c.contains(&AuraDev1866::Sleep),
-                c.contains(&AuraDev1866::Keyboard),
+                c.contains(&AuraDevRog1::Boot),
+                c.contains(&AuraDevRog1::Awake),
+                c.contains(&AuraDevRog1::Sleep),
+                c.contains(&AuraDevRog1::Keyboard),
             ]);
         }
 
@@ -70,8 +67,9 @@ impl AuraPowerConfig {
             }
         }
     }
-    pub fn set_0x1866(&mut self, power: AuraDev1866, on: bool) {
-        if let Self::AuraDev1866(p) = self {
+
+    pub fn set_0x1866(&mut self, power: AuraDevRog1, on: bool) {
+        if let Self::AuraDevRog1(p) = self {
             if on {
                 p.insert(power);
             } else {
@@ -80,13 +78,9 @@ impl AuraPowerConfig {
         }
     }
 
-    pub fn set_0x19b6(&mut self, power: AuraDev19b6, on: bool) {
-        if let Self::AuraDev19b6(p) = self {
-            if on {
-                p.insert(power);
-            } else {
-                p.remove(&power);
-            }
+    pub fn set_0x19b6(&mut self, power: AuraPower) {
+        if let Self::AuraDevRog2(p) = self {
+            *p = power;
         }
     }
 }
@@ -96,24 +90,21 @@ impl From<&AuraPowerConfig> for AuraPowerDev {
         match config {
             AuraPowerConfig::AuraDevTuf(d) => AuraPowerDev {
                 tuf: d.iter().copied().collect(),
-                x1866: vec![],
-                x19b6: vec![],
+                ..Default::default()
             },
-            AuraPowerConfig::AuraDev1866(d) => AuraPowerDev {
-                tuf: vec![],
-                x1866: d.iter().copied().collect(),
-                x19b6: vec![],
+            AuraPowerConfig::AuraDevRog1(d) => AuraPowerDev {
+                old_rog: d.iter().copied().collect(),
+                ..Default::default()
             },
-            AuraPowerConfig::AuraDev19b6(d) => AuraPowerDev {
-                tuf: vec![],
-                x1866: vec![],
-                x19b6: d.iter().copied().collect(),
+            AuraPowerConfig::AuraDevRog2(d) => AuraPowerDev {
+                rog: d.clone(),
+                ..Default::default()
             },
         }
     }
 }
 
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, Serialize, Debug, Clone)]
 // #[serde(default)]
 pub struct AuraConfig {
     pub brightness: LedBrightness,
@@ -124,40 +115,37 @@ pub struct AuraConfig {
     pub enabled: AuraPowerConfig,
 }
 
-impl Default for AuraConfig {
-    fn default() -> Self {
+impl StdConfig for AuraConfig {
+    /// Detect the keyboard type and load from default DB if data available
+    fn new() -> Self {
+        warn!("AuraConfig: creating new config");
         let mut prod_id = AuraDevice::Unknown;
-        for prod in &ASUS_KEYBOARD_DEVICES {
-            if HidRaw::new(prod).is_ok() {
-                prod_id = AuraDevice::from(*prod);
+        for prod in ASUS_KEYBOARD_DEVICES {
+            if HidRaw::new(prod.into()).is_ok() {
+                prod_id = prod;
                 break;
             }
         }
+        Self::from_default_support(prod_id, &LaptopLedData::get_data())
+    }
 
-        if prod_id == AuraDevice::Unknown {
-            if let Ok(p) = KeyboardLed::new() {
-                if p.has_kbd_rgb_mode() {
-                    prod_id = AuraDevice::Tuf;
-                }
-            }
-        }
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
 
-        let enabled = if prod_id == AuraDevice::X19B6 {
-            AuraPowerConfig::AuraDev19b6(HashSet::from([
-                AuraDev19b6::BootLogo,
-                AuraDev19b6::BootKeyb,
-                AuraDev19b6::SleepLogo,
-                AuraDev19b6::SleepKeyb,
-                AuraDev19b6::AwakeLogo,
-                AuraDev19b6::AwakeKeyb,
-                AuraDev19b6::ShutdownLogo,
-                AuraDev19b6::ShutdownKeyb,
-                AuraDev19b6::BootBar,
-                AuraDev19b6::AwakeBar,
-                AuraDev19b6::SleepBar,
-                AuraDev19b6::ShutdownBar,
-            ]))
-        } else if prod_id == AuraDevice::Tuf {
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+}
+
+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.is_new_style() {
+            AuraPowerConfig::AuraDevRog2(AuraPower::new_all_on())
+        } else if prod_id.is_tuf_style() {
             AuraPowerConfig::AuraDevTuf(HashSet::from([
                 AuraDevTuf::Awake,
                 AuraDevTuf::Boot,
@@ -165,76 +153,32 @@ impl Default for AuraConfig {
                 AuraDevTuf::Keyboard,
             ]))
         } else {
-            AuraPowerConfig::AuraDev1866(HashSet::from([
-                AuraDev1866::Awake,
-                AuraDev1866::Boot,
-                AuraDev1866::Sleep,
-                AuraDev1866::Keyboard,
-                AuraDev1866::Lightbar,
+            AuraPowerConfig::AuraDevRog1(HashSet::from([
+                AuraDevRog1::Awake,
+                AuraDevRog1::Boot,
+                AuraDevRog1::Sleep,
+                AuraDevRog1::Keyboard,
+                AuraDevRog1::Lightbar,
             ]))
         };
-
-        AuraConfig {
+        let mut config = AuraConfig {
             brightness: LedBrightness::Med,
             current_mode: AuraModeNum::Static,
             builtins: BTreeMap::new(),
             multizone: None,
             multizone_on: false,
             enabled,
-        }
-    }
-}
+        };
 
-impl AuraConfig {
-    /// `load` will attempt to read the config, and panic if the dir is missing
-    pub fn load(supported_led_modes: &LaptopLedData) -> Self {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(AURA_CONFIG_PATH)
-            .unwrap_or_else(|_| {
-                panic!(
-                    "The file {} or directory /etc/asusd/ is missing",
-                    AURA_CONFIG_PATH
-                )
-            }); // okay to cause panic here
-        let mut buf = String::new();
-        if let Ok(read_len) = file.read_to_string(&mut buf) {
-            if read_len == 0 {
-                return AuraConfig::create_default(&mut file, supported_led_modes);
-            } else {
-                if let Ok(data) = serde_json::from_str(&buf) {
-                    return data;
-                }
-                warn!(
-                    "Could not deserialise {}.\nWill rename to {}-old and recreate config",
-                    AURA_CONFIG_PATH, AURA_CONFIG_PATH
-                );
-                let cfg_old = AURA_CONFIG_PATH.to_string() + "-old";
-                std::fs::rename(AURA_CONFIG_PATH, cfg_old).unwrap_or_else(|err| {
-                    panic!(
-                        "Could not rename. Please remove {} then restart service: Error {}",
-                        AURA_CONFIG_PATH, err
-                    )
-                });
-            }
-        }
-        AuraConfig::create_default(&mut file, supported_led_modes)
-    }
-
-    fn create_default(file: &mut File, support_data: &LaptopLedData) -> Self {
-        // create a default config here
-        let mut config = AuraConfig::default();
-
-        for n in &support_data.standard {
+        for n in &support_data.basic_modes {
+            debug!("AuraConfig: creating default for {n}");
             config
                 .builtins
                 .insert(*n, AuraEffect::default_with_mode(*n));
 
-            if !support_data.multizone.is_empty() {
+            if !support_data.basic_zones.is_empty() {
                 let mut default = vec![];
-                for (i, tmp) in support_data.multizone.iter().enumerate() {
+                for (i, tmp) in support_data.basic_zones.iter().enumerate() {
                     default.push(AuraEffect {
                         mode: *n,
                         zone: *tmp,
@@ -253,41 +197,13 @@ impl AuraConfig {
                 }
             }
         }
-
-        // Should be okay to unwrap this as is since it is a Default
-        let json = serde_json::to_string(&config).unwrap();
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|_| panic!("Could not write {}", AURA_CONFIG_PATH));
         config
     }
 
-    pub fn read(&mut self) {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(AURA_CONFIG_PATH)
-            .unwrap_or_else(|err| panic!("Error reading {}: {}", AURA_CONFIG_PATH, err));
-        let mut buf = String::new();
-        if let Ok(l) = file.read_to_string(&mut buf) {
-            if l == 0 {
-                warn!("File is empty {}", AURA_CONFIG_PATH);
-            } else {
-                let x = serde_json::from_str(&buf)
-                    .unwrap_or_else(|_| panic!("Could not deserialise {}", AURA_CONFIG_PATH));
-                *self = x;
-            }
-        }
-    }
-
-    pub fn write(&self) {
-        let mut file = File::create(AURA_CONFIG_PATH).expect("Couldn't overwrite config");
-        let json = serde_json::to_string_pretty(self).expect("Parse config to JSON failed");
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|err| error!("Could not write config: {}", err));
-    }
-
     /// Set the mode data, current mode, and if multizone enabled.
     ///
-    /// Multipurpose, will accept `AuraEffect` with zones and put in the correct store.
+    /// Multipurpose, will accept `AuraEffect` with zones and put in the correct
+    /// store.
     pub fn set_builtin(&mut self, effect: AuraEffect) {
         self.current_mode = effect.mode;
         if effect.zone() == AuraZone::None {
@@ -325,15 +241,23 @@ impl AuraConfig {
 
 #[cfg(test)]
 mod tests {
-    use super::AuraConfig;
+    use rog_aura::aura_detection::LaptopLedData;
+    use rog_aura::usb::AuraDevice;
     use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour};
 
+    use super::AuraConfig;
+
     #[test]
     fn set_multizone_4key_config() {
-        let mut config = AuraConfig::default();
+        let mut config =
+            AuraConfig::from_default_support(AuraDevice::X19b6, &LaptopLedData::default());
 
         let effect = AuraEffect {
-            colour1: Colour(0xff, 0x00, 0xff),
+            colour1: Colour {
+                r: 0xff,
+                g: 0x00,
+                b: 0xff,
+            },
             zone: AuraZone::Key1,
             ..Default::default()
         };
@@ -342,21 +266,33 @@ mod tests {
         assert!(config.multizone.is_some());
 
         let effect = AuraEffect {
-            colour1: Colour(0x00, 0xff, 0xff),
+            colour1: Colour {
+                r: 0x00,
+                g: 0xff,
+                b: 0xff,
+            },
             zone: AuraZone::Key2,
             ..Default::default()
         };
         config.set_builtin(effect);
 
         let effect = AuraEffect {
-            colour1: Colour(0xff, 0xff, 0x00),
+            colour1: Colour {
+                r: 0xff,
+                g: 0xff,
+                b: 0x00,
+            },
             zone: AuraZone::Key3,
             ..Default::default()
         };
         config.set_builtin(effect);
 
         let effect = AuraEffect {
-            colour1: Colour(0x00, 0xff, 0x00),
+            colour1: Colour {
+                r: 0x00,
+                g: 0xff,
+                b: 0x00,
+            },
             zone: AuraZone::Key4,
             ..Default::default()
         };
@@ -368,15 +304,44 @@ mod tests {
         let res = config.multizone.unwrap();
         let sta = res.get(&AuraModeNum::Static).unwrap();
         assert_eq!(sta.len(), 4);
-        assert_eq!(sta[0].colour1, Colour(0xff, 0x00, 0xff));
-        assert_eq!(sta[1].colour1, Colour(0x00, 0xff, 0xff));
-        assert_eq!(sta[2].colour1, Colour(0xff, 0xff, 0x00));
-        assert_eq!(sta[3].colour1, Colour(0x00, 0xff, 0x00));
+        assert_eq!(
+            sta[0].colour1,
+            Colour {
+                r: 0xff,
+                g: 0x00,
+                b: 0xff
+            }
+        );
+        assert_eq!(
+            sta[1].colour1,
+            Colour {
+                r: 0x00,
+                g: 0xff,
+                b: 0xff
+            }
+        );
+        assert_eq!(
+            sta[2].colour1,
+            Colour {
+                r: 0xff,
+                g: 0xff,
+                b: 0x00
+            }
+        );
+        assert_eq!(
+            sta[3].colour1,
+            Colour {
+                r: 0x00,
+                g: 0xff,
+                b: 0x00
+            }
+        );
     }
 
     #[test]
     fn set_multizone_multimode_config() {
-        let mut config = AuraConfig::default();
+        let mut config =
+            AuraConfig::from_default_support(AuraDevice::X19b6, &LaptopLedData::default());
 
         let effect = AuraEffect {
             zone: AuraZone::Key1,

asusd/src/ctrl_aura/controller.rs

@@ -0,0 +1,363 @@
+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, Direction, LedBrightness, Speed, GRADIENT, LED_MSG_LEN};
+use rog_platform::hid_raw::HidRaw;
+use rog_platform::keyboard_led::KeyboardLed;
+
+use super::config::{AuraConfig, AuraPowerConfig};
+use crate::error::RogError;
+
+#[derive(Debug)]
+pub enum LEDNode {
+    KbdLed(KeyboardLed),
+    Rog(HidRaw),
+    None,
+}
+
+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 sysfs_node: KeyboardLed,
+    pub supported_modes: LaptopLedData,
+    pub per_key_mode_active: bool,
+    pub config: AuraConfig,
+}
+
+impl CtrlKbdLed {
+    pub fn new(supported_modes: LaptopLedData) -> Result<Self, RogError> {
+        let mut led_prod = AuraDevice::Unknown;
+        let mut usb_node = None;
+        for prod in ASUS_KEYBOARD_DEVICES {
+            match HidRaw::new(prod.into()) {
+                Ok(node) => {
+                    led_prod = prod;
+                    usb_node = Some(node);
+                    info!(
+                        "Looked for keyboard controller 0x{}: Found",
+                        <&str>::from(prod)
+                    );
+                    break;
+                }
+                Err(err) => info!(
+                    "Looked for keyboard controller 0x{}: {err}",
+                    <&str>::from(prod)
+                ),
+            }
+        }
+
+        let rgb_led = KeyboardLed::new()?;
+
+        if usb_node.is_none() && !rgb_led.has_kbd_rgb_mode() {
+            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);
+        }
+
+        let led_node = if let Some(rog) = usb_node {
+            info!("Found ROG USB keyboard");
+            LEDNode::Rog(rog)
+        } else if rgb_led.has_kbd_rgb_mode() {
+            info!("Found TUF keyboard");
+            LEDNode::KbdLed(rgb_led.clone())
+        } else {
+            LEDNode::None
+        };
+
+        // New loads data fromt he DB also
+        let mut config_init = AuraConfig::new();
+        let mut config_loaded = config_init.clone().load();
+        // update the initialised data with what we loaded from disk
+        for mode in &mut config_init.builtins {
+            // update init values from loaded values if they exist
+            if let Some(loaded) = config_loaded.builtins.get(mode.0) {
+                *mode.1 = loaded.clone();
+            }
+        }
+        // Then replace just incase the initialised data contains new modes added
+        config_loaded.builtins = config_init.builtins;
+
+        if let (Some(mut multizone_init), Some(multizone_loaded)) =
+            (config_init.multizone, config_loaded.multizone.as_mut())
+        {
+            for mode in multizone_init.iter_mut() {
+                // update init values from loaded values if they exist
+                if let Some(loaded) = multizone_loaded.get(mode.0) {
+                    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) {
+                            new_set.push(mode.clone());
+                        }
+                    }
+                    *mode.1 = new_set;
+                }
+            }
+            *multizone_loaded = multizone_init;
+        }
+
+        let ctrl = CtrlKbdLed {
+            led_prod,
+            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_modes,
+            per_key_mode_active: false,
+            config: config_loaded,
+        };
+        Ok(ctrl)
+    }
+
+    /// 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> {
+        if let LEDNode::KbdLed(platform) = &mut self.led_node {
+            if let Some(pwr) = AuraPowerConfig::to_tuf_bool_array(&self.config.enabled) {
+                let buf = [1, pwr[1] as u8, pwr[2] as u8, pwr[3] as u8, pwr[4] as u8];
+                platform.set_kbd_rgb_state(&buf)?;
+            }
+        } else if let LEDNode::Rog(hid_raw) = &self.led_node {
+            let bytes = AuraPowerConfig::to_bytes(&self.config.enabled);
+            let message = [0x5d, 0xbd, 0x01, bytes[0], bytes[1], bytes[2], bytes[3]];
+
+            hid_raw.write_bytes(&message)?;
+            hid_raw.write_bytes(&LED_SET)?;
+            // Changes won't persist unless apply is set
+            hid_raw.write_bytes(&LED_APPLY)?;
+        }
+        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.
+    pub fn write_effect_block(&mut self, effect: &UsbPackets) -> Result<(), RogError> {
+        if self.config.brightness == LedBrightness::Off {
+            self.config.brightness = LedBrightness::Med;
+            self.config.write();
+        }
+
+        let pkt_type = effect[0][1];
+        const PER_KEY_TYPE: u8 = 0xbc;
+
+        if pkt_type != PER_KEY_TYPE {
+            self.per_key_mode_active = false;
+            if let LEDNode::Rog(hid_raw) = &self.led_node {
+                hid_raw.write_bytes(&effect[0])?;
+                hid_raw.write_bytes(&LED_SET)?;
+                // hid_raw.write_bytes(&LED_APPLY)?;
+            }
+        } else {
+            if !self.per_key_mode_active {
+                if let LEDNode::Rog(hid_raw) = &self.led_node {
+                    let init = LedUsbPackets::get_init_msg();
+                    hid_raw.write_bytes(&init)?;
+                }
+                self.per_key_mode_active = true;
+            }
+            if let LEDNode::Rog(hid_raw) = &self.led_node {
+                for row in effect.iter() {
+                    hid_raw.write_bytes(row)?;
+                }
+            } else if let LEDNode::KbdLed(tuf) = &self.led_node {
+                for row in effect.iter() {
+                    let r = row[9];
+                    let g = row[10];
+                    let b = row[11];
+                    tuf.set_kbd_rgb_mode(&[0, 0, r, g, b, 0])?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub fn write_mode(&mut self, mode: &AuraEffect) -> Result<(), RogError> {
+        if let LEDNode::KbdLed(platform) = &self.led_node {
+            let buf = [
+                1,
+                mode.mode as u8,
+                mode.colour1.r,
+                mode.colour1.g,
+                mode.colour1.b,
+                mode.speed as u8,
+            ];
+            platform.set_kbd_rgb_mode(&buf)?;
+        } else if let LEDNode::Rog(hid_raw) = &self.led_node {
+            let bytes: [u8; LED_MSG_LEN] = mode.into();
+            hid_raw.write_bytes(&bytes)?;
+            hid_raw.write_bytes(&LED_SET)?;
+            // Changes won't persist unless apply is set
+            hid_raw.write_bytes(&LED_APPLY)?;
+        } else {
+            return Err(RogError::NoAuraKeyboard);
+        }
+        self.per_key_mode_active = false;
+        Ok(())
+    }
+
+    pub(super) fn write_current_config_mode(&mut self) -> Result<(), RogError> {
+        if self.config.multizone_on {
+            let mode = self.config.current_mode;
+            let mut create = false;
+            // There is no multizone config for this mode so create one here
+            // using the colours of rainbow if it exists, or first available
+            // mode, or random
+            if self.config.multizone.is_none() {
+                create = true;
+            } else if let Some(multizones) = self.config.multizone.as_ref() {
+                if !multizones.contains_key(&mode) {
+                    create = true;
+                }
+            }
+            if create {
+                info!("No user-set config for zone founding, attempting a default");
+                self.create_multizone_default()?;
+            }
+
+            if let Some(multizones) = self.config.multizone.as_mut() {
+                if let Some(set) = multizones.get(&mode) {
+                    for mode in set.clone() {
+                        self.write_mode(&mode)?;
+                    }
+                }
+            }
+        } else {
+            let mode = self.config.current_mode;
+            if let Some(effect) = self.config.builtins.get(&mode).cloned() {
+                self.write_mode(&effect)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Create a default for the `current_mode` if multizone and no config
+    /// exists.
+    fn create_multizone_default(&mut self) -> Result<(), RogError> {
+        let mut default = vec![];
+        for (i, tmp) in self.supported_modes.basic_zones.iter().enumerate() {
+            default.push(AuraEffect {
+                mode: self.config.current_mode,
+                zone: *tmp,
+                colour1: *GRADIENT.get(i).unwrap_or(&GRADIENT[0]),
+                colour2: *GRADIENT.get(GRADIENT.len() - i).unwrap_or(&GRADIENT[6]),
+                speed: Speed::Med,
+                direction: Direction::Left,
+            });
+        }
+        if default.is_empty() {
+            return Err(RogError::AuraEffectNotSupported);
+        }
+
+        if let Some(multizones) = self.config.multizone.as_mut() {
+            multizones.insert(self.config.current_mode, default);
+        } else {
+            let mut tmp = BTreeMap::new();
+            tmp.insert(self.config.current_mode, default);
+            self.config.multizone = Some(tmp);
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rog_aura::aura_detection::{LaptopLedData, PowerZones};
+    use rog_aura::usb::AuraDevice;
+    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]
+    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 {
+            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,
+            sysfs_node: KeyboardLed::default(),
+            supported_modes,
+            per_key_mode_active: false,
+            config,
+        };
+
+        assert!(controller.config.multizone.is_none());
+        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);
+        assert!(controller.create_multizone_default().is_ok());
+        assert!(controller.config.multizone.is_some());
+
+        let m = controller.config.multizone.unwrap();
+        assert!(m.contains_key(&AuraModeNum::Static));
+        let e = m.get(&AuraModeNum::Static).unwrap();
+        assert_eq!(e.len(), 2);
+        assert_eq!(e[0].zone, AuraZone::Key1);
+        assert_eq!(e[1].zone, AuraZone::Key2);
+    }
+
+    #[test]
+    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 {
+            board_name: String::new(),
+            layout_name: "ga401".to_owned(),
+            basic_modes: vec![AuraModeNum::Static],
+            basic_zones: vec![AuraZone::Key1, AuraZone::Key2],
+            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,
+            sysfs_node: KeyboardLed::default(),
+            supported_modes,
+            per_key_mode_active: false,
+            config,
+        };
+
+        assert!(controller.config.multizone.is_none());
+        controller.config.multizone_on = true;
+        // This is called in toggle_mode. It will error here because we have no
+        // keyboard node in tests.
+        assert_eq!(
+            controller
+                .write_current_config_mode()
+                .unwrap_err()
+                .to_string(),
+            "No supported Aura keyboard"
+        );
+        assert!(controller.config.multizone.is_some());
+
+        let m = controller.config.multizone.unwrap();
+        assert!(m.contains_key(&AuraModeNum::Static));
+        let e = m.get(&AuraModeNum::Static).unwrap();
+        assert_eq!(e.len(), 2);
+        assert_eq!(e[0].zone, AuraZone::Key1);
+        assert_eq!(e[1].zone, AuraZone::Key2);
+    }
+}

asusd/src/ctrl_aura/mod.rs

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

asusd/src/ctrl_aura/trait_impls.rs

@@ -0,0 +1,278 @@
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use config_traits::StdConfig;
+use log::{debug, error, info, warn};
+use rog_aura::advanced::UsbPackets;
+use rog_aura::usb::{AuraDevice, AuraPowerDev};
+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 const AURA_ZBUS_NAME: &str = "Aura";
+pub const AURA_ZBUS_PATH: &str = "/org/asuslinux/Aura";
+
+#[derive(Clone)]
+pub struct CtrlAuraZbus(pub Arc<Mutex<CtrlKbdLed>>);
+
+impl CtrlAuraZbus {
+    fn update_config(lock: &mut CtrlKbdLed) -> Result<(), RogError> {
+        let bright = lock.sysfs_node.get_brightness()?;
+        lock.config.read();
+        lock.config.brightness = bright.into();
+        lock.config.write();
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl crate::ZbusRun for CtrlAuraZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, AURA_ZBUS_PATH, server).await;
+    }
+}
+
+/// The main interface for changing, reading, or notfying signals
+///
+/// LED commands are split between Brightness, Modes, Per-Key
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl 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.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_modes(&self) -> Result<Vec<AuraModeNum>, ZbErr> {
+        let ctrl = self.0.lock().await;
+        Ok(ctrl.config.builtins.keys().cloned().collect())
+    }
+
+    /// 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_modes.basic_modes.contains(&effect.mode)
+            || effect.zone != AuraZone::None
+                && !ctrl.supported_modes.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.
+    #[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);
+        }
+        for p in options.old_rog {
+            ctrl.config.enabled.set_0x1866(p, enabled);
+        }
+        ctrl.config.enabled.set_0x19b6(options.rog);
+        ctrl.config.write();
+        Ok(ctrl.set_power_states().map_err(|e| {
+            warn!("{}", e);
+            e
+        })?)
+    }
+
+    /// 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) -> Result<(), ZbErr> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.write_effect_block(&data)?;
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl CtrlTask for CtrlAuraZbus {
+    fn zbus_path() -> &'static str {
+        AURA_ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, _: SignalContext<'static>) -> Result<(), RogError> {
+        let load_save = |start: bool, mut lock: MutexGuard<'_, CtrlKbdLed>| {
+            // If waking up
+            if !start {
+                info!("CtrlKbdLedTask reloading brightness and modes");
+                lock.sysfs_node
+                    .set_brightness(lock.config.brightness.into())
+                    .map_err(|e| error!("CtrlKbdLedTask: {e}"))
+                    .ok();
+                lock.write_current_config_mode()
+                    .map_err(|e| error!("CtrlKbdLedTask: {e}"))
+                    .ok();
+            } else if start {
+                Self::update_config(&mut lock)
+                    .map_err(|e| error!("CtrlKbdLedTask: {e}"))
+                    .ok();
+            }
+        };
+
+        let inner1 = self.0.clone();
+        let inner3 = self.0.clone();
+        self.create_sys_event_tasks(
+            move |sleeping| {
+                let inner1 = inner1.clone();
+                async move {
+                    let lock = inner1.lock().await;
+                    load_save(sleeping, lock);
+                }
+            },
+            move |_shutting_down| {
+                let inner3 = inner3.clone();
+                async move {
+                    let lock = inner3.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.sysfs_node.monitor_brightness()?;
+        tokio::spawn(async move {
+            let mut buffer = [0; 32];
+            watch
+                .into_event_stream(&mut buffer)
+                .unwrap()
+                .for_each(|_| async {
+                    if let Some(lock) = ctrl2.try_lock() {
+                        load_save(true, lock);
+                    }
+                })
+                .await;
+        });
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl crate::Reloadable for CtrlAuraZbus {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        let mut ctrl = self.0.lock().await;
+        debug!("CtrlKbdLedZbus: reloading keyboard mode");
+        ctrl.write_current_config_mode()?;
+        debug!("CtrlKbdLedZbus: reloading power states");
+        ctrl.set_power_states().map_err(|err| warn!("{err}")).ok();
+        Ok(())
+    }
+}

asusd/src/ctrl_fancurves.rs

@@ -0,0 +1,295 @@
+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) {
+        let mut fan_curves = self.fan_curves.lock().await;
+        let config = self.config.lock().await;
+        fan_curves.balanced = config.balanced.clone();
+        fan_curves.performance = config.performance.clone();
+        fan_curves.quiet = config.quiet.clone();
+    }
+
+    pub async fn update_config_from_profiles(&self) {
+        let fan_curves = self.fan_curves.lock().await;
+        let mut config = self.config.lock().await;
+        config.balanced = fan_curves.balanced.clone();
+        config.performance = fan_curves.performance.clone();
+        config.quiet = fan_curves.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<()> {
+        let mut fan_curves = self.fan_curves.lock().await;
+        fan_curves.set_profile_curves_enabled(profile, enabled);
+        fan_curves.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<()> {
+        let mut fan_curves = self.fan_curves.lock().await;
+        fan_curves.set_profile_fan_curve_enabled(profile, fan, enabled);
+        fan_curves.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 fan_curves = self.fan_curves.lock().await;
+        let curve = fan_curves.get_fan_curves_for(profile);
+        Ok(curve.to_vec())
+    }
+
+    /// 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<()> {
+        let mut fan_curves = self.fan_curves.lock().await;
+        fan_curves.save_fan_curve(curve, profile)?;
+        fan_curves.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 mut fan_curves = self.fan_curves.lock().await;
+        let active = self.platform.get_throttle_thermal_policy()?;
+        fan_curves.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 mut fan_curves = self.fan_curves.lock().await;
+
+        let active = self
+            .platform
+            .get_throttle_thermal_policy()
+            .unwrap_or(PlatformPolicy::Balanced.into());
+
+        self.platform.set_throttle_thermal_policy(profile.into())?;
+        fan_curves.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
+        //     self.fan_curves
+        //         .lock()
+        //         .await
+        //         .write_profile_curve_to_platform(active, &mut device)?;
+        // }
+        Ok(())
+    }
+}

asusd/src/ctrl_platform.rs

@@ -0,0 +1,703 @@
+use std::process::Command;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use config_traits::StdConfig;
+use log::{debug, error, info, warn};
+use rog_platform::cpu::CPUControl;
+use rog_platform::platform::{GpuMode, PlatformPolicy, Properties, RogPlatform};
+use rog_platform::power::AsusPower;
+use zbus::export::futures_util::lock::Mutex;
+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, task_watch_item_notify, CtrlTask};
+
+const ZBUS_PATH: &str = "/org/asuslinux/Platform";
+
+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 {
+                error!("RogPlatform: {} not supported", $prop_name);
+                return Err(FdoErr::NotSupported(format!("RogPlatform: {} not supported", $prop_name)));
+            }
+        })
+    }
+}
+
+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.ppt_pl1_spl.unwrap_or($default))
+            } else {
+                error!("RogPlatform: {} not supported", $prop_name);
+                return Err(FdoErr::NotSupported(format!("RogPlatform: {} not supported", $prop_name)));
+            }
+        })
+    }
+}
+
+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 {
+                error!("RogPlatform: {} not supported", $prop_name);
+                Err(FdoErr::NotSupported(format!("RogPlatform: {} not supported", $prop_name)))
+            }
+        })
+    }
+}
+
+/// 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 = 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.");
+        }
+
+        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> {
+        self.platform.set_gpu_mux_mode(mode.to_mux_attr())?;
+        // self.update_initramfs(enable)?;
+        if mode == GpuMode::Discrete {
+            info!("Set system-level graphics mode: Dedicated Nvidia");
+        } else {
+            info!("Set system-level graphics mode: Optimus");
+        }
+        Ok(())
+    }
+
+    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 {
+            // 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}");
+                }
+            }
+        }
+    }
+
+    async fn update_policy_ac_or_bat(&self, power_plugged: 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();
+        if let Some(cpu) = self.cpu_control.as_ref() {
+            cpu.set_epp(profile.into()).ok();
+        }
+    }
+}
+
+#[dbus_interface(name = "org.asuslinux.Daemon")]
+impl CtrlPlatform {
+    /// 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
+    }
+
+    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(),
+            ))
+        }
+    }
+
+    /// 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<'_>,
+    ) -> 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() {
+            if let Some(cpu) = self.cpu_control.as_ref() {
+                info!("PlatformPolicy setting EPP");
+                cpu.set_epp(policy.into())?
+            }
+            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}"))
+                })?;
+            self.config.lock().await.platform_policy_to_restore = policy;
+            Ok(self.throttle_thermal_policy_changed(&ctxt).await?)
+        } else {
+            Err(FdoErr::NotSupported(
+                "RogPlatform: throttle_thermal_policy not supported".to_owned(),
+            ))
+        }
+    }
+
+    #[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(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() {
+            if let Some(cpu) = self.cpu_control.as_ref() {
+                info!("PlatformPolicy setting EPP");
+                cpu.set_epp(policy.into())?
+            }
+            self.config.lock().await.platform_policy_to_restore = policy;
+            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(),
+            ))
+        }
+    }
+
+    #[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.
+    #[dbus_interface(property)]
+    fn panel_od(&self) -> Result<bool, FdoErr> {
+        platform_get_value!(self, panel_od, "panel_od")
+    }
+
+    #[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.
+    #[dbus_interface(property)]
+    fn mini_led_mode(&self) -> Result<bool, FdoErr> {
+        platform_get_value!(self, mini_led_mode, "mini_led_mode")
+    }
+
+    #[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)
+    }
+
+    #[dbus_interface(property)]
+    fn dgpu_disable(&self) -> Result<bool, FdoErr> {
+        platform_get_value!(self, dgpu_disable, "dgpu_disable")
+    }
+
+    #[dbus_interface(property)]
+    fn egpu_enable(&self) -> Result<bool, FdoErr> {
+        platform_get_value!(self, egpu_enable, "egpu_enable")
+    }
+
+    /// ************************************************************************
+    #[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)
+    }
+
+    #[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(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, ZBUS_PATH, server).await;
+    }
+}
+
+#[async_trait]
+impl crate::Reloadable for CtrlPlatform {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        if self.platform.has_panel_od() {
+            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() {
+                self.update_policy_ac_or_bat(power_plugged > 0).await;
+            }
+            self.run_ac_or_bat_cmd(power_plugged > 0).await;
+        }
+
+        Ok(())
+    }
+}
+
+impl CtrlPlatform {
+    task_watch_item!(panel_od 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_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]
+impl CtrlTask for CtrlPlatform {
+    fn zbus_path() -> &'static str {
+        ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
+        let platform1 = self.clone();
+        let platform2 = self.clone();
+        let platform3 = self.clone();
+        self.create_sys_event_tasks(
+            move |sleeping| {
+                let platform1 = platform1.clone();
+                async move {
+                    info!("RogPlatform reloading panel_od");
+                    if !sleeping && platform1.platform.has_panel_od() {
+                        platform1
+                            .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() {
+                            platform1.update_policy_ac_or_bat(power_plugged > 0).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
+                            })
+                            .ok();
+                    }
+                }
+            },
+            move |_lid_closed| {
+                // on lid change
+                async move {}
+            },
+            move |power_plugged| {
+                let platform3 = platform3.clone();
+                // power change
+                async move {
+                    if platform3.platform.has_throttle_thermal_policy() {
+                        platform3.update_policy_ac_or_bat(power_plugged).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?;
+
+        // 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_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}");
+                        })
+                    {
+                        if let Some(cpu) = ctrl.cpu_control.as_ref() {
+                            info!("PlatformPolicy setting EPP");
+                            cpu.set_epp(profile.into()).ok();
+                        }
+                        ctrl.config.lock().await.platform_policy_to_restore = profile;
+                    }
+                }
+            }
+        });
+
+        Ok(())
+    }
+}

asusd/src/daemon.rs

@@ -6,28 +6,21 @@ use std::time::Duration;
 
 use ::zbus::export::futures_util::lock::Mutex;
 use ::zbus::Connection;
-use daemon::ctrl_anime::CtrlAnime;
+use asusd::config::Config;
+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::CtrlAuraZbus;
+use asusd::ctrl_fancurves::CtrlFanCurveZbus;
+use asusd::ctrl_platform::CtrlPlatform;
+use asusd::{print_board_info, CtrlTask, Reloadable, ZbusRun, DBUS_NAME};
+use config_traits::{StdConfig, StdConfigLoad2};
 use log::{error, info, warn};
+use rog_aura::aura_detection::LaptopLedData;
 use tokio::time::sleep;
 use zbus::SignalContext;
 
-use daemon::ctrl_anime::{config::AnimeConfig, trait_impls::CtrlAnimeZbus};
-use daemon::ctrl_aura::{config::AuraConfig, controller::CtrlKbdLed, trait_impls::CtrlKbdLedZbus};
-use daemon::ctrl_platform::CtrlPlatform;
-use daemon::ctrl_power::CtrlPower;
-use daemon::ctrl_profiles::{
-    config::ProfileConfig, controller::CtrlPlatformProfile, trait_impls::ProfileZbus,
-};
-use daemon::laptops::LaptopLedData;
-use daemon::{
-    config::Config, ctrl_supported::SupportedFunctions, laptops::print_board_info, GetSupported,
-};
-use daemon::{CtrlTask, Reloadable, ZbusRun};
-use rog_dbus::DBUS_NAME;
-use rog_profiles::Profile;
-
-static PROFILE_CONFIG_PATH: &str = "/etc/asusd/profile.conf";
-
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut logger = env_logger::Builder::new();
@@ -51,10 +44,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         return Ok(());
     }
 
-    info!("       daemon v{}", daemon::VERSION);
+    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);
 
@@ -64,17 +56,17 @@ 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!("{}", serde_json::to_string_pretty(&supported)?);
+    // println!("{:?}", supported.supported_functions());
 
     // Start zbus server
     let mut connection = Connection::system().await?;
 
-    let config = Config::load();
+    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) => {
@@ -86,33 +78,17 @@ 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::load(PROFILE_CONFIG_PATH.into());
-        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::load()) {
+    match CtrlAnime::new(AnimeConfig::new().load()) {
         Ok(ctrl) => {
             let zbus = CtrlAnimeZbus(Arc::new(Mutex::new(ctrl)));
             let sig_ctx = CtrlAnimeZbus::signal_context(&connection)?;
@@ -124,11 +100,12 @@ async fn start_daemon() -> Result<(), Box<dyn Error>> {
     }
 
     let laptop = LaptopLedData::get_data();
-    let aura_config = AuraConfig::load(&laptop);
-    match CtrlKbdLed::new(laptop, aura_config) {
+    // CtrlKbdLed deviates from the config pattern above due to requiring a keyboard
+    // 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/error.rs

@@ -1,8 +1,10 @@
+use std::convert::From;
+use std::fmt;
+
+use config_traits::ron;
 use rog_anime::error::AnimeError;
 use rog_platform::error::PlatformError;
 use rog_profiles::error::ProfileError;
-use std::convert::From;
-use std::fmt;
 
 #[derive(Debug)]
 pub enum RogError {
@@ -33,6 +35,7 @@ pub enum RogError {
     SystemdUnitAction(String),
     SystemdUnitWaitTimeout(String),
     Command(String, std::io::Error),
+    ParseRon(ron::Error),
 }
 
 impl fmt::Display for RogError {
@@ -50,14 +53,21 @@ impl fmt::Display for RogError {
             RogError::NotFound(deets) => write!(f, "Not found: {}", deets),
             RogError::DoTask(deets) => write!(f, "Task error: {}", deets),
             RogError::MissingFunction(deets) => write!(f, "Missing functionality: {}", deets),
-            RogError::MissingLedBrightNode(path, error) => write!(f, "Led node at {} is missing, please check you have the required patch or dkms module installed: {}", path, error),
+            RogError::MissingLedBrightNode(path, error) => write!(
+                f,
+                "Led node at {} is missing, please check you have the required patch or dkms \
+                 module installed: {}",
+                path, error
+            ),
             RogError::ReloadFail(deets) => write!(f, "Reload error: {}", deets),
             RogError::Profiles(deets) => write!(f, "Profile error: {}", deets),
             RogError::Initramfs(detail) => write!(f, "Initiramfs error: {}", detail),
             RogError::Modprobe(detail) => write!(f, "Modprobe error: {}", detail),
             RogError::Io(detail) => write!(f, "std::io error: {}", detail),
             RogError::Zbus(detail) => write!(f, "Zbus error: {}", detail),
-            RogError::ChargeLimit(value) => write!(f, "Invalid charging limit, not in range 20-100%: {}", value),
+            RogError::ChargeLimit(value) => {
+                write!(f, "Invalid charging limit, not in range 20-100%: {}", value)
+            }
             RogError::AuraEffectNotSupported => write!(f, "Aura effect not supported"),
             RogError::NoAuraKeyboard => write!(f, "No supported Aura keyboard"),
             RogError::NoAuraNode => write!(f, "No Aura keyboard node found"),
@@ -74,6 +84,7 @@ impl fmt::Display for RogError {
                 )
             }
             RogError::Command(func, error) => write!(f, "Command exec error: {}: {}", func, error),
+            RogError::ParseRon(error) => write!(f, "Parse config error: {}", error),
         }
     }
 }
@@ -110,6 +121,12 @@ impl From<std::io::Error> for RogError {
     }
 }
 
+impl From<ron::Error> for RogError {
+    fn from(err: ron::Error) -> Self {
+        RogError::ParseRon(err)
+    }
+}
+
 impl From<RogError> for zbus::fdo::Error {
     #[inline]
     fn from(err: RogError) -> Self {

asusd/src/lib.rs

@@ -0,0 +1,285 @@
+#![deny(unused_must_use)]
+/// Configuration loading, saving
+pub mod config;
+/// Control of anime matrix display
+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;
+
+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 tokio::time::sleep;
+use zbus::zvariant::ObjectPath;
+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`.
+///
+/// The generated function is `watch_<name>()`. Self requires the following
+/// methods to be available:
+/// - `<name>() -> SomeValue`, functionally is a getter, but is allowed to have
+///   side effects.
+/// - `notify_<name>(SignalContext, SomeValue)`
+///
+/// In most cases if `SomeValue` is stored in a config then `<name>()` getter is
+/// expected to update it. The getter should *never* write back to the path or
+/// attribute that is being watched or an infinite loop will occur.
+///
+/// # Example
+///
+/// ```ignore
+/// impl RogPlatform {
+///     task_watch_item!(panel_od platform);
+///     task_watch_item!(gpu_mux_mode platform);
+/// }
+/// ```
+/// // TODO: this is kind of useless if it can't trigger some action
+#[macro_export]
+macro_rules! task_watch_item {
+    ($name:ident $self_inner:ident) => {
+        concat_idents::concat_idents!(fn_name = watch_, $name {
+        async fn fn_name(
+            &self,
+            signal_ctxt: SignalContext<'static>,
+        ) -> Result<(), RogError> {
+            use zbus::export::futures_util::StreamExt;
+
+            let ctrl = self.clone();
+            concat_idents::concat_idents!(watch_fn = monitor_, $name {
+                match self.$self_inner.watch_fn() {
+                    Ok(watch) => {
+                        tokio::spawn(async move {
+                            let mut buffer = [0; 32];
+                            watch.into_event_stream(&mut buffer).unwrap().for_each(|_| async {
+                                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;
+                        });
+                    }
+                    Err(e) => info!("inotify watch failed: {}. You can ignore this if your device does not support the feature", e),
+                }
+            });
+            Ok(())
+        }
+        });
+    };
+}
+
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+pub fn print_board_info() {
+    let dmi = DMIID::new().unwrap_or_default();
+    info!("Product family: {}", dmi.product_family);
+    info!("Board name: {}", dmi.board_name);
+}
+
+#[async_trait]
+pub trait Reloadable {
+    async fn reload(&mut self) -> Result<(), RogError>;
+}
+
+#[async_trait]
+pub trait ZbusRun {
+    async fn add_to_server(self, server: &mut Connection);
+
+    async fn add_to_server_helper(
+        iface: impl zbus::Interface,
+        path: &str,
+        server: &mut Connection,
+    ) {
+        server
+            .object_server()
+            .at(&ObjectPath::from_str_unchecked(path), iface)
+            .await
+            .map_err(|err| {
+                warn!("{}: add_to_server {}", path, err);
+                err
+            })
+            .ok();
+    }
+}
+
+/// Set up a task to run on the async executor
+#[async_trait]
+pub trait CtrlTask {
+    fn zbus_path() -> &'static str;
+
+    fn signal_context(connection: &Connection) -> Result<SignalContext<'static>, zbus::Error> {
+        SignalContext::new(connection, Self::zbus_path())
+    }
+
+    /// Implement to set up various tasks that may be required, using the
+    /// `Executor`. No blocking loops are allowed, or they must be run on a
+    /// separate thread.
+    async fn create_tasks(&self, signal: SignalContext<'static>) -> Result<(), RogError>;
+
+    // /// Create a timed repeating task
+    // async fn repeating_task(&self, millis: u64, mut task: impl FnMut() + Send +
+    // 'static) {     use std::time::Duration;
+    //     use tokio::time;
+    //     let mut timer = time::interval(Duration::from_millis(millis));
+    //     tokio::spawn(async move {
+    //         timer.tick().await;
+    //         task();
+    //     });
+    // }
+
+    /// Free helper method to create tasks to run on: sleep, wake, shutdown,
+    /// boot
+    ///
+    /// The closures can potentially block, so execution time should be the
+    /// minimal possible such as save a variable.
+    async fn create_sys_event_tasks<
+        Fut1,
+        Fut2,
+        Fut3,
+        Fut4,
+        F1: Send + 'static,
+        F2: Send + 'static,
+        F3: Send + 'static,
+        F4: Send + 'static,
+    >(
+        &self,
+        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(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,
+        Fut4: Future<Output = ()> + Send,
+    {
+        let connection = Connection::system()
+            .await
+            .expect("Controller could not create dbus 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) = manager1.receive_prepare_for_shutdown().await {
+                while let Some(event) = notif.next().await {
+                    // blocks thread :|
+                    if let Ok(args) = event.args() {
+                        debug!("Doing on_prepare_for_shutdown({})", args.start);
+                        on_prepare_for_shutdown(args.start).await;
+                    }
+                }
+            }
+        });
+
+        let manager2 = manager.clone();
+        tokio::spawn(async move {
+            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() {
+                        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;
+            }
+        });
+    }
+}
+
+pub trait GetSupported {
+    type A;
+
+    fn get_supported() -> Self::A;
+}

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

@@ -0,0 +1,57 @@
+<!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">
+    <!--
+     Writes a data stream of length. Will force system thread to exit until
+     it is restarted
+     -->
+    <method name="Write">
+      <arg name="input" type="(ays)" direction="in"/>
+    </method>
+    <!--
+     The main loop is the base system set action if the user isn't running
+     the user daemon
+     -->
+    <method name="RunMainLoop">
+      <arg name="start" type="b" direction="in"/>
+    </method>
+    <!--
+     Get the device state as stored by asusd
+     -->
+    <method name="DeviceState">
+      <arg type="(bub(ssss)bbbu)" direction="out"/>
+    </method>
+    <!--
+     Set base brightness level
+     -->
+    <!--
+     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

@@ -0,0 +1,65 @@
+<!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">
+    <!--
+     Get the data set for every mode available
+     -->
+    <method name="AllModeData">
+      <arg type="a{u(us(yyy)(yyy)ss)}" direction="out"/>
+    </method>
+    <!--
+     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
+     -->
+    <method name="DirectAddressingRaw">
+      <arg name="data" type="aay" direction="in"/>
+    </method>
+    <!--
+     Return the current LED brightness
+     -->
+    <!--
+     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="(us(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="(asas((sbbbb)(sbbbb)(sbbbb)(sbbbb)(sbbbb)))" access="readwrite"/>
+    <!--
+     Total levels of brightness available
+     -->
+    <property name="SupportedBrightness" type="au" access="read"/>
+    <!--
+     The total available modes
+     -->
+    <property name="SupportedModes" type="au" access="read"/>
+  </interface>
+</node>

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

@@ -0,0 +1,56 @@
+<!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">
+    <!--
+     Set all fan curves for a profile to enabled status. Will also activate a
+     fan curve if in the same profile mode
+     -->
+    <method name="SetFanCurvesEnabled">
+      <arg name="profile" type="s" direction="in"/>
+      <arg name="enabled" type="b" direction="in"/>
+    </method>
+    <!--
+     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="a(s(yyyyyyyy)(yyyyyyyy)b)" direction="out"/>
+    </method>
+    <!--
+     Set the fan curve for the specified profile.
+     Will also activate the fan curve if the user is in the same mode.
+     -->
+    <method name="SetFanCurve">
+      <arg name="profile" type="s" 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
+     platform.
+
+     Each platform_profile has a different default and the defualt can be
+     read only for the currently active profile.
+     -->
+    <method name="SetActiveCurveToDefaults">
+    </method>
+    <!--
+     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.
+     -->
+    <method name="ResetProfileCurves">
+      <arg name="profile" type="s" direction="in"/>
+    </method>
+  </interface>
+</node>

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

@@ -0,0 +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">
+    <!--
+     Returns a list of property names that this system supports
+     -->
+    <method name="SupportedProperties">
+      <arg type="as" direction="out"/>
+    </method>
+    <method name="SupportedInterfaces">
+      <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="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.
+     -->
+    <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.
+     -->
+    <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/ts/anime.ts

@@ -0,0 +1,57 @@
+/*
+ Generated by typeshare 1.7.0
+*/
+
+export enum AnimBooting {
+	GlitchConstruction = "GlitchConstruction",
+	StaticEmergence = "StaticEmergence",
+}
+
+export enum AnimAwake {
+	BinaryBannerScroll = "BinaryBannerScroll",
+	RogLogoGlitch = "RogLogoGlitch",
+}
+
+export enum AnimSleeping {
+	BannerSwipe = "BannerSwipe",
+	Starfield = "Starfield",
+}
+
+export enum AnimShutdown {
+	GlitchOut = "GlitchOut",
+	SeeYa = "SeeYa",
+}
+
+export interface Animations {
+	boot: AnimBooting;
+	awake: AnimAwake;
+	sleep: AnimSleeping;
+	shutdown: AnimShutdown;
+}
+
+/** Base LED brightness of the display */
+export enum Brightness {
+	Off = "Off",
+	Low = "Low",
+	Med = "Med",
+	High = "High",
+}
+
+export interface DeviceState {
+	display_enabled: boolean;
+	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 {
+	GA401 = "GA401",
+	GA402 = "GA402",
+	GU604 = "GU604",
+	Unknown = "Unknown",
+}
+

bindings/ts/aura.ts

@@ -0,0 +1,233 @@
+/*
+ Generated by typeshare 1.7.0
+*/
+
+/** Represents the per-key raw USB packets */
+export type UsbPackets = number[][];
+
+/**
+ * A `UsbPackets` contains all data to change the full set of keyboard
+ * key colours individually.
+ * 
+ * Each row of the internal array is a full HID packet that can be sent
+ * to the keyboard EC. One row controls one group of keys, these keys are not
+ * necessarily all on the same row of the keyboard, with some splitting between
+ * two rows.
+ */
+export interface LedUsbPackets {
+	/** The packet data used to send data to the USB keyboard */
+	usb_packets: UsbPackets;
+	/**
+	 * Wether or not this packet collection is zoned. The determines which
+	 * starting bytes are used and what the indexing is for lightbar RGB
+	 * colours
+	 */
+	zoned: boolean;
+}
+
+export interface Colour {
+	r: number;
+	g: number;
+	b: number;
+}
+
+/** Enum of modes that convert to the actual number required by a USB HID packet */
+export enum AuraModeNum {
+	Static = "Static",
+	Breathe = "Breathe",
+	Strobe = "Strobe",
+	Rainbow = "Rainbow",
+	Star = "Star",
+	Rain = "Rain",
+	Highlight = "Highlight",
+	Laser = "Laser",
+	Ripple = "Ripple",
+	Pulse = "Pulse",
+	Comet = "Comet",
+	Flash = "Flash",
+}
+
+/** Base effects have no zoning, while multizone is 1-4 */
+export enum AuraZone {
+	/** Used if keyboard has no zones, or if setting all */
+	None = "None",
+	/** Leftmost zone */
+	Key1 = "Key1",
+	/** Zone after leftmost */
+	Key2 = "Key2",
+	/** Zone second from right */
+	Key3 = "Key3",
+	/** Rightmost zone */
+	Key4 = "Key4",
+	/** Logo on the lid (or elsewhere?) */
+	Logo = "Logo",
+	/** The left part of a lightbar (typically on the front of laptop) */
+	BarLeft = "BarLeft",
+	/** The right part of a lightbar */
+	BarRight = "BarRight",
+}
+
+export enum Speed {
+	Low = "Low",
+	Med = "Med",
+	High = "High",
+}
+
+/**
+ * Used for Rainbow mode.
+ * 
+ * Enum corresponds to the required integer value
+ */
+export enum Direction {
+	Right = "Right",
+	Left = "Left",
+	Up = "Up",
+	Down = "Down",
+}
+
+/**
+ * Default factory modes structure. This easily converts to an USB HID packet
+ * with:
+ * ```rust
+ * // let bytes: [u8; LED_MSG_LEN] = mode.into();
+ * ```
+ */
+export interface AuraEffect {
+	/** The effect type */
+	mode: AuraModeNum;
+	/** `AuraZone::None` for no zone or zoneless keyboards */
+	zone: AuraZone;
+	/** Primary colour for all modes */
+	colour1: Colour;
+	/** Secondary colour in some modes like Breathing or Stars */
+	colour2: Colour;
+	/** One of three speeds for modes that support speed (most that animate) */
+	speed: Speed;
+	/** Up, down, left, right. Only Rainbow mode seems to use this */
+	direction: Direction;
+}
+
+/** The powerr zones this laptop supports */
+export enum PowerZones {
+	/** The logo on some laptop lids */
+	Logo = "Logo",
+	/** The full keyboard (not zones) */
+	Keyboard = "Keyboard",
+	/** The lightbar, typically on the front of the laptop */
+	Lightbar = "Lightbar",
+	/** The leds that may be placed around the edge of the laptop lid */
+	Lid = "Lid",
+	/** The led strip on the rear of some laptops */
+	RearGlow = "RearGlow",
+}
+
+export interface KbAuraPowerState {
+	zone: PowerZones;
+	boot: boolean;
+	awake: boolean;
+	sleep: boolean;
+	shutdown: boolean;
+}
+
+/**
+ * Track and control the Aura keyboard power state
+ * 
+ * # Bits for newer 0x18c6, 0x19B6, 0x1a30, keyboard models
+ * 
+ * | Byte 1 | Byte 2  | Byte 3  | Byte 4  | Label    |
+ * |--------|---------|---------|---------|----------|
+ * |00000001| 00000000| 00000000| 00000000|boot_logo_|
+ * |00000010| 00000000| 00000000| 00000000|boot_keyb_|
+ * |00000100| 00000000| 00000000| 00000000|awake_logo|
+ * |00001000| 00000000| 00000000| 00000000|awake_keyb|
+ * |00010000| 00000000| 00000000| 00000000|sleep_logo|
+ * |00100000| 00000000| 00000000| 00000000|sleep_keyb|
+ * |01000000| 00000000| 00000000| 00000000|shut_logo_|
+ * |10000000| 00000000| 00000000| 00000000|shut_keyb_|
+ * |00000000| 00000010| 00000000| 00000000|boot_bar__|
+ * |00000000| 00000100| 00000000| 00000000|awake_bar_|
+ * |00000000| 00001000| 00000000| 00000000|sleep_bar_|
+ * |00000000| 00010000| 00000000| 00000000|shut_bar__|
+ * |00000000| 00000000| 00000001| 00000000|boot_lid__|
+ * |00000000| 00000000| 00000010| 00000000|awkae_lid_|
+ * |00000000| 00000000| 00000100| 00000000|sleep_lid_|
+ * |00000000| 00000000| 00001000| 00000000|shut_lid__|
+ * |00000000| 00000000| 00000000| 00000001|boot_rear_|
+ * |00000000| 00000000| 00000000| 00000010|awake_rear|
+ * |00000000| 00000000| 00000000| 00000100|sleep_rear|
+ * |00000000| 00000000| 00000000| 00001000|shut_rear_|
+ */
+export interface AuraPower {
+	keyboard: KbAuraPowerState;
+	logo: KbAuraPowerState;
+	lightbar: KbAuraPowerState;
+	lid: KbAuraPowerState;
+	rear_glow: KbAuraPowerState;
+}
+
+export enum AuraDevTuf {
+	Boot = "Boot",
+	Awake = "Awake",
+	Sleep = "Sleep",
+	Keyboard = "Keyboard",
+}
+
+/**
+ * # Bits for older 0x1866 keyboard model
+ * 
+ * Keybord and Lightbar require Awake, Boot and Sleep apply to both
+ * Keybord and Lightbar regardless of if either are enabled (or Awake is
+ * enabled)
+ * 
+ * |   Byte 1   |   Byte 2   |   Byte 3   | function |   hex    |
+ * |------------|------------|------------|----------|----------|
+ * | 0000, 0000 | 0000, 0000 | 0000, 0010 | Awake    | 00,00,02 |
+ * | 0000, 1000 | 0000, 0000 | 0000, 0000 | Keyboard | 08,00,00 |
+ * | 0000, 0100 | 0000, 0101 | 0000, 0000 | Lightbar | 04,05,00 |
+ * | 1100, 0011 | 0001, 0010 | 0000, 1001 | Boot/Sht | c3,12,09 |
+ * | 0011, 0000 | 0000, 1000 | 0000, 0100 | Sleep    | 30,08,04 |
+ * | 1111, 1111 | 0001, 1111 | 0000, 1111 | all on   |          |
+ */
+export enum AuraDevRog1 {
+	Awake = "Awake",
+	Keyboard = "Keyboard",
+	Lightbar = "Lightbar",
+	Boot = "Boot",
+	Sleep = "Sleep",
+}
+
+/** This struct is intended as a helper to pass args to generic dbus interface */
+export interface AuraPowerDev {
+	/**
+	 * TUF laptops use a similar style of control to the older ROG devices but
+	 * through WMI
+	 */
+	tuf: AuraDevTuf[];
+	/**
+	 * Pre-0x19b6 devices use a different smaller scheme to the newer ROG
+	 * devices
+	 */
+	old_rog: AuraDevRog1[];
+	/** ASUS standardised control scheme from 2020 onwards */
+	rog: AuraPower;
+}
+
+export enum LedBrightness {
+	Off = "Off",
+	Low = "Low",
+	Med = "Med",
+	High = "High",
+}
+
+export enum AuraDevice {
+	Tuf = "Tuf",
+	X1854 = "X1854",
+	X1869 = "X1869",
+	X1866 = "X1866",
+	X18c6 = "X18c6",
+	X19b6 = "X19b6",
+	X1a30 = "X1a30",
+	X1abe = "X1abe",
+	Unknown = "Unknown",
+}
+

bindings/ts/platform.ts

@@ -0,0 +1,40 @@
+/*
+ Generated by typeshare 1.7.0
+*/
+
+export enum GpuMode {
+	Discrete = "Discrete",
+	Optimus = "Optimus",
+	Integrated = "Integrated",
+	Egpu = "Egpu",
+	Vfio = "Vfio",
+	Ultimate = "Ultimate",
+	Error = "Error",
+	NotSupported = "NotSupported",
+}
+
+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

@@ -0,0 +1,24 @@
+/*
+ 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];
+	enabled: boolean;
+}
+
+/** Main purpose of `FanCurves` is to enable restoring state on system boot */
+export interface FanCurveProfiles {
+	balanced: CurveData[];
+	performance: CurveData[];
+	quiet: CurveData[];
+}
+

config-traits/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "config-traits"
+license = "MPL-2.0"
+authors = ["Luke D Jones <luke@ljones.dev>"]
+edition = "2021"
+version.workspace = true
+
+[dependencies]
+serde.workspace = true
+serde_derive.workspace = true
+serde_json.workspace = true
+toml.workspace = true
+ron.workspace = true
+
+log.workspace = true
+
+[dev-dependencies]
+cargo-husky.workspace = true

config-traits/README.md

@@ -0,0 +1,10 @@
+# config-traits
+
+`config_traits` is a crate that broke out from the requirement to manage various
+different config files, including parsing from different formats and updating
+them from previous versions where fields or names are changed in some way.
+
+The end canonical file format is `.ron` as this supports rust types well, and includes
+the ability to add commenting, and is less verbose than `json`. Currently the crate will
+also try to parse from `json` and `toml` if the `ron` parsing fails, then update to `ron`
+format.

config-traits/src/lib.rs

@@ -0,0 +1,328 @@
+//! `config_traits` is a crate that broke out from the requirement to manage
+//! various different config files, including parsing from different formats and
+//! updating them from previous versions where fields or names are changed in
+//! some way.
+//!
+//! The end canonical file format is `.ron` as this supports rust types well,
+//! and includes the ability to add commenting, and is less verbose than `json`.
+//! Currently the crate will also try to parse from `json` and `toml` if the
+//! `ron` parsing fails, then update to `ron` format.
+
+use std::fs::{self, create_dir, File, OpenOptions};
+use std::io::{Read, Write};
+use std::path::PathBuf;
+
+use log::{error, warn};
+pub use ron;
+use ron::ser::PrettyConfig;
+use serde::de::DeserializeOwned;
+use serde::Serialize;
+
+/// Config file helper traits. Only `new()` and `file_name()` are required to be
+/// implemented, the rest are intended to be free methods.
+pub trait StdConfig
+where
+    Self: Serialize + DeserializeOwned,
+{
+    /// Taking over the standard `new()` to ensure things can be generic
+    fn new() -> Self;
+
+    /// Return the config files names, such as `wibble.cfg`
+    fn file_name(&self) -> String;
+
+    /// Return the full path to the directory the config file resides in
+    fn config_dir() -> PathBuf;
+
+    /// Return the full path to the config file
+    fn file_path(&self) -> PathBuf {
+        let mut config = Self::config_dir();
+        if !config.exists() {
+            create_dir(config.as_path())
+                .unwrap_or_else(|e| panic!("Could not create {:?} {e}", Self::config_dir()));
+        }
+        config.push(self.file_name());
+        let mut do_rename = !config.exists();
+        let mut cfg_old = config.clone();
+        // Migrating all configs to .ron format, so we do need to check for older ones
+        if do_rename {
+            warn!("Config {cfg_old:?} does not exist, looking for .cfg next");
+            cfg_old.pop();
+            let tmp = self.file_name();
+            let parts: Vec<_> = tmp.split('.').collect();
+            cfg_old.push(format!("{}.cfg", parts[0]));
+        }
+        if do_rename && cfg_old.exists() {
+            // Now we gotta rename it
+            warn!("Renaming {cfg_old:?} to {config:?}");
+            std::fs::rename(&cfg_old, &config).unwrap_or_else(|err| {
+                error!(
+                    "Could not rename. Please remove {} then restart service: Error {}",
+                    self.file_name(),
+                    err
+                );
+            });
+            do_rename = false;
+        }
+        if do_rename && !cfg_old.exists() {
+            warn!("Config {cfg_old:?} does not exist, looking for .conf next");
+            cfg_old.pop();
+            let tmp = self.file_name();
+            let parts: Vec<_> = tmp.split('.').collect();
+            cfg_old.push(format!("{}.conf", parts[0]));
+        }
+        if do_rename && cfg_old.exists() {
+            // Now we gotta rename it
+            warn!("Renaming {cfg_old:?} to {config:?}");
+            std::fs::rename(&cfg_old, &config).unwrap_or_else(|err| {
+                error!(
+                    "Could not rename. Please remove {} then restart service: Error {}",
+                    self.file_name(),
+                    err
+                );
+            });
+        }
+        config
+    }
+
+    /// Directly open the config file for read and write. If the config file
+    /// does not exist it is created, including the directories the file
+    /// resides in.
+    fn file_open(&self) -> File {
+        OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .open(self.file_path())
+            .unwrap_or_else(|e| panic!("Could not open {:?} {e}", self.file_path()))
+    }
+
+    /// Open and parse the config file to self from ron format
+    fn read(&mut self) {
+        if let Ok(data) = fs::read_to_string(self.file_path()) {
+            if data.is_empty() {
+                warn!("File is empty {:?}", self.file_path());
+            } else if let Ok(data) = ron::from_str(&data) {
+                *self = data;
+            } else {
+                warn!("Could not deserialise {:?}", self.file_path());
+            }
+        }
+    }
+
+    /// Write the config file data to pretty ron format
+    fn write(&self) {
+        let mut file = match File::create(self.file_path()) {
+            Ok(data) => data,
+            Err(e) => {
+                error!(
+                    "Couldn't overwrite config {:?}, error: {e}",
+                    self.file_path()
+                );
+                return;
+            }
+        };
+        let ron = match ron::ser::to_string_pretty(&self, PrettyConfig::new().depth_limit(4)) {
+            Ok(data) => data,
+            Err(e) => {
+                error!("Parse {:?} to RON failed, error: {e}", self.file_path());
+                return;
+            }
+        };
+        file.write_all(ron.as_bytes())
+            .unwrap_or_else(|err| error!("Could not write config: {}", err));
+    }
+
+    /// Renames the existing file to `<file>-old`
+    fn rename_file_old(&self) {
+        warn!(
+            "Renaming {} to {}-old and recreating config",
+            self.file_name(),
+            self.file_name()
+        );
+        let mut cfg_old = self.file_path().to_string_lossy().to_string();
+        cfg_old.push_str("-old");
+        std::fs::rename(self.file_path(), cfg_old).unwrap_or_else(|err| {
+            error!(
+                "Could not rename. Please remove {} then restart service: Error {}",
+                self.file_name(),
+                err
+            );
+        });
+    }
+}
+
+#[macro_export]
+macro_rules! std_config_load {
+    ($trait_name:ident: $($generic:ident),*) => {
+        /// Base trait for loading/parsing. This is intended to be used to help update
+        /// configs to new versions
+        ///
+        /// # Example
+        /// ```rust
+        /// use std::path::PathBuf;
+        /// use serde::{Deserialize, Serialize};
+        /// use config_traits::{StdConfig, StdConfigLoad2};
+        ///
+        /// #[derive(Deserialize, Serialize, Debug)]
+        /// struct FanCurveConfigOld {}
+        ///
+        /// #[derive(Deserialize, Serialize, Debug)]
+        /// struct FanCurveConfigOlder {}
+        ///
+        /// #[derive(Deserialize, Serialize, Debug)]
+        /// struct FanCurveConfig {}
+        ///
+        /// impl From<FanCurveConfigOld> for FanCurveConfig {
+        ///     fn from(_: FanCurveConfigOld) -> Self { Self {} }
+        /// }
+        ///
+        /// impl From<FanCurveConfigOlder> for FanCurveConfig {
+        ///     fn from(_: FanCurveConfigOlder) -> Self { Self {} }
+        /// }
+        ///
+        /// impl StdConfig for FanCurveConfig {
+        ///     fn new() -> Self { Self {} }
+        ///
+        ///     fn file_name(&self) -> std::string::String { "test_name.conf".to_owned() }
+        ///
+        ///     fn config_dir() -> PathBuf { PathBuf::from("/tmp") }
+        /// }
+        ///
+        /// impl StdConfigLoad2<FanCurveConfigOld, FanCurveConfigOlder> for FanCurveConfig {}
+        /// ```
+        ///
+        /// If all of the generics fails to parse, then the old config is renamed and a
+        /// new one created
+        pub trait $trait_name<$($generic),*>
+        where
+            Self: $crate::StdConfig +std::fmt::Debug + DeserializeOwned + Serialize,
+            $($generic: DeserializeOwned + Into<Self>),*
+        {
+            fn load(mut self) -> Self {
+                let mut file = self.file_open();
+                let mut buf = String::new();
+                if let Ok(read_len) = file.read_to_string(&mut buf) {
+                    if read_len != 0 {
+                        if let Ok(data) = ron::from_str(&buf) {
+                            self = data;
+                            log::info!("Parsed RON for {:?}", std::any::type_name::<Self>());
+                        } else if let Ok(data) = serde_json::from_str(&buf) {
+                            self = data;
+                            log::info!("Parsed JSON for {:?}", std::any::type_name::<Self>());
+                        } else if let Ok(data) = toml::from_str(&buf) {
+                            self = data;
+                            log::info!("Parsed TOML for {:?}", std::any::type_name::<Self>());
+                        } $(else if let Ok(data) = ron::from_str::<$generic>(&buf) {
+                            self = data.into();
+                            log::info!("New version failed, trying previous: Parsed RON for {:?}", std::any::type_name::<$generic>());
+                        } else if let Ok(data) = serde_json::from_str::<$generic>(&buf) {
+                            self = data.into();
+                            log::info!("New version failed, trying previous: Parsed JSON for {:?}", std::any::type_name::<$generic>());
+                        } else if let Ok(data) = toml::from_str::<$generic>(&buf) {
+                            self = data.into();
+                            log::info!("Newvious version failed, trying previous: Parsed TOML for {:?}", std::any::type_name::<$generic>());
+                        })* else {
+                            self.rename_file_old();
+                            self = Self::new();
+                        }
+                    } else {
+                        error!("Config file {} zero read length", self.file_name());
+                    }
+                }
+                self.write();
+                self
+            }
+        }
+    };
+}
+
+std_config_load!(StdConfigLoad:);
+std_config_load!(StdConfigLoad1: T1);
+std_config_load!(StdConfigLoad2: T1, T2);
+std_config_load!(StdConfigLoad3: T1, T2, T3);
+std_config_load!(StdConfigLoad4: T1, T2, T3, T4);
+
+#[cfg(test)]
+mod tests {
+    use std::path::PathBuf;
+
+    #[test]
+    fn check_macro_from_1() {
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Test {}
+
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Old1 {}
+
+        impl crate::StdConfig for Test {
+            fn new() -> Self {
+                Self {}
+            }
+
+            fn file_name(&self) -> String {
+                String::new()
+            }
+
+            fn config_dir() -> PathBuf {
+                PathBuf::new()
+            }
+        }
+
+        impl From<Old1> for Test {
+            fn from(_: Old1) -> Self {
+                Self {}
+            }
+        }
+
+        impl crate::StdConfigLoad1<Old1> for Test {}
+    }
+
+    #[test]
+    fn check_macro_from_3() {
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Test {}
+
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Old1 {}
+
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Old2 {}
+
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Old3 {}
+
+        impl crate::StdConfig for Test {
+            fn new() -> Self {
+                Self {}
+            }
+
+            fn file_name(&self) -> String {
+                String::new()
+            }
+
+            fn config_dir() -> PathBuf {
+                PathBuf::new()
+            }
+        }
+
+        impl From<Old1> for Test {
+            fn from(_: Old1) -> Self {
+                Self {}
+            }
+        }
+
+        impl From<Old2> for Test {
+            fn from(_: Old2) -> Self {
+                Self {}
+            }
+        }
+
+        impl From<Old3> for Test {
+            fn from(_: Old3) -> Self {
+                Self {}
+            }
+        }
+
+        impl crate::StdConfigLoad3<Old1, Old2, Old3> for Test {}
+    }
+}

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);
+    }
+}

daemon-user/src/user_config.rs

@@ -1,318 +0,0 @@
-use std::{
-    fs::{create_dir, OpenOptions},
-    io::{Read, Write},
-    time::Duration,
-};
-
-use rog_anime::{ActionLoader, AnimTime, AnimeType, Fade, Sequences, Vec2};
-use rog_aura::{keys::Key, Breathe, Colour, Effect, Flicker, LedType, Speed, Static};
-use serde::de::DeserializeOwned;
-use serde_derive::{Deserialize, Serialize};
-
-use crate::error::Error;
-
-pub trait ConfigLoadSave<T: DeserializeOwned + serde::Serialize> {
-    fn name(&self) -> String;
-
-    fn default_with_name(name: String) -> T;
-
-    fn write(&self) -> Result<(), Error>
-    where
-        Self: serde::Serialize,
-    {
-        let mut path = if let Some(dir) = dirs::config_dir() {
-            dir
-        } else {
-            return Err(Error::XdgVars);
-        };
-
-        path.push("rog");
-        if !path.exists() {
-            create_dir(path.clone())?;
-        }
-        let name = self.name();
-        path.push(name + ".cfg");
-
-        let mut file = OpenOptions::new()
-            .write(true)
-            .create(true)
-            .truncate(true)
-            .open(&path)?;
-
-        let json = serde_json::to_string_pretty(&self).unwrap();
-        file.write_all(json.as_bytes())?;
-        Ok(())
-    }
-
-    fn load(name: String) -> Result<T, Error> {
-        let mut path = if let Some(dir) = dirs::config_dir() {
-            dir
-        } else {
-            return Err(Error::XdgVars);
-        };
-
-        path.push("rog");
-        if !path.exists() {
-            create_dir(path.clone())?;
-        }
-
-        path.push(name.clone() + ".cfg");
-
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(&path)?;
-
-        let mut buf = String::new();
-
-        if let Ok(read_len) = file.read_to_string(&mut buf) {
-            if read_len == 0 {
-                let default = Self::default_with_name(name);
-                let json = serde_json::to_string_pretty(&default).unwrap();
-                file.write_all(json.as_bytes())?;
-                return Ok(default);
-            } else if let Ok(data) = serde_json::from_str::<T>(&buf) {
-                return Ok(data);
-            }
-        }
-        Err(Error::ConfigLoadFail)
-    }
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-pub struct UserAnimeConfig {
-    pub name: String,
-    pub anime: Vec<ActionLoader>,
-}
-
-impl UserAnimeConfig {
-    pub fn create(&self, anime_type: AnimeType) -> Result<Sequences, Error> {
-        let mut seq = Sequences::new(anime_type);
-
-        for (idx, action) in self.anime.iter().enumerate() {
-            seq.insert(idx, action)?;
-        }
-
-        Ok(seq)
-    }
-}
-
-impl ConfigLoadSave<UserAnimeConfig> for UserAnimeConfig {
-    fn name(&self) -> String {
-        self.name.clone()
-    }
-
-    fn default_with_name(name: String) -> Self {
-        UserAnimeConfig {
-            name,
-            ..Default::default()
-        }
-    }
-}
-
-impl Default for UserAnimeConfig {
-    fn default() -> Self {
-        Self {
-            name: "default".to_owned(),
-            anime: vec![
-                ActionLoader::AsusImage {
-                    file: "/usr/share/asusd/anime/custom/diagonal-template.png".into(),
-                    brightness: 1.0,
-                    time: AnimTime::Fade(Fade::new(
-                        Duration::from_secs(2),
-                        None,
-                        Duration::from_secs(2),
-                    )),
-                },
-                ActionLoader::AsusAnimation {
-                    file: "/usr/share/asusd/anime/asus/rog/Sunset.gif".into(),
-                    brightness: 0.5,
-                    time: AnimTime::Fade(Fade::new(
-                        Duration::from_secs(6),
-                        None,
-                        Duration::from_secs(3),
-                    )),
-                },
-                ActionLoader::ImageAnimation {
-                    file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
-                    scale: 0.9,
-                    angle: 0.65,
-                    translation: Vec2::default(),
-                    brightness: 0.5,
-                    time: AnimTime::Fade(Fade::new(
-                        Duration::from_secs(2),
-                        Some(Duration::from_secs(2)),
-                        Duration::from_secs(2),
-                    )),
-                },
-                ActionLoader::Image {
-                    file: "/usr/share/asusd/anime/custom/rust.png".into(),
-                    scale: 1.0,
-                    angle: 0.0,
-                    translation: Vec2::default(),
-                    time: AnimTime::Fade(Fade::new(
-                        Duration::from_secs(2),
-                        Some(Duration::from_secs(1)),
-                        Duration::from_secs(2),
-                    )),
-                    brightness: 0.6,
-                },
-                ActionLoader::Pause(Duration::from_secs(1)),
-                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: 0.5,
-                    time: AnimTime::Count(2),
-                },
-            ],
-        }
-    }
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-pub struct UserAuraConfig {
-    pub name: String,
-    pub aura: rog_aura::Sequences,
-}
-
-impl ConfigLoadSave<UserAuraConfig> for UserAuraConfig {
-    fn name(&self) -> String {
-        self.name.clone()
-    }
-
-    fn default_with_name(name: String) -> Self {
-        UserAuraConfig {
-            name,
-            ..Default::default()
-        }
-    }
-}
-
-impl Default for UserAuraConfig {
-    fn default() -> Self {
-        let mut seq = rog_aura::Sequences::new();
-        let mut key = Effect::Breathe(Breathe::new(
-            LedType::Key(Key::W),
-            Colour(255, 0, 20),
-            Colour(20, 255, 0),
-            Speed::Low,
-        ));
-
-        seq.push(key.clone());
-        key.set_led_type(LedType::Key(Key::A));
-        seq.push(key.clone());
-        key.set_led_type(LedType::Key(Key::S));
-        seq.push(key.clone());
-        key.set_led_type(LedType::Key(Key::D));
-        seq.push(key);
-
-        let key = Effect::Breathe(Breathe::new(
-            LedType::Key(Key::F),
-            Colour(255, 0, 0),
-            Colour(255, 0, 0),
-            Speed::High,
-        ));
-        seq.push(key);
-
-        let mut key = Effect::Static(Static::new(LedType::Key(Key::RCtrl), Colour(0, 0, 255)));
-        seq.push(key.clone());
-        key.set_led_type(LedType::Key(Key::LCtrl));
-        seq.push(key.clone());
-        key.set_led_type(LedType::Key(Key::Esc));
-        seq.push(key);
-
-        let key = Effect::Flicker(Flicker::new(
-            LedType::Key(Key::N9),
-            Colour(0, 0, 255),
-            80,
-            40,
-        ));
-        seq.push(key);
-
-        Self {
-            name: "default".to_owned(),
-            aura: seq,
-        }
-    }
-}
-
-#[derive(Debug, Default, Deserialize, Serialize)]
-#[serde(default)]
-pub struct UserConfig {
-    /// Name of active anime config file in the user config directory
-    pub active_anime: Option<String>,
-    /// Name of active aura config file in the user config directory
-    pub active_aura: Option<String>,
-}
-
-impl UserConfig {
-    pub fn new() -> Self {
-        Self {
-            active_anime: Some("anime-default".to_owned()),
-            active_aura: Some("aura-default".to_owned()),
-        }
-    }
-
-    pub fn load(&mut self) -> Result<(), Error> {
-        let mut path = if let Some(dir) = dirs::config_dir() {
-            dir
-        } else {
-            return Err(Error::XdgVars);
-        };
-
-        path.push("rog");
-        if !path.exists() {
-            create_dir(path.clone())?;
-        }
-
-        path.push("rog-user.cfg");
-
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(&path)?;
-
-        let mut buf = String::new();
-
-        if let Ok(read_len) = file.read_to_string(&mut buf) {
-            if read_len == 0 {
-                let json = serde_json::to_string_pretty(&self).unwrap();
-                file.write_all(json.as_bytes())?;
-            } else if let Ok(data) = serde_json::from_str::<UserConfig>(&buf) {
-                self.active_anime = data.active_anime;
-                self.active_aura = data.active_aura;
-                return Ok(());
-            }
-        }
-        Ok(())
-    }
-
-    pub fn write(&self) -> Result<(), Error> {
-        let mut path = if let Some(dir) = dirs::config_dir() {
-            dir
-        } else {
-            return Err(Error::XdgVars);
-        };
-
-        path.push("rog");
-        if !path.exists() {
-            create_dir(path.clone())?;
-        }
-
-        path.push("rog-user.cfg");
-
-        let mut file = OpenOptions::new()
-            .write(true)
-            .create(true)
-            .truncate(true)
-            .open(&path)?;
-
-        let json = serde_json::to_string_pretty(&self).unwrap();
-        file.write_all(json.as_bytes())?;
-        Ok(())
-    }
-}

daemon/src/config.rs

@@ -1,107 +0,0 @@
-use log::{error, warn};
-use serde_derive::{Deserialize, Serialize};
-use std::fs::{File, OpenOptions};
-use std::io::{Read, Write};
-use std::path::PathBuf;
-
-pub static CONFIG_PATH: &str = "/etc/asusd/asusd.conf";
-
-#[derive(Deserialize, Serialize, Default)]
-pub struct Config {
-    /// Save charge limit for restoring on boot
-    pub bat_charge_limit: u8,
-    pub panel_od: bool,
-    pub ac_command: String,
-    pub bat_command: String,
-}
-
-impl Config {
-    fn new() -> Self {
-        Config {
-            bat_charge_limit: 100,
-            panel_od: false,
-            ac_command: String::new(),
-            bat_command: String::new(),
-        }
-    }
-
-    /// `load` will attempt to read the config, and panic if the dir is missing
-    pub fn load() -> Self {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(&PathBuf::from(CONFIG_PATH))
-            .unwrap_or_else(|e| panic!("Error opening {}, {}", CONFIG_PATH, e)); // okay to cause panic here
-        let mut buf = String::new();
-        let config;
-        if let Ok(read_len) = file.read_to_string(&mut buf) {
-            if read_len == 0 {
-                config = Self::new();
-            } else if let Ok(data) = serde_json::from_str(&buf) {
-                config = data;
-            } else if let Ok(data) = serde_json::from_str::<Config455>(&buf) {
-                config = data.into();
-            } else {
-                warn!(
-                    "Could not deserialise {}.\nWill rename to {}-old and recreate config",
-                    CONFIG_PATH, CONFIG_PATH
-                );
-                let cfg_old = CONFIG_PATH.to_owned() + "-old";
-                std::fs::rename(CONFIG_PATH, cfg_old).unwrap_or_else(|err| {
-                    panic!(
-                        "Could not rename. Please remove {} then restart service: Error {}",
-                        CONFIG_PATH, err
-                    )
-                });
-                config = Self::new();
-            }
-        } else {
-            config = Self::new();
-        }
-        config.write();
-        config
-    }
-
-    pub fn read(&mut self) {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(CONFIG_PATH)
-            .unwrap_or_else(|err| panic!("Error reading {}: {}", CONFIG_PATH, err));
-        let mut buf = String::new();
-        if let Ok(l) = file.read_to_string(&mut buf) {
-            if l == 0 {
-                warn!("File is empty {}", CONFIG_PATH);
-            } else {
-                *self = serde_json::from_str(&buf)
-                    .unwrap_or_else(|_| panic!("Could not deserialise {}", CONFIG_PATH));
-            }
-        }
-    }
-
-    pub fn write(&self) {
-        let mut file = File::create(CONFIG_PATH).expect("Couldn't overwrite config");
-        let json = serde_json::to_string_pretty(self).expect("Parse config to JSON failed");
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|err| error!("Could not write config: {}", err));
-    }
-}
-
-#[derive(Deserialize, Serialize, Default)]
-#[serde(default)]
-pub struct Config455 {
-    /// Save charge limit for restoring on boot
-    pub bat_charge_limit: u8,
-    pub panel_od: bool,
-}
-
-impl From<Config455> for Config {
-    fn from(c: Config455) -> Self {
-        Self {
-            bat_charge_limit: c.bat_charge_limit,
-            panel_od: c.panel_od,
-            ac_command: String::new(),
-            bat_command: String::new(),
-        }
-    }
-}

daemon/src/ctrl_anime/config.rs

@@ -1,272 +0,0 @@
-use crate::VERSION;
-use log::{error, info, warn};
-use rog_anime::{error::AnimeError, ActionData, ActionLoader, AnimTime, Vec2};
-use rog_anime::{AnimeType, Fade};
-use serde_derive::{Deserialize, Serialize};
-use std::fs::{File, OpenOptions};
-use std::io::{Read, Write};
-use std::time::Duration;
-
-pub static ANIME_CONFIG_PATH: &str = "/etc/asusd/anime.conf";
-pub static ANIME_CACHE_PATH: &str = "/etc/asusd/anime-cache.conf";
-
-#[derive(Deserialize, Serialize)]
-pub struct AnimeConfigV341 {
-    pub system: Option<ActionLoader>,
-    pub boot: Option<ActionLoader>,
-    pub suspend: Option<ActionLoader>,
-    pub shutdown: Option<ActionLoader>,
-}
-
-impl AnimeConfigV341 {
-    pub(crate) fn into_current(self) -> AnimeConfig {
-        AnimeConfig {
-            system: if let Some(ani) = self.system {
-                vec![ani]
-            } else {
-                vec![]
-            },
-            boot: if let Some(ani) = self.boot {
-                vec![ani]
-            } else {
-                vec![]
-            },
-            wake: if let Some(ani) = self.suspend {
-                vec![ani]
-            } else {
-                vec![]
-            },
-            shutdown: if let Some(ani) = self.shutdown {
-                vec![ani]
-            } else {
-                vec![]
-            },
-            brightness: 1.0,
-            awake_enabled: true,
-            boot_anim_enabled: true,
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct AnimeConfigV352 {
-    pub system: Vec<ActionLoader>,
-    pub boot: Vec<ActionLoader>,
-    pub wake: Vec<ActionLoader>,
-    pub shutdown: Vec<ActionLoader>,
-    pub brightness: f32,
-}
-
-impl AnimeConfigV352 {
-    pub(crate) fn into_current(self) -> AnimeConfig {
-        AnimeConfig {
-            system: self.system,
-            boot: self.boot,
-            wake: self.wake,
-            shutdown: self.shutdown,
-            brightness: 1.0,
-            awake_enabled: true,
-            boot_anim_enabled: true,
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize, Default)]
-pub struct AnimeConfigCached {
-    pub system: Vec<ActionData>,
-    pub boot: Vec<ActionData>,
-    pub wake: Vec<ActionData>,
-    pub shutdown: Vec<ActionData>,
-}
-
-impl AnimeConfigCached {
-    pub fn init_from_config(
-        &mut self,
-        config: &AnimeConfig,
-        anime_type: AnimeType,
-    ) -> Result<(), AnimeError> {
-        let mut sys = Vec::with_capacity(config.system.len());
-        for ani in &config.system {
-            sys.push(ActionData::from_anime_action(anime_type, ani)?);
-        }
-        self.system = sys;
-
-        let mut boot = Vec::with_capacity(config.boot.len());
-        for ani in &config.boot {
-            boot.push(ActionData::from_anime_action(anime_type, ani)?);
-        }
-        self.boot = boot;
-
-        let mut wake = Vec::with_capacity(config.wake.len());
-        for ani in &config.wake {
-            wake.push(ActionData::from_anime_action(anime_type, ani)?);
-        }
-        self.wake = wake;
-
-        let mut shutdown = Vec::with_capacity(config.shutdown.len());
-        for ani in &config.shutdown {
-            shutdown.push(ActionData::from_anime_action(anime_type, ani)?);
-        }
-        self.shutdown = shutdown;
-        Ok(())
-    }
-}
-
-/// Config for base system actions for the anime display
-#[derive(Deserialize, Serialize)]
-pub struct AnimeConfig {
-    pub system: Vec<ActionLoader>,
-    pub boot: Vec<ActionLoader>,
-    pub wake: Vec<ActionLoader>,
-    pub shutdown: Vec<ActionLoader>,
-    pub brightness: f32,
-    pub awake_enabled: bool,
-    pub boot_anim_enabled: bool,
-}
-
-impl Default for AnimeConfig {
-    fn default() -> Self {
-        AnimeConfig {
-            system: Vec::new(),
-            boot: Vec::new(),
-            wake: Vec::new(),
-            shutdown: Vec::new(),
-            brightness: 1.0,
-            awake_enabled: true,
-            boot_anim_enabled: true,
-        }
-    }
-}
-
-impl AnimeConfig {
-    /// `load` will attempt to read the config, and panic if the dir is missing
-    pub fn load() -> Self {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(ANIME_CONFIG_PATH)
-            .unwrap_or_else(|_| {
-                panic!(
-                    "The file {} or directory /etc/asusd/ is missing",
-                    ANIME_CONFIG_PATH
-                )
-            }); // okay to cause panic here
-        let mut buf = String::new();
-        if let Ok(read_len) = file.read_to_string(&mut buf) {
-            if read_len == 0 {
-                return AnimeConfig::create_default(&mut file);
-            } else {
-                if let Ok(mut data) = serde_json::from_str(&buf) {
-                    Self::clamp_config_brightness(&mut data);
-                    return data;
-                } else if let Ok(data) = serde_json::from_str::<AnimeConfigV341>(&buf) {
-                    let mut config = data.into_current();
-                    config.write();
-                    info!("Updated config version to: {}", VERSION);
-                    Self::clamp_config_brightness(&mut config);
-                    return config;
-                } else if let Ok(data) = serde_json::from_str::<AnimeConfigV352>(&buf) {
-                    let mut config = data.into_current();
-                    config.write();
-                    info!("Updated config version to: {}", VERSION);
-                    Self::clamp_config_brightness(&mut config);
-                    return config;
-                }
-                warn!(
-                    "Could not deserialise {}.\nWill rename to {}-old and recreate config",
-                    ANIME_CONFIG_PATH, ANIME_CONFIG_PATH
-                );
-                let cfg_old = ANIME_CONFIG_PATH.to_string() + "-old";
-                std::fs::rename(ANIME_CONFIG_PATH, cfg_old).unwrap_or_else(|err| {
-                    panic!(
-                        "Could not rename. Please remove {} then restart service: Error {}",
-                        ANIME_CONFIG_PATH, err
-                    )
-                });
-            }
-        }
-        AnimeConfig::create_default(&mut file)
-    }
-
-    fn clamp_config_brightness(mut config: &mut AnimeConfig) {
-        if config.brightness < 0.0 || config.brightness > 1.0 {
-            warn!(
-                "Clamped brightness to [0.0 ; 1.0], was {}",
-                config.brightness
-            );
-            config.brightness = f32::max(0.0, f32::min(1.0, config.brightness));
-        }
-    }
-
-    fn create_default(file: &mut File) -> Self {
-        // create a default config here
-        let config = AnimeConfig {
-            system: vec![],
-            boot: vec![ActionLoader::ImageAnimation {
-                file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
-                scale: 0.9,
-                angle: 0.65,
-                translation: Vec2::default(),
-                brightness: 1.0,
-                time: AnimTime::Fade(Fade::new(
-                    Duration::from_secs(2),
-                    Some(Duration::from_secs(2)),
-                    Duration::from_secs(2),
-                )),
-            }],
-            wake: vec![ActionLoader::ImageAnimation {
-                file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
-                scale: 0.9,
-                angle: 0.65,
-                translation: Vec2::default(),
-                brightness: 1.0,
-                time: AnimTime::Fade(Fade::new(
-                    Duration::from_secs(2),
-                    Some(Duration::from_secs(2)),
-                    Duration::from_secs(2),
-                )),
-            }],
-            shutdown: 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,
-            }],
-            brightness: 1.0,
-            awake_enabled: true,
-            boot_anim_enabled: true,
-        };
-        // Should be okay to unwrap this as is since it is a Default
-        let json = serde_json::to_string_pretty(&config).unwrap();
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|_| panic!("Could not write {}", ANIME_CONFIG_PATH));
-        config
-    }
-
-    pub fn read(&mut self) {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(ANIME_CONFIG_PATH)
-            .unwrap_or_else(|err| panic!("Error reading {}: {}", ANIME_CONFIG_PATH, err));
-        let mut buf = String::new();
-        if let Ok(l) = file.read_to_string(&mut buf) {
-            if l == 0 {
-                warn!("File is empty {}", ANIME_CONFIG_PATH);
-            } else {
-                let x: AnimeConfig = serde_json::from_str(&buf)
-                    .unwrap_or_else(|_| panic!("Could not deserialise {}", ANIME_CONFIG_PATH));
-                *self = x;
-            }
-        }
-    }
-
-    pub fn write(&self) {
-        let mut file = File::create(ANIME_CONFIG_PATH).expect("Couldn't overwrite config");
-        let json = serde_json::to_string_pretty(self).expect("Parse config to JSON failed");
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|err| error!("Could not write config: {}", err));
-    }
-}

daemon/src/ctrl_anime/trait_impls.rs

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

daemon/src/ctrl_aura/controller.rs

@@ -1,509 +0,0 @@
-use crate::{
-    error::RogError,
-    laptops::{LaptopLedData, ASUS_KEYBOARD_DEVICES},
-};
-use log::{info, warn};
-use rog_aura::{
-    usb::{AuraDevice, LED_APPLY, LED_SET},
-    AuraEffect, KeyColourArray, LedBrightness, PerKeyRaw, LED_MSG_LEN,
-};
-use rog_aura::{AuraZone, Direction, Speed, GRADIENT};
-use rog_platform::{hid_raw::HidRaw, keyboard_led::KeyboardLed, supported::LedSupportedFunctions};
-use std::collections::BTreeMap;
-
-use crate::GetSupported;
-
-use super::config::{AuraConfig, AuraPowerConfig};
-
-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 stock_led_modes = laptop.standard;
-        let multizone_led_mode = laptop.multizone;
-        let per_key_led_mode = laptop.per_key;
-
-        let mut prod_id = AuraDevice::Unknown;
-        for prod in &ASUS_KEYBOARD_DEVICES {
-            if HidRaw::new(prod).is_ok() {
-                prod_id = AuraDevice::from(*prod);
-                break;
-            }
-        }
-
-        let rgb = KeyboardLed::new();
-        if let Ok(p) = rgb.as_ref() {
-            if p.has_kbd_rgb_mode() {
-                prod_id = AuraDevice::Tuf;
-            }
-        }
-
-        LedSupportedFunctions {
-            prod_id,
-            brightness_set: rgb.is_ok(),
-            stock_led_modes,
-            multizone_led_mode,
-            per_key_led_mode,
-        }
-    }
-}
-
-#[derive(Debug, PartialEq, Eq, PartialOrd)]
-pub enum LEDNode {
-    KbdLed(KeyboardLed),
-    Rog(HidRaw),
-    None,
-}
-
-pub struct CtrlKbdLed {
-    // TODO: config stores the keyboard type as an AuraPower, use or update this
-    pub led_prod: Option<String>,
-    pub led_node: LEDNode,
-    pub kd_brightness: KeyboardLed,
-    pub supported_modes: LaptopLedData,
-    pub flip_effect_write: bool,
-    pub per_key_mode_active: bool,
-    pub config: AuraConfig,
-}
-
-impl CtrlKbdLed {
-    pub fn new(supported_modes: LaptopLedData, config: AuraConfig) -> Result<Self, RogError> {
-        let mut led_prod = None;
-        let mut led_node = None;
-        for prod in &ASUS_KEYBOARD_DEVICES {
-            match HidRaw::new(prod) {
-                Ok(node) => {
-                    led_prod = Some((*prod).to_owned());
-                    led_node = Some(node);
-                    info!("Looked for keyboard controller 0x{prod}: Found");
-                    break;
-                }
-                Err(err) => info!("Looked for keyboard controller 0x{prod}: {err}"),
-            }
-        }
-
-        let rgb_led = KeyboardLed::new()?;
-
-        if led_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!("A kernel patch is in progress for TUF RGB support");
-                }
-            }
-            return Err(RogError::NoAuraKeyboard);
-        }
-
-        let led_node = if let Some(rog) = led_node {
-            info!("Found ROG USB keyboard");
-            LEDNode::Rog(rog)
-        } else if rgb_led.has_kbd_rgb_mode() {
-            info!("Found TUF keyboard");
-            LEDNode::KbdLed(rgb_led.clone())
-        } else {
-            LEDNode::None
-        };
-
-        let ctrl = CtrlKbdLed {
-            led_prod,
-            led_node,
-            kd_brightness: rgb_led, // If was none then we already returned above
-            supported_modes,
-            flip_effect_write: false,
-            per_key_mode_active: false,
-            config,
-        };
-        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> {
-        if let LEDNode::KbdLed(platform) = &mut self.led_node {
-            if let Some(pwr) = AuraPowerConfig::to_tuf_bool_array(&self.config.enabled) {
-                let buf = [1, pwr[1] as u8, pwr[2] as u8, pwr[3] as u8, pwr[4] as u8];
-                platform.set_kbd_rgb_state(&buf)?;
-            }
-        } else if let LEDNode::Rog(hid_raw) = &self.led_node {
-            let bytes = AuraPowerConfig::to_bytes(&self.config.enabled);
-            let message = [0x5d, 0xbd, 0x01, bytes[0], bytes[1], bytes[2]];
-
-            hid_raw.write_bytes(&message)?;
-            hid_raw.write_bytes(&LED_SET)?;
-            // Changes won't persist unless apply is set
-            hid_raw.write_bytes(&LED_APPLY)?;
-        }
-        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.standard.contains(&effect.mode)
-            || effect.zone != AuraZone::None
-                && !self.supported_modes.multizone.contains(&effect.zone)
-        {
-            return Err(RogError::AuraEffectNotSupported);
-        }
-
-        self.write_mode(&effect)?;
-        self.config.read(); // refresh config if successful
-        self.config.set_builtin(effect);
-        self.config.write();
-        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.
-    pub fn write_effect_block(&mut self, effect: &PerKeyRaw) -> Result<(), RogError> {
-        let pkt_type = effect[0][1];
-        const PER_KEY_TYPE: u8 = 0xbc;
-
-        if pkt_type != PER_KEY_TYPE {
-            self.per_key_mode_active = false;
-            if let LEDNode::Rog(hid_raw) = &self.led_node {
-                hid_raw.write_bytes(&effect[0])?;
-                hid_raw.write_bytes(&LED_SET)?;
-                // hid_raw.write_bytes(&LED_APPLY)?;
-            }
-        } else {
-            if !self.per_key_mode_active {
-                if let LEDNode::Rog(hid_raw) = &self.led_node {
-                    let init = KeyColourArray::get_init_msg();
-                    hid_raw.write_bytes(&init)?;
-                }
-                self.per_key_mode_active = true;
-            }
-            if let LEDNode::Rog(hid_raw) = &self.led_node {
-                for row in effect.iter() {
-                    hid_raw.write_bytes(row)?;
-                }
-            } else if let LEDNode::KbdLed(tuf) = &self.led_node {
-                for row in effect.iter() {
-                    let r = row[9];
-                    let g = row[10];
-                    let b = row[11];
-                    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
-            .standard
-            .iter()
-            .position(|v| *v == current)
-        {
-            let mut idx = idx;
-            // goes past end of array
-            if reverse {
-                if idx == 0 {
-                    idx = self.supported_modes.standard.len() - 1;
-                } else {
-                    idx -= 1;
-                }
-            } else {
-                idx += 1;
-                if idx == self.supported_modes.standard.len() {
-                    idx = 0;
-                }
-            }
-            let next = self.supported_modes.standard[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> {
-        if let LEDNode::KbdLed(platform) = &self.led_node {
-            let buf = [
-                1,
-                mode.mode as u8,
-                mode.colour1.0,
-                mode.colour1.1,
-                mode.colour1.2,
-                mode.speed as u8,
-            ];
-            platform.set_kbd_rgb_mode(&buf)?;
-        } else if let LEDNode::Rog(hid_raw) = &self.led_node {
-            let bytes: [u8; LED_MSG_LEN] = mode.into();
-            hid_raw.write_bytes(&bytes)?;
-            hid_raw.write_bytes(&LED_SET)?;
-            // Changes won't persist unless apply is set
-            hid_raw.write_bytes(&LED_APPLY)?;
-        } else {
-            return Err(RogError::NoAuraKeyboard);
-        }
-        self.per_key_mode_active = false;
-        Ok(())
-    }
-
-    pub(super) fn write_current_config_mode(&mut self) -> Result<(), RogError> {
-        if self.config.multizone_on {
-            let mode = self.config.current_mode;
-            let mut create = false;
-            // There is no multizone config for this mode so create one here
-            // using the colours of rainbow if it exists, or first available
-            // mode, or random
-            if self.config.multizone.is_none() {
-                create = true;
-            } else if let Some(multizones) = self.config.multizone.as_ref() {
-                if !multizones.contains_key(&mode) {
-                    create = true;
-                }
-            }
-            if create {
-                info!("No user-set config for zone founding, attempting a default");
-                self.create_multizone_default()?;
-            }
-
-            if let Some(multizones) = self.config.multizone.as_mut() {
-                if let Some(set) = multizones.get(&mode) {
-                    for mode in set.clone() {
-                        self.write_mode(&mode)?;
-                    }
-                }
-            }
-        } else {
-            let mode = self.config.current_mode;
-            if let Some(effect) = self.config.builtins.get(&mode).cloned() {
-                self.write_mode(&effect)?;
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Create a default for the `current_mode` if multizone and no config exists.
-    fn create_multizone_default(&mut self) -> Result<(), RogError> {
-        let mut default = vec![];
-        for (i, tmp) in self.supported_modes.multizone.iter().enumerate() {
-            default.push(AuraEffect {
-                mode: self.config.current_mode,
-                zone: *tmp,
-                colour1: *GRADIENT.get(i).unwrap_or(&GRADIENT[0]),
-                colour2: *GRADIENT.get(GRADIENT.len() - i).unwrap_or(&GRADIENT[6]),
-                speed: Speed::Med,
-                direction: Direction::Left,
-            });
-        }
-        if default.is_empty() {
-            return Err(RogError::AuraEffectNotSupported);
-        }
-
-        if let Some(multizones) = self.config.multizone.as_mut() {
-            multizones.insert(self.config.current_mode, default);
-        } else {
-            let mut tmp = BTreeMap::new();
-            tmp.insert(self.config.current_mode, default);
-            self.config.multizone = Some(tmp);
-        }
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour};
-    use rog_platform::keyboard_led::KeyboardLed;
-
-    use crate::{
-        ctrl_aura::{config::AuraConfig, controller::LEDNode},
-        laptops::LaptopLedData,
-    };
-
-    use super::CtrlKbdLed;
-
-    #[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::default();
-        let supported_modes = LaptopLedData {
-            prod_family: String::new(),
-            board_names: vec![],
-            standard: vec![AuraModeNum::Static],
-            multizone: vec![],
-            per_key: false,
-        };
-        let mut controller = CtrlKbdLed {
-            led_prod: None,
-            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(0xff, 0x00, 0xff),
-            zone: AuraZone::None,
-            ..Default::default()
-        };
-
-        // This error comes from write_bytes because we don't have a keyboard node stored
-        assert_eq!(
-            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.multizone.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::default();
-        let supported_modes = LaptopLedData {
-            prod_family: String::new(),
-            board_names: vec![],
-            standard: vec![AuraModeNum::Static],
-            multizone: vec![],
-            per_key: false,
-        };
-        let mut controller = CtrlKbdLed {
-            led_prod: None,
-            led_node: LEDNode::None,
-            kd_brightness: KeyboardLed::default(),
-            supported_modes,
-            flip_effect_write: false,
-            per_key_mode_active: false,
-            config,
-        };
-
-        assert!(controller.config.multizone.is_none());
-        assert!(controller.create_multizone_default().is_err());
-        assert!(controller.config.multizone.is_none());
-
-        controller.supported_modes.multizone.push(AuraZone::Key1);
-        controller.supported_modes.multizone.push(AuraZone::Key2);
-        assert!(controller.create_multizone_default().is_ok());
-        assert!(controller.config.multizone.is_some());
-
-        let m = controller.config.multizone.unwrap();
-        assert!(m.contains_key(&AuraModeNum::Static));
-        let e = m.get(&AuraModeNum::Static).unwrap();
-        assert_eq!(e.len(), 2);
-        assert_eq!(e[0].zone, AuraZone::Key1);
-        assert_eq!(e[1].zone, AuraZone::Key2);
-    }
-
-    #[test]
-    fn next_mode_create_multizone_if_no_config() {
-        // Checking to ensure set_mode errors when unsupported modes are tried
-        let config = AuraConfig::default();
-        let supported_modes = LaptopLedData {
-            prod_family: String::new(),
-            board_names: vec![],
-            standard: vec![AuraModeNum::Static],
-            multizone: vec![AuraZone::Key1, AuraZone::Key2],
-            per_key: false,
-        };
-        let mut controller = CtrlKbdLed {
-            led_prod: None,
-            led_node: LEDNode::None,
-            kd_brightness: KeyboardLed::default(),
-            supported_modes,
-            flip_effect_write: false,
-            per_key_mode_active: false,
-            config,
-        };
-
-        assert!(controller.config.multizone.is_none());
-        controller.config.multizone_on = true;
-        // This is called in toggle_mode. It will error here because we have no
-        // keyboard node in tests.
-        assert_eq!(
-            controller
-                .write_current_config_mode()
-                .unwrap_err()
-                .to_string(),
-            "No supported Aura keyboard"
-        );
-        assert!(controller.config.multizone.is_some());
-
-        let m = controller.config.multizone.unwrap();
-        assert!(m.contains_key(&AuraModeNum::Static));
-        let e = m.get(&AuraModeNum::Static).unwrap();
-        assert_eq!(e.len(), 2);
-        assert_eq!(e[0].zone, AuraZone::Key1);
-        assert_eq!(e[1].zone, AuraZone::Key2);
-    }
-}

daemon/src/ctrl_aura/trait_impls.rs

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

daemon/src/ctrl_platform.rs

@@ -1,382 +0,0 @@
-use crate::{config::Config, error::RogError, GetSupported};
-use crate::{task_watch_item, CtrlTask};
-use async_trait::async_trait;
-use log::{info, warn};
-use rog_platform::platform::{AsusPlatform, GpuMode};
-use rog_platform::supported::RogBiosSupportedFunctions;
-use std::fs::OpenOptions;
-use std::io::{Read, Write};
-use std::path::Path;
-use std::process::Command;
-use std::sync::Arc;
-use zbus::export::futures_util::lock::Mutex;
-use zbus::Connection;
-use zbus::{dbus_interface, SignalContext};
-
-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>>,
-}
-
-impl GetSupported for CtrlPlatform {
-    type A = RogBiosSupportedFunctions;
-
-    fn get_supported() -> Self::A {
-        let mut panel_overdrive = false;
-        let mut dgpu_disable = false;
-        let mut egpu_enable = false;
-        let mut gpu_mux = false;
-
-        if let Ok(platform) = AsusPlatform::new() {
-            panel_overdrive = platform.has_panel_od();
-            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,
-            dgpu_disable,
-            egpu_enable,
-        }
-    }
-}
-
-impl CtrlPlatform {
-    pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
-        let platform = AsusPlatform::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(())
-    }
-
-    fn set_gfx_mode(&self, mode: GpuMode) -> Result<(), RogError> {
-        self.platform.set_gpu_mux_mode(mode.to_mux_attr())?;
-        // self.update_initramfs(enable)?;
-        if mode == GpuMode::Discrete {
-            info!("Set system-level graphics mode: Dedicated Nvidia");
-        } else {
-            info!("Set system-level graphics mode: Optimus");
-        }
-        Ok(())
-    }
-
-    pub fn get_boot_sound() -> Result<i8, RogError> {
-        let path = ASUS_POST_LOGO_SOUND;
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(path)
-            .map_err(|err| RogError::Path(path.into(), err))?;
-
-        let mut data = Vec::new();
-        file.read_to_end(&mut data)
-            .map_err(|err| RogError::Read(path.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();
-        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");
-        } else {
-            data[idx] = 0;
-            info!("Set boot POST sound off");
-        }
-        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(())
-    }
-}
-
-#[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();
-    }
-
-    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
-            }
-        }
-    }
-
-    #[dbus_interface(signal)]
-    async fn notify_gpu_mux_mode(
-        signal_ctxt: &SignalContext<'_>,
-        mode: GpuMode,
-    ) -> zbus::Result<()> {
-    }
-
-    async fn set_post_boot_sound(
-        &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.ok();
-    }
-
-    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(signal)]
-    async fn notify_post_boot_sound(ctxt: &SignalContext<'_>, on: bool) -> zbus::Result<()> {}
-
-    async fn set_panel_od(
-        &mut self,
-        #[zbus(signal_context)] ctxt: SignalContext<'_>,
-        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();
-                }
-                Self::notify_panel_od(&ctxt, overdrive).await.ok();
-            }
-            Err(err) => warn!("CtrlRogBios: set_panel_overdrive {}", err),
-        };
-    }
-
-    /// Get the `panel_od` value from platform. Updates the stored value in internal config also.
-    fn panel_od(&self) -> bool {
-        let od = self
-            .platform
-            .get_panel_od()
-            .map_err(|err| {
-                warn!("CtrlRogBios: get_panel_od {}", err);
-                err
-            })
-            .unwrap_or(false);
-        if let Some(mut lock) = self.config.try_lock() {
-            lock.panel_od = od;
-            lock.write();
-        }
-        od
-    }
-
-    #[dbus_interface(signal)]
-    async fn notify_panel_od(signal_ctxt: &SignalContext<'_>, overdrive: bool) -> zbus::Result<()> {
-    }
-
-    async fn set_dgpu_disable(
-        &mut self,
-        #[zbus(signal_context)] ctxt: SignalContext<'_>,
-        disable: bool,
-    ) {
-        match self.platform.set_dgpu_disable(disable) {
-            Ok(_) => {
-                Self::notify_dgpu_disable(&ctxt, disable).await.ok();
-            }
-            Err(err) => warn!("CtrlRogBios: set_dgpu_disable {}", err),
-        };
-    }
-
-    fn dgpu_disable(&self) -> bool {
-        self.platform
-            .get_dgpu_disable()
-            .map_err(|err| {
-                warn!("CtrlRogBios: get_dgpu_disable {}", err);
-                err
-            })
-            .unwrap_or(false)
-    }
-
-    #[dbus_interface(signal)]
-    async fn notify_dgpu_disable(
-        signal_ctxt: &SignalContext<'_>,
-        disable: bool,
-    ) -> zbus::Result<()> {
-    }
-
-    async fn set_egpu_enable(
-        &mut self,
-        #[zbus(signal_context)] ctxt: SignalContext<'_>,
-        enable: bool,
-    ) {
-        match self.platform.set_egpu_enable(enable) {
-            Ok(_) => {
-                Self::notify_egpu_enable(&ctxt, enable).await.ok();
-            }
-            Err(err) => warn!("CtrlRogBios: set_egpu_enable {}", err),
-        };
-    }
-
-    fn egpu_enable(&self) -> bool {
-        self.platform
-            .get_egpu_enable()
-            .map_err(|err| {
-                warn!("CtrlRogBios: get_egpu_enable {}", err);
-                err
-            })
-            .unwrap_or(false)
-    }
-
-    #[dbus_interface(signal)]
-    async fn notify_egpu_enable(signal_ctxt: &SignalContext<'_>, enable: bool) -> zbus::Result<()> {
-    }
-}
-
-#[async_trait]
-impl crate::ZbusRun for CtrlPlatform {
-    async fn add_to_server(self, server: &mut Connection) {
-        Self::add_to_server_helper(self, "/org/asuslinux/Platform", server).await;
-    }
-}
-
-#[async_trait]
-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)?;
-        }
-        Ok(())
-    }
-}
-
-impl CtrlPlatform {
-    task_watch_item!(panel_od platform);
-    task_watch_item!(dgpu_disable platform);
-    task_watch_item!(egpu_enable platform);
-    // NOTE: see note further below
-    //task_watch_item!(gpu_mux_mode platform);
-}
-
-#[async_trait]
-impl CtrlTask for CtrlPlatform {
-    fn zbus_path() -> &'static str {
-        ZBUS_PATH
-    }
-
-    async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
-        let platform1 = self.clone();
-        let platform2 = self.clone();
-        self.create_sys_event_tasks(
-            move || async { {} },
-            move || {
-                let platform1 = platform1.clone();
-                async move {
-                    info!("CtrlRogBios reloading panel_od");
-                    let lock = platform1.config.lock().await;
-                    if platform1.platform.has_panel_od() {
-                        platform1
-                            .set_panel_overdrive(lock.panel_od)
-                            .map_err(|err| {
-                                warn!("CtrlCharge: set_limit {}", err);
-                                err
-                            })
-                            .ok();
-                    }
-                }
-            },
-            move || async { {} },
-            move || {
-                let platform2 = platform2.clone();
-                async move {
-                    info!("CtrlRogBios reloading panel_od");
-                    let lock = platform2.config.lock().await;
-                    if platform2.platform.has_panel_od() {
-                        platform2
-                            .set_panel_overdrive(lock.panel_od)
-                            .map_err(|err| {
-                                warn!("CtrlCharge: set_limit {}", err);
-                                err
-                            })
-                            .ok();
-                    }
-                }
-            },
-        )
-        .await;
-
-        self.watch_panel_od(signal_ctxt.clone()).await?;
-        self.watch_dgpu_disable(signal_ctxt.clone()).await?;
-        self.watch_egpu_enable(signal_ctxt.clone()).await?;
-        // NOTE: Can't have this as a watch because on a write to it, it reverts back to booted-with value
-        //  as it does not actually change until reboot.
-        //self.watch_gpu_mux_mode(signal_ctxt.clone()).await?;
-
-        Ok(())
-    }
-}

daemon/src/ctrl_power.rs

@@ -1,278 +0,0 @@
-use crate::{config::Config, error::RogError, GetSupported};
-use crate::{task_watch_item, CtrlTask};
-use async_trait::async_trait;
-use log::{error, info, warn};
-use rog_platform::power::AsusPower;
-use rog_platform::supported::ChargeSupportedFunctions;
-use std::process::Command;
-use std::sync::Arc;
-use std::time::Duration;
-use systemd_zbus::{ManagerProxy as SystemdProxy, Mode, UnitFileState};
-use tokio::time::sleep;
-use zbus::dbus_interface;
-use zbus::export::futures_util::lock::Mutex;
-use zbus::Connection;
-use zbus::SignalContext;
-
-const ZBUS_PATH: &str = "/org/asuslinux/Power";
-const NVIDIA_POWERD: &str = "nvidia-powerd.service";
-
-impl GetSupported for CtrlPower {
-    type A = ChargeSupportedFunctions;
-
-    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 {
-    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(())
-    }
-
-    task_watch_item!(charge_control_end_threshold power);
-}
-
-#[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 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 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;
-                        do_nvidia_powerd_action(&sysd3, value == 1).await;
-
-                        Self::notify_mains_online(&signal_ctxt, value == 1)
-                            .await
-                            .unwrap();
-
-                        let mut config = config.lock().await;
-                        config.read();
-                        let mut prog: Vec<&str> = Vec::new();
-                        if value == 1 {
-                            // AC ONLINE
-                            prog = config.ac_command.split_whitespace().collect();
-                        } else if value == 0 {
-                            // BATTERY
-                            prog = config.bat_command.split_whitespace().collect();
-                        }
-
-                        if prog.len() > 1 {
-                            let mut cmd = Command::new(prog[0]);
-                            for arg in prog.iter().skip(1) {
-                                cmd.arg(*arg);
-                            }
-                            if let Err(e) = cmd.spawn() {
-                                if value == 1 {
-                                    error!("AC power command error: {e}");
-                                } else {
-                                    error!("Battery power command error: {e}");
-                                }
-                            }
-                        }
-                    }
-                }
-                // The inotify doesn't pick up events when the kernel changes internal value
-                // 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();
-            }
-        }
-    }
-}

daemon/src/ctrl_profiles/config.rs

@@ -1,88 +0,0 @@
-use log::{error, warn};
-use rog_profiles::{FanCurveProfiles, Profile};
-use serde_derive::{Deserialize, Serialize};
-use std::fs::{File, OpenOptions};
-use std::io::{Read, Write};
-
-#[derive(Deserialize, Serialize, Debug)]
-pub struct ProfileConfig {
-    #[serde(skip)]
-    config_path: String,
-    /// For restore on boot
-    pub active_profile: Profile,
-    /// States to restore
-    pub fan_curves: Option<FanCurveProfiles>,
-}
-
-impl ProfileConfig {
-    fn new(config_path: String) -> Self {
-        Self {
-            config_path,
-            active_profile: Profile::Balanced,
-            fan_curves: None,
-        }
-    }
-
-    pub fn load(config_path: String) -> Self {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(&config_path)
-            .unwrap_or_else(|_| panic!("The directory /etc/asusd/ is missing")); // okay to cause panic here
-        let mut buf = String::new();
-        let mut config;
-        if let Ok(read_len) = file.read_to_string(&mut buf) {
-            if read_len == 0 {
-                config = Self::new(config_path);
-            } else if let Ok(data) = toml::from_str(&buf) {
-                config = data;
-                config.config_path = config_path;
-            } else {
-                warn!(
-                    "Could not deserialise {}.\nWill rename to {}-old and recreate config",
-                    config_path, config_path
-                );
-                let mut cfg_old = config_path.clone();
-                cfg_old.push_str("-old");
-                std::fs::rename(config_path.clone(), cfg_old).unwrap_or_else(|err| {
-                    panic!(
-                        "Could not rename. Please remove {} then restart service: Error {}",
-                        config_path, err
-                    )
-                });
-                config = Self::new(config_path);
-            }
-        } else {
-            config = Self::new(config_path);
-        }
-        config
-    }
-
-    pub fn read(&mut self) {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(&self.config_path)
-            .unwrap_or_else(|err| panic!("Error reading {}: {}", self.config_path, err));
-
-        let mut buf = String::new();
-        if let Ok(l) = file.read_to_string(&mut buf) {
-            if l == 0 {
-                warn!("File is empty {}", self.config_path);
-            } else {
-                let mut data: ProfileConfig = toml::from_str(&buf)
-                    .unwrap_or_else(|_| panic!("Could not deserialise {}", self.config_path));
-                // copy over serde skipped values
-                data.config_path = self.config_path.clone();
-                *self = data;
-            }
-        }
-    }
-
-    pub fn write(&self) {
-        let mut file = File::create(&self.config_path).expect("Couldn't overwrite config");
-        let data = toml::to_string(self).expect("Parse config to toml failed");
-        file.write_all(data.as_bytes())
-            .unwrap_or_else(|err| error!("Could not write config: {}", err));
-    }
-}

daemon/src/ctrl_profiles/controller.rs

@@ -1,116 +0,0 @@
-use crate::error::RogError;
-use crate::GetSupported;
-use log::{info, warn};
-use rog_platform::platform::AsusPlatform;
-use rog_platform::supported::PlatformProfileFunctions;
-use rog_profiles::error::ProfileError;
-use rog_profiles::{FanCurveProfiles, Profile};
-
-use super::config::ProfileConfig;
-
-pub struct CtrlPlatformProfile {
-    pub config: ProfileConfig,
-    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::is_supported();
-        let mut fan_curve_supported = res.is_err();
-        if let Ok(r) = res {
-            fan_curve_supported = r;
-        };
-
-        if !fan_curve_supported {
-            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(),
-            fan_curves: fan_curve_supported,
-        }
-    }
-}
-
-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!("Device has profile control available");
-
-            let mut controller = CtrlPlatformProfile { config, platform };
-            if FanCurveProfiles::get_device().is_ok() {
-                info!("Device has fan curves available");
-                if controller.config.fan_curves.is_none() {
-                    controller.config.fan_curves = Some(Default::default());
-                    for _ in [Profile::Balanced, Profile::Performance, Profile::Quiet] {
-                        controller.set_next_profile()?;
-                        controller.set_active_curve_to_defaults()?;
-
-                        let active = Profile::get_active_profile().unwrap_or(Profile::Balanced);
-                        if let Some(curves) = controller.config.fan_curves.as_ref() {
-                            info!(
-                                "{active:?}: {}",
-                                String::from(curves.get_fan_curves_for(active))
-                            );
-                        }
-                    }
-                }
-            }
-
-            return Ok(controller);
-        }
-
-        Err(ProfileError::NotSupported.into())
-    }
-
-    pub fn save_config(&self) {
-        self.config.write();
-    }
-
-    /// Toggle to next profile in list. This will first read the config, switch, then write out
-    pub(super) fn set_next_profile(&mut self) -> Result<(), RogError> {
-        // Read first just incase the user has modified the config before calling this
-        match self.config.active_profile {
-            Profile::Balanced => {
-                Profile::set_profile(Profile::Performance)?;
-                self.config.active_profile = Profile::Performance;
-            }
-            Profile::Performance => {
-                Profile::set_profile(Profile::Quiet)?;
-                self.config.active_profile = Profile::Quiet;
-            }
-            Profile::Quiet => {
-                Profile::set_profile(Profile::Balanced)?;
-                self.config.active_profile = Profile::Balanced;
-            }
-        }
-        self.write_profile_curve_to_platform()?;
-        Ok(())
-    }
-
-    /// 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.config.fan_curves {
-            if let Ok(mut device) = FanCurveProfiles::get_device() {
-                curves.write_profile_curve_to_platform(self.config.active_profile, &mut device)?;
-            }
-        }
-        Ok(())
-    }
-
-    pub(super) fn set_active_curve_to_defaults(&mut self) -> Result<(), RogError> {
-        if let Some(curves) = self.config.fan_curves.as_mut() {
-            if let Ok(mut device) = FanCurveProfiles::get_device() {
-                curves.set_active_curve_to_defaults(self.config.active_profile, &mut device)?;
-            }
-        }
-        Ok(())
-    }
-}

daemon/src/ctrl_profiles/mod.rs

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

daemon/src/ctrl_profiles/trait_impls.rs

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

daemon/src/ctrl_supported.rs

@@ -1,47 +0,0 @@
-use async_trait::async_trait;
-use serde_derive::{Deserialize, Serialize};
-use zbus::{dbus_interface, zvariant::Type, Connection};
-
-use crate::{
-    ctrl_anime::CtrlAnime, ctrl_aura::controller::CtrlKbdLed, ctrl_platform::CtrlPlatform,
-    ctrl_power::CtrlPower, ctrl_profiles::controller::CtrlPlatformProfile, GetSupported,
-};
-
-use rog_platform::supported::*;
-
-#[derive(Serialize, Deserialize, Type)]
-pub struct SupportedFunctions {
-    pub anime_ctrl: AnimeSupportedFunctions,
-    pub charge_ctrl: ChargeSupportedFunctions,
-    pub platform_profile: PlatformProfileFunctions,
-    pub keyboard_led: LedSupportedFunctions,
-    pub rog_bios_ctrl: RogBiosSupportedFunctions,
-}
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl SupportedFunctions {
-    fn supported_functions(&self) -> &SupportedFunctions {
-        self
-    }
-}
-
-#[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 {
-        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(),
-        }
-    }
-}

daemon/src/laptops.rs

@@ -1,167 +0,0 @@
-use log::{info, warn};
-use rog_aura::{AuraModeNum, AuraZone};
-use serde_derive::{Deserialize, Serialize};
-use std::fs::OpenOptions;
-use std::io::Read;
-
-pub const ASUS_LED_MODE_CONF: &str = "/etc/asusd/asusd-ledmodes.toml";
-pub const ASUS_LED_MODE_USER_CONF: &str = "/etc/asusd/asusd-user-ledmodes.toml";
-pub const ASUS_KEYBOARD_DEVICES: [&str; 4] = ["1866", "1869", "1854", "19b6"];
-
-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());
-}
-
-pub fn print_modes(supported_modes: &[u8]) {
-    if !supported_modes.is_empty() {
-        info!("Supported Keyboard LED modes are:");
-        for mode in supported_modes {
-            let mode = <&str>::from(&<AuraModeNum>::from(*mode));
-            info!("- {}", mode);
-        }
-        info!(
-            "If these modes are incorrect you can edit {}",
-            ASUS_LED_MODE_CONF
-        );
-    } else {
-        info!("No RGB control available");
-    }
-}
-
-#[derive(Debug, Default, Deserialize, Serialize)]
-struct LedSupportFile {
-    led_data: Vec<LaptopLedData>,
-}
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-#[serde(default)]
-pub struct LaptopLedData {
-    pub prod_family: String,
-    pub board_names: Vec<String>,
-    pub standard: Vec<AuraModeNum>,
-    pub multizone: Vec<AuraZone>,
-    pub per_key: bool,
-}
-
-impl LaptopLedData {
-    pub fn get_data() -> Self {
-        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");
-
-        if let Some(modes) = LedSupportFile::load_from_config() {
-            if let Some(data) = modes.matcher(&prod_family, &board_name) {
-                return data;
-            }
-        }
-        info!("Using generic LED control for keyboard brightness only");
-        LaptopLedData {
-            prod_family,
-            board_names: vec![board_name],
-            standard: vec![],
-            multizone: vec![],
-            per_key: false,
-        }
-    }
-}
-
-impl LedSupportFile {
-    /// Consumes the `LEDModes`
-    fn matcher(self, prod_family: &str, board_name: &str) -> Option<LaptopLedData> {
-        for config in self.led_data {
-            if prod_family.contains(&config.prod_family) {
-                for board in &config.board_names {
-                    if board_name.contains(board) {
-                        info!("Matched to {} {}", config.prod_family, board);
-                        return Some(config);
-                    }
-                }
-            }
-        }
-        None
-    }
-
-    fn load_from_config() -> Option<Self> {
-        let mut loaded = false;
-        let mut data = LedSupportFile::default();
-        // Load user configs first so they are first to be checked
-        if let Ok(mut file) = OpenOptions::new().read(true).open(ASUS_LED_MODE_USER_CONF) {
-            let mut buf = String::new();
-            if let Ok(l) = file.read_to_string(&mut buf) {
-                if l == 0 {
-                    warn!("{} is empty", ASUS_LED_MODE_USER_CONF);
-                } else {
-                    if let Ok(mut tmp) = toml::from_str::<LedSupportFile>(&buf) {
-                        data.led_data.append(&mut tmp.led_data);
-                    }
-                    info!(
-                        "Loaded user-defined LED support data from {}",
-                        ASUS_LED_MODE_USER_CONF
-                    );
-                }
-            }
-        }
-        // Load and append the default LED support data
-        if let Ok(mut file) = OpenOptions::new().read(true).open(ASUS_LED_MODE_CONF) {
-            let mut buf = String::new();
-            if let Ok(l) = file.read_to_string(&mut buf) {
-                if l == 0 {
-                    warn!("{} is empty", ASUS_LED_MODE_CONF);
-                } else {
-                    let mut tmp: LedSupportFile = toml::from_str(&buf)
-                        .unwrap_or_else(|_| panic!("Could not deserialise {}", ASUS_LED_MODE_CONF));
-                    data.led_data.append(&mut tmp.led_data);
-                    loaded = true;
-                    info!(
-                        "Loaded default LED support data from {}",
-                        ASUS_LED_MODE_CONF
-                    );
-                }
-            }
-        }
-
-        if loaded {
-            return Some(data);
-        }
-
-        warn!("Does {} exist?", ASUS_LED_MODE_USER_CONF);
-        None
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::{fs::OpenOptions, io::Read, path::PathBuf};
-
-    use super::LaptopLedData;
-    use rog_aura::{AuraModeNum, AuraZone};
-
-    #[test]
-    fn check_data_parse() {
-        let led = LaptopLedData {
-            prod_family: "Test".to_owned(),
-            board_names: vec!["Test".to_owned()],
-            standard: vec![AuraModeNum::Static],
-            multizone: vec![AuraZone::Key1, AuraZone::Logo, AuraZone::BarLeft],
-            per_key: false,
-        };
-
-        let toml = toml::to_string_pretty(&led).unwrap();
-        println!("{toml}");
-
-        let mut data = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-        data.push("../data/asusd-ledmodes.toml");
-
-        let mut file = OpenOptions::new().read(true).open(&data).unwrap();
-        let mut buf = String::new();
-        file.read_to_string(&mut buf).unwrap();
-
-        let x = toml::to_string_pretty(&buf).unwrap();
-        println!("{x}");
-    }
-}

daemon/src/lib.rs

@@ -1,212 +0,0 @@
-#![deny(unused_must_use)]
-/// Configuration loading, saving
-pub mod config;
-/// Control of anime matrix display
-pub mod ctrl_anime;
-/// Keyboard LED brightness control, RGB, and LED display modes
-pub mod ctrl_aura;
-/// 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;
-/// Laptop matching to determine capabilities
-pub mod laptops;
-
-/// Fetch all supported functions for the laptop
-pub mod ctrl_supported;
-
-pub mod error;
-
-use std::future::Future;
-
-use crate::error::RogError;
-use async_trait::async_trait;
-use log::{debug, warn};
-use logind_zbus::manager::ManagerProxy;
-use zbus::{export::futures_util::StreamExt, zvariant::ObjectPath, Connection, SignalContext};
-
-/// This macro adds a function which spawns an `inotify` task on the passed in `Executor`.
-///
-/// The generated function is `watch_<name>()`. Self requires the following methods to be available:
-/// - `<name>() -> SomeValue`, functionally is a getter, but is allowed to have side effects.
-/// - `notify_<name>(SignalContext, SomeValue)`
-///
-/// In most cases if `SomeValue` is stored in a config then `<name>()` getter is expected to update it.
-/// The getter should *never* write back to the path or attribute that is being watched or an
-/// infinite loop will occur.
-///
-/// # Example
-///
-/// ```ignore
-/// impl CtrlRogBios {
-///     task_watch_item!(panel_od platform);
-///     task_watch_item!(gpu_mux_mode platform);
-/// }
-/// ```
-#[macro_export]
-macro_rules! task_watch_item {
-    ($name:ident $self_inner:ident) => {
-        concat_idents::concat_idents!(fn_name = watch_, $name {
-        async fn fn_name(
-            &self,
-            signal_ctxt: SignalContext<'static>,
-        ) -> Result<(), RogError> {
-            use zbus::export::futures_util::StreamExt;
-
-            let ctrl = self.clone();
-            concat_idents::concat_idents!(watch_fn = monitor_, $name {
-                match self.$self_inner.watch_fn() {
-                    Ok(mut watch) => {
-                        tokio::spawn(async move {
-                            let mut buffer = [0; 32];
-                            watch.event_stream(&mut buffer).unwrap().for_each(|_| async {
-                                let value = ctrl.$name();
-                                concat_idents::concat_idents!(notif_fn = notify_, $name {
-                                    Self::notif_fn(&signal_ctxt, value).await.ok();
-                                });
-                            }).await;
-                        });
-                    }
-                    Err(e) => info!("inotify watch failed: {}. You can ignore this if your device does not support the feature", e),
-                }
-            });
-            Ok(())
-        }
-        });
-    };
-}
-
-pub const VERSION: &str = env!("CARGO_PKG_VERSION");
-
-#[async_trait]
-pub trait Reloadable {
-    async fn reload(&mut self) -> Result<(), RogError>;
-}
-
-#[async_trait]
-pub trait ZbusRun {
-    async fn add_to_server(self, server: &mut Connection);
-
-    async fn add_to_server_helper(
-        iface: impl zbus::Interface,
-        path: &str,
-        server: &mut Connection,
-    ) {
-        server
-            .object_server()
-            .at(&ObjectPath::from_str_unchecked(path), iface)
-            .await
-            .map_err(|err| {
-                warn!("{}: add_to_server {}", path, err);
-                err
-            })
-            .ok();
-    }
-}
-
-/// Set up a task to run on the async executor
-#[async_trait]
-pub trait CtrlTask {
-    fn zbus_path() -> &'static str;
-
-    fn signal_context(connection: &Connection) -> Result<SignalContext<'static>, zbus::Error> {
-        SignalContext::new(connection, Self::zbus_path())
-    }
-
-    /// Implement to set up various tasks that may be required, using the `Executor`.
-    /// No blocking loops are allowed, or they must be run on a separate thread.
-    async fn create_tasks(&self, signal: SignalContext<'static>) -> Result<(), RogError>;
-
-    // /// Create a timed repeating task
-    // async fn repeating_task(&self, millis: u64, mut task: impl FnMut() + Send + 'static) {
-    //     use std::time::Duration;
-    //     use tokio::time;
-    //     let mut timer = time::interval(Duration::from_millis(millis));
-    //     tokio::spawn(async move {
-    //         timer.tick().await;
-    //         task();
-    //     });
-    // }
-
-    /// Free helper method to create tasks to run on: sleep, wake, shutdown, boot
-    ///
-    /// The closures can potentially block, so execution time should be the minimal possible
-    /// such as save a variable.
-    async fn create_sys_event_tasks<
-        Fut1,
-        Fut2,
-        Fut3,
-        Fut4,
-        F1: Send + 'static,
-        F2: Send + 'static,
-        F3: Send + 'static,
-        F4: Send + 'static,
-    >(
-        &self,
-        mut on_sleep: F1,
-        mut on_wake: F2,
-        mut on_shutdown: F3,
-        mut on_boot: F4,
-    ) where
-        F1: FnMut() -> Fut1,
-        F2: FnMut() -> Fut2,
-        F3: FnMut() -> Fut3,
-        F4: FnMut() -> Fut4,
-        Fut1: Future<Output = ()> + Send,
-        Fut2: Future<Output = ()> + Send,
-        Fut3: Future<Output = ()> + Send,
-        Fut4: Future<Output = ()> + Send,
-    {
-        let connection = Connection::system()
-            .await
-            .expect("Controller could not create dbus connection");
-
-        let manager = ManagerProxy::new(&connection)
-            .await
-            .expect("Controller could not create ManagerProxy");
-
-        tokio::spawn(async move {
-            if let Ok(mut notif) = manager.receive_prepare_for_sleep().await {
-                while let Some(event) = notif.next().await {
-                    if let Ok(args) = event.args() {
-                        if args.start {
-                            debug!("Doing on_sleep()");
-                            on_sleep().await;
-                        } else if !args.start() {
-                            debug!("Doing on_wake()");
-                            on_wake().await;
-                        }
-                    }
-                }
-            }
-        });
-
-        let manager = ManagerProxy::new(&connection)
-            .await
-            .expect("Controller could not create ManagerProxy");
-
-        tokio::spawn(async move {
-            if let Ok(mut notif) = manager.receive_prepare_for_shutdown().await {
-                while let Some(event) = notif.next().await {
-                    if let Ok(args) = event.args() {
-                        if args.start {
-                            debug!("Doing on_shutdown()");
-                            on_shutdown().await;
-                        } else if !args.start() {
-                            debug!("Doing on_boot()");
-                            on_boot().await;
-                        }
-                    }
-                }
-            }
-        });
-    }
-}
-
-pub trait GetSupported {
-    type A;
-
-    fn get_supported() -> Self::A;
-}

data/asusd-ledmodes.toml

@@ -1,204 +0,0 @@
-[[led_data]]
-prod_family = "ASUS TUF Gaming F15"
-board_names = ["FX506HC"]
-standard = ["Static", "Breathe", "Strobe", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "TUF"
-board_names = ["FA507"]
-standard = ["Static", "Breathe", "Strobe", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "TUF Gaming"
-board_names = ["FX505D"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "ASUS TUF Gaming A15"
-board_names = ["FA506I"]
-standard = ["Static", "Breathe", "Strobe", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "Zephyrus S"
-board_names = ["GX502", "GX701", "G531", "GL531", "G532"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = []
-per_key = true
-
-[[led_data]]
-prod_family = "Zephyrus M"
-board_names = ["GU502G"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = []
-per_key = true
-
-[[led_data]]
-prod_family = "ROG Zephyrus M15"
-board_names = ["GU502LU"]
-standard = ["Static", "Breathe", "Strobe", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Zephyrus M15"
-board_names = ["GU502L"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = []
-per_key = true
-
-[[led_data]]
-prod_family = "ROG Zephyrus M16"
-board_names = ["GU603Z", "GU603H"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Zephyrus S17"
-board_names = ["GX703H"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = []
-per_key = false
-
-
-[[led_data]]
-prod_family = "Zephyrus"
-board_names = ["GM501G", "GX531"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = ["Key1", "Key2", "Key3", "Key4"]
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Strix"
-board_names = ["G531GW", "G533QR", "G533QS", "G733Q", "G513QR", "G713QR", "G513QM", "G713IC", "G713RS"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = []
-per_key = true
-
-[[led_data]]
-prod_family = "ROG Strix"
-board_names = ["G513QE", "GX531", "G512LV", "G712LV", "G712LW", "G513IH", "G513QY", "G713QM", "G512", "G713RM", "G713RW"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = ["Key1", "Key2", "Key3", "Key4"]
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Strix"
-board_names = ["G512LI", "G712LI", "G531GD"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Strix"
-board_names = ["G513IM"]
-standard = ["Flash", "Static", "Breathe", "Strobe", "Rainbow"]
-multizone = []
-per_key = true
-
-[[led_data]]
-prod_family = "Strix"
-board_names = ["G731GV", "G731GW", "G531GV"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow"]
-multizone = ["Key1", "Key2", "Key3", "Key4"]
-per_key = false
-
-[[led_data]]
-prod_family = "Strix"
-board_names = ["GL504G"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = ["Key1", "Key2", "Key3", "Key4", "Logo", "BarLeft", "BarRight"]
-per_key = false
-
-[[led_data]]
-prod_family = "Strix"
-board_names = ["G731GT", "G731GU", "G531GT", "G531GU"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "Strix Scar"
-board_names = ["G531", "G731"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = ["Key1", "Key2", "Key3", "Key4"]
-per_key = true
-
-[[led_data]]
-prod_family = "ROG"
-board_names = ["GL553VE"]
-standard = ["Static", "Breathe", "Strobe"]
-multizone = ["Key1", "Key2", "Key3", "Key4"]
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Zephyrus G14"
-board_names = ["GA401Q"]
-standard = ["Static", "Breathe", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Zephyrus G14"
-board_names = ["GA402R"]
-standard = ["Static", "Breathe", "Pulse", "Rainbow"]
-multizone = []
-per_key = false
-
-# GA503QE at higher priority (first match) than GA503Q
-[[led_data]]
-prod_family = "ROG Zephyrus G15"
-board_names = ["GA503QE"]
-standard = ["Static", "Breathe", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Zephyrus G15"
-board_names = ["GA503Q", "GA503R"]
-standard = ["Static", "Breathe", "Pulse", "Rainbow", "Strobe"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Zephyrus"
-board_names = ["GX550L"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = []
-per_key = true
-
-[[led_data]]
-prod_family = "ROG Zephyrus Duo 15 SE"
-board_names = ["GX551Q"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = []
-per_key = true
-
-[[led_data]]
-prod_family = "ROG Flow X13"
-board_names = ["GV301Q"]
-standard = ["Static", "Breathe", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Strix"
-board_names = ["G513IC", "G513RC", "G513RM"]
-standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = []
-per_key = false
-
-[[led_data]]
-prod_family = "ROG Flow X16"
-board_names = ["GV601R"]
-standard = ["Static", "Breathe", "Strobe", "Pulse"]
-multizone = []
-per_key = false

data/asusd.rules

@@ -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,16 +1,15 @@
 [Unit]
 Description=ASUS Notebook Control
-StartLimitInterval=200
-StartLimitBurst=2
-Before=multi-user.target
+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
-Restart=always
 RestartSec=1
 Type=dbus
 BusName=org.asuslinux.Daemon

data/icons/scalable/anime.svg

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?><!-- Generator: Gravit.io --><svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" style="isolation:isolate" viewBox="0 0 512 512" width="512pt" height="512pt"><defs><clipPath id="_clipPath_8C5izdJ0sH9w7nD5UuBTlpktuZWEWJn8"><rect width="512" height="512"/></clipPath></defs><g clip-path="url(#_clipPath_8C5izdJ0sH9w7nD5UuBTlpktuZWEWJn8)"><path d=" M 113.969 270.246 C 113.969 301.718 88.456 327.231 56.985 327.231 C 25.513 327.231 0 301.718 0 270.246 C 0 238.775 25.513 213.262 56.985 213.262 C 88.456 213.262 113.969 238.775 113.969 270.246 Z  M 56.985 384.215 C 41.249 384.215 28.492 396.972 28.492 412.708 C 28.492 428.443 41.249 441.2 56.985 441.2 C 72.72 441.2 85.477 428.443 85.477 412.708 C 85.477 396.972 72.72 384.215 56.985 384.215 Z  M 56.985 70.8 C 25.513 70.8 0 96.313 0 127.785 C 0 159.256 25.513 184.769 56.985 184.769 C 88.456 184.769 113.969 159.256 113.969 127.785 C 113.969 96.313 88.456 70.8 56.985 70.8 Z  M 199.446 241.754 C 183.71 241.754 170.954 254.51 170.954 270.246 C 170.954 285.982 183.71 298.738 199.446 298.738 C 215.182 298.738 227.938 285.982 227.938 270.246 C 227.938 254.51 215.182 241.754 199.446 241.754 Z  M 199.446 384.215 C 183.71 384.215 170.954 396.972 170.954 412.708 C 170.954 428.443 183.71 441.2 199.446 441.2 C 215.182 441.2 227.938 428.443 227.938 412.708 C 227.938 396.972 215.182 384.215 199.446 384.215 Z  M 199.446 70.8 C 167.975 70.8 142.462 96.313 142.462 127.785 C 142.462 159.256 167.975 184.769 199.446 184.769 C 230.918 184.769 256.431 159.256 256.431 127.785 C 256.431 96.313 230.918 70.8 199.446 70.8 Z  M 339.904 241.754 C 324.169 241.754 311.412 254.51 311.412 270.246 C 311.412 285.982 324.169 298.738 339.904 298.738 C 355.64 298.738 368.397 285.982 368.397 270.246 C 368.397 254.51 355.64 241.754 339.904 241.754 Z  M 339.904 384.215 C 324.169 384.215 311.412 396.972 311.412 412.708 C 311.412 428.443 324.169 441.2 339.904 441.2 C 355.64 441.2 368.397 428.443 368.397 412.708 C 368.397 396.972 355.64 384.215 339.904 384.215 Z  M 339.904 70.8 C 308.433 70.8 282.92 96.313 282.92 127.785 C 282.92 159.256 308.433 184.769 339.904 184.769 C 371.376 184.769 396.889 159.256 396.889 127.785 C 396.889 96.313 371.376 70.8 339.904 70.8 Z  M 482.366 241.754 C 466.63 241.754 453.874 254.51 453.874 270.246 C 453.874 285.982 466.63 298.738 482.366 298.738 C 498.102 298.738 510.858 285.982 510.858 270.246 C 510.858 254.51 498.102 241.754 482.366 241.754 Z  M 482.366 384.215 C 466.63 384.215 453.874 396.972 453.874 412.708 C 453.874 428.443 466.63 441.2 482.366 441.2 C 498.102 441.2 510.858 428.443 510.858 412.708 C 510.858 396.972 498.102 384.215 482.366 384.215 Z  M 482.366 99.292 C 466.63 99.292 453.874 112.049 453.874 127.785 C 453.874 143.52 466.63 156.277 482.366 156.277 C 498.102 156.277 510.858 143.52 510.858 127.785 C 510.858 112.049 498.102 99.292 482.366 99.292 Z " fill="#F2F2F2"/></g></svg>

data/icons/scalable/reboot.svg

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?><!-- Generator: Gravit.io --><svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" style="isolation:isolate" viewBox="141 297.96 507.339 471.04" width="507.339pt" height="471.04pt"><g><g><g><g><path d=" M 537.075 443.463 L 537.075 443.463 L 564.723 427.335 C 504.903 324.571 375.966 285.313 269.027 337.304 L 269.027 297.96 L 237.027 297.96 L 237.027 393.96 L 333.027 393.96 L 333.027 361.96 L 292.147 361.96 C 382.665 323.563 487.612 358.486 537.075 443.463 Z " fill="rgb(221,221,221)"/><path d=" M 245.027 692.775 C 170.84 632.524 151.314 527.353 198.931 444.488 L 171.187 428.488 C 116.876 523.063 137.426 642.887 220.147 713.96 L 181.027 713.96 L 181.027 745.96 L 277.027 745.96 L 277.027 649.96 L 245.027 649.96 L 245.027 692.775 L 245.027 692.775 Z " fill="rgb(221,221,221)"/><path d=" M 580.451 499.048 L 512.579 566.936 L 535.203 589.56 L 562.403 562.36 C 551.734 661.49 468.201 736.724 368.499 737 L 368.499 769 C 487.289 768.688 585.833 677.011 594.707 558.552 L 625.715 589.56 L 648.339 566.936 L 580.451 499.048 Z " fill="rgb(221,221,221)"/></g></g></g></g></svg>

data/icons/scalable/rog-logo.svg

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?><!-- Generator: Gravit.io --><svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" style="isolation:isolate" viewBox="0 0 128 128" width="128pt" height="128pt"><defs><clipPath id="_clipPath_CHRnLOITGqiXLlZjYLaUfMylStiUiIRD"><rect width="128" height="128"/></clipPath></defs><g clip-path="url(#_clipPath_CHRnLOITGqiXLlZjYLaUfMylStiUiIRD)"><path d=" M 69.096 31.645 C 68.865 31.712 68.805 31.816 68.577 32.011 C 68.393 32.168 68.238 32.28 68.059 32.434 C 67.651 32.785 67.411 33.003 67.052 33.305 C 65.269 34.805 62.85 37.142 61.102 38.778 C 58.391 41.317 55.947 43.762 53.346 46.287 C 48.441 51.049 42.882 56.766 37.972 61.357 C 33.914 65.151 30.434 68.558 26.194 72.351 C 24.574 73.801 23.553 75.121 21.346 75.197 C 17.705 75.323 12.902 72.224 10.446 70.814 C 8.299 69.583 2.598 66.23 -0.15 66.137 L 1.864 68.903 C 3.303 71.1 5.724 75.885 6.887 78.214 C 10.881 86.213 16.273 94.589 23.136 100.161 C 24.891 101.586 26.481 102.783 28.71 104.132 C 29.687 104.723 30.685 105.215 31.778 105.834 C 32.157 106.049 34.786 107.277 35.11 107.276 C 34.39 106.554 33.649 105.673 33.064 104.985 C 30.452 101.912 24.64 95.938 22.894 92.889 C 21.428 90.329 21.091 88.761 22.72 86.192 C 24.582 83.254 28.924 79.619 31.648 77.289 C 38.277 71.62 44.256 66.485 51.191 61.102 C 54.478 58.551 57.895 55.949 61.429 53.427 C 64.896 50.954 68.381 48.57 72 46.178 L 77.465 42.7 C 77.972 42.409 82.95 39.446 83.029 39.347 L 87.9 36.66 C 89.536 35.736 91.124 34.964 92.857 34.031 C 97.94 31.294 108.035 26.833 113.82 24.792 C 115.718 24.122 117.528 23.489 119.449 22.833 L 125.205 21.03 C 124.739 20.79 118.379 20.724 117.207 20.724 C 112.491 20.723 109.598 20.855 105.095 21.211 C 101.65 21.483 95.237 22.19 92.104 22.948 C 91.54 23.084 90.872 23.142 90.304 23.292 C 89.218 23.578 87.974 23.775 86.861 24.052 C 84.567 24.623 82.484 25.271 80.328 25.914 C 78.108 26.575 76.101 27.36 74.115 28.177 C 72.942 28.659 69.397 31.029 69.096 31.645 L 69.096 31.645 Z  M 115.16 43.036 L 119.345 40.899 C 120.797 40.208 122.299 39.413 123.667 38.745 C 126.441 37.389 128.04 32.995 127.999 30.179 C 127.509 30.199 125.516 31.144 124.975 31.342 C 124.603 31.479 124.259 31.596 123.911 31.744 C 121.439 32.794 118.139 34.036 115.795 35.142 C 115.115 35.463 114.457 35.729 113.769 36.024 C 113.228 36.256 112.036 36.724 111.814 36.999 C 111.07 36.962 95.925 44.467 94.037 45.443 C 91.35 46.833 87.97 48.499 85.386 49.936 C 85.08 50.106 77.204 54.275 76.891 54.676 C 76.372 54.762 70.974 57.968 70.112 58.454 C 59.43 64.482 47.599 72.065 37.367 79.004 C 34.524 80.933 30.892 83.463 28.034 85.617 L 25.739 87.329 C 25.476 87.53 25.165 87.663 25.013 87.965 C 26.033 88.843 32.791 91.628 34.403 92.209 C 43.451 95.47 51.92 97.742 61.441 99.376 L 67.483 100.3 L 72.241 100.72 L 68.366 100.378 C 69.105 100.462 69.839 100.582 70.559 100.651 C 71.624 100.753 72.679 100.84 73.776 100.949 C 75.841 101.157 78.238 101.298 80.361 101.335 C 82.999 101.381 84.453 101.516 86.617 100.603 C 88.294 99.894 89.659 99.013 90.992 97.992 C 95.957 94.187 100.375 88.235 103.899 82.849 C 107.587 77.213 110.909 70.915 113.773 64.675 C 115.231 61.498 116.599 58.182 117.888 54.804 C 118.541 53.092 119.107 51.439 119.697 49.622 C 120.023 48.617 121.212 44.945 121.302 44.125 C 119.948 44.31 96.265 57.088 94.012 58.297 C 90.956 59.938 88.029 61.647 85.064 63.258 C 82.182 64.823 79.134 66.672 76.267 68.266 C 70.441 71.504 64.575 75.11 58.757 78.479 C 57.76 79.056 50.352 83.387 50.086 83.691 C 50.584 83.611 74.07 73.525 74.639 73.29 C 75.746 72.832 98.806 62.937 99.184 62.92 C 99.052 63.454 97.624 66.118 97.264 66.901 C 96.664 68.206 95.94 69.692 95.284 70.989 C 91.565 78.346 87.529 87.178 79.411 90.439 L 78.923 90.732 C 78.488 90.742 77.299 91.225 76.775 91.369 C 75.986 91.586 75.223 91.736 74.428 91.899 C 70.686 92.665 65.028 92.266 61.129 91.656 C 56.682 90.96 53.568 90.179 49.258 89.137 C 48.229 88.889 40.792 86.799 40.362 86.516 C 40.604 86.093 44.858 83.368 45.23 83.109 C 53.46 77.389 67.13 68.983 76.02 63.925 C 76.961 63.389 77.835 62.903 78.696 62.41 C 79.411 62 80.72 61.317 81.298 60.897 L 85.457 58.616 C 86.864 57.835 88.155 57.159 89.637 56.314 C 92.438 54.716 95.275 53.376 98.032 51.823 C 98.437 51.595 114.179 43.323 115.159 43.037 L 115.16 43.036 Z " fill-rule="evenodd" fill="#F2F2F2"/></g></svg>

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

@@ -0,0 +1,25 @@
+/* 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-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/LICENSE

@@ -0,0 +1,373 @@
+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-45/README.md

@@ -0,0 +1,21 @@
+# 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-45/esbuild.js

@@ -0,0 +1,67 @@
+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",
+  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: "firefox102",
+  //platform: "neutral",
+  platform: "node",
+  // mainFields: ['main'],
+  // conditions: ['require', 'default'],
+  format: "esm",
+  external: ["gi://*", "resource://*", "system", "gettext", "cairo"],
+}).then(() => {
+  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 = resolve(__dirname, zipFilename);
+
+  exec("glib-compile-schemas schemas/", (error, stdout, stderr) => {
+    console.log("stdout: " + stdout);
+    console.log("stderr: " + stderr);
+  });
+
+  copyFileSync(metaSrc, metaDist);
+
+  cpSync(schemaSrc, schemaDist, { recursive: true }, (err) => {
+    if (err) {
+      console.error(err);
+    }
+  });
+
+  cpSync(dbusXmlSrc, dbusXmlDist, { recursive: true }, (err) => {
+    if (err) {
+      console.error(err);
+    }
+  });
+
+  const zip = new AdmZip();
+  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`);
+});

desktop-extensions/gnome-45/generate.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+
+## Script to initialise dev-environment (types)
+gv="44"
+wd=${PWD}
+
+# cleanup
+rm -rf @types
+
+# generate GJS from gir (this does not include the extensions)
+echo "Generating GJS types from gir.."
+npx ts-for-gir generate Shell-12 St-12 Gtk-4.0 \
+  -g /usr/share/gir-1.0 \
+  -g /usr/share/gnome-shell \
+  -g /usr/share/gnome-shell/gir-1.0 \
+  -g /usr/lib64/mutter-12 \
+  -t esm -o @types/Gjs
+
+# get latest js (44) in this case and create the types for it
+echo "Generating GJS Extension (Gex) types from extension source.."
+mkdir -p ./_tmp/
+cd ./_tmp
+wget -q -O gnome-shell-js-${gv}.tar.gz https://gitlab.gnome.org/GNOME/gnome-shell/-/archive/gnome-${gv}/gnome-shell-gnome-${gv}.tar.gz?path=js
+tar xf gnome-shell-js-${gv}.tar.gz
+cd gnome-shell-gnome-${gv}-js
+cat >tsconfig.json <<EOL
+{
+  "include": ["js/ui/*"],
+  "exclude": [
+    "js/ui/shellDBus.js",
+    "node_modules",
+    "**/node_modules/*"
+  ],
+  "compilerOptions": {
+    "allowJs": true,
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "outDir": "gex-types",
+    "declarationMap": true,
+    "lib": ["es2019"]
+  }
+}
+EOL
+npx tsc
+cd ${wd}
+mv ./_tmp/gnome-shell-gnome-${gv}-js/gex-types @types/Gex
+# rm -rf ./_tmp/
+
+echo "done."
+
+exit 0

desktop-extensions/gnome-45/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "asusctl-gnome",
+  "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",
+    "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.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",
+    "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-45/schemas/org.gnome.shell.extensions.asusctl-gnome.gschema.xml

@@ -0,0 +1,24 @@
+<?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 type="b" name="anime-builtins">
+      <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-45/src/bindings

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

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

@@ -0,0 +1,127 @@
+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 { 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 {
+  // public dbus_aura: AuraDbus = new AuraDbus;
+  // public dbus_anime: AnimeDbus = new AnimeDbus;
+  public dbus_platform: DbusBase | undefined;
+  public dbus_anime: DbusBase | undefined;
+
+  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;
+
+  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();
+    }
+
+    if (this.dbus_anime == undefined) {
+      this.dbus_anime = new DbusBase("org-asuslinux-anime-4.xml", "/org/asuslinux/Anime");
+      await this.dbus_anime.start();
+    }
+
+    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);
+
+    // new AsusIndicator("selection-mode-symbolic", "mini-led-enabled");
+    // new AsusIndicator("selection-mode-symbolic", "panel-od-enabled");
+
+    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.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.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.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",
+          );
+        }
+    }
+
+    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",
+        );
+      }
+  }
+
+  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

@@ -0,0 +1,9 @@
+{
+  "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": ["45"]
+}

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

@@ -0,0 +1,98 @@
+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,
+    },
+    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[] = [];
+
+  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 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;
+  }
+
+  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();
+  }
+}