Point release

These have a slightly different power settings data which needs to be verified.
We can use the old style for now.

Closes #542

.cargo-husky/hooks/pre-commit

@@ -0,0 +1,18 @@
+#!/bin/sh
+
+set -e
+
+echo 'find -name \*.slint | xargs slint-tr-extractor -o rog-control-center/translations/en/rog-control-center.po'
+find -name \*.slint | xargs slint-tr-extractor -o rog-control-center/translations/en/rog-control-center.po
+
+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 -- --test-threads=1
+
+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

.gitignore

@@ -8,4 +8,14 @@ vendor_*
 .vscode-ctags
 .vscode
 .~lock.*
-*.ods# 
+*.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 libinput-dev libseat-dev 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,37 @@ check:
 test:
   except:
     - tags
+  <<: *rust_cache
   script:
-    - cargo test
+    - mkdir -p .git/hooks > /dev/null
+    - cargo test --all -- --test-threads=1
 
 release:
   only:
     - tags
+  <<: *rust_cache
   script:
+    - cargo install cargo-vendor-filterer
     - make && make vendor
   artifacts:
     paths:
-    - vendor_asusctl_*.tar.xz
-    - cargo-config
+      - 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

.gitlab/issue_templates/default.md

@@ -0,0 +1,32 @@
+## Issue description
+
+(** I can not support distros which are outdated by default. This includes Ubuntu at least 50% of the time, and definitely includes Mint. **)
+(Summarize the bug encountered)
+
+## Steps to reproduce
+
+(How can the issue be reproduced)
+
+## What is the current bug behavior?
+
+(What actually happens)
+
+## What is the expected correct behavior?
+
+(What you should see instead)
+
+## Relevant logs and/or screenshots
+
+(run `journalctl -b -u asusd > ~/asusd.log` and attach `~/asusd.log`)
+
+(Paste any relevant logs - use code blocks (```) to format console output, logs, and code, as
+it's very hard to read otherwise.)
+
+## System details
+
+- Distro:
+- Kernel: (`uname -r`)
+- Desktop:
+- Xorg or wayland: ??
+
+/label ~bug ~reproducable ~needs-investigation

Cargo.toml

@@ -1,33 +1,66 @@
-[workspace]
-members = ["asusctl", "config-traits", "daemon", "daemon-user", "rog-platform", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles", "rog-control-center"]
-
 [workspace.package]
-version = "4.6.0-rc1"
+version = "6.0.12"
+rust-version = "1.77"
+license = "MPL-2.0"
+readme = "README.md"
+authors = ["Luke <luke@ljones.dev>"]
+repository = "https://gitlab.com/asus-linux/asusctl"
+homepage = "https://gitlab.com/asus-linux/asusctl"
+description = "Laptop feature control for ASUS ROG laptops and others"
+edition = "2021"
+
+[workspace]
+resolver = "2"
+members = [
+    "asusctl",
+    "asusd",
+    "asusd-user",
+    "config-traits",
+    "cpuctl",
+    "dmi-id",
+    "rog-platform",
+    "rog-dbus",
+    "rog-anime",
+    "rog-aura",
+    "rog-profiles",
+    "rog-control-center",
+    "rog-slash",
+    "simulators",
+]
+default-members = [
+    "asusctl",
+    "asusd",
+    "asusd-user",
+    "cpuctl",
+    "rog-control-center",
+]
 
 [workspace.dependencies]
-async-trait = "^0.1"
-tokio = { version = "^1.23.0", features = ["macros", "rt-multi-thread", "time", "sync"]}
+tokio = { version = "^1.39.0", default-features = false, features = [
+    "macros",
+    "sync",
+    "time",
+    "rt-multi-thread",
+] }
 concat-idents = "^1.1"
 dirs = "^4.0"
 smol = "^1.3"
+mio = "0.8.11"
 
-zbus = "^3.6"
-logind-zbus = { version = "^3.1.0" } #, default-features = false, features = ["non_blocking"] }
+zbus = "4.4"
+logind-zbus = { version = "4.0.3" } #, default-features = false, features = ["non_blocking"] }
 
-serde = "^1.0"
-serde_derive = "^1.0"
-serde_json = "^1.0"
-toml = "^0.5.10"
+serde = { version = "^1.0", features = ["serde_derive"] }
 ron = "*"
+typeshare = "1.0.0"
 
 log = "^0.4"
 env_logger = "^0.10.0"
 
 glam = { version = "^0.22", features = ["serde"] }
 gumdrop = "^0.8"
-udev = "^0.7"
+udev = { version = "^0.8", features = ["mio"] }
 rusb = "^0.9"
-sysfs-class = "^0.1.3"
 inotify = "^0.10.0"
 
 png_pong = "^0.8"
@@ -35,7 +68,9 @@ pix = "^0.13"
 tinybmp = "^0.4.0"
 gif = "^0.12.0"
 
-notify-rust = { git = "https://github.com/flukejones/notify-rust.git", default-features = false, features = ["z"] }
+versions = "6.2"
+
+notify-rust = { version = "4.11.0", features = ["z", "async"] }
 
 [profile.release]
 # thin = 57s, asusd = 9.0M
@@ -44,11 +79,21 @@ lto = "fat"
 debug = false
 opt-level = 3
 panic = "abort"
+codegen-units = 1
 
 [profile.dev]
-debug = true
 opt-level = 1
+codegen-units = 16
+
+[profile.dev.package."*"]
+opt-level = 1
+codegen-units = 16
 
 [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

@@ -1,5 +1,7 @@
 # asusctrl manual
 
+**NOTE:** this manual is in need of an update in some places. If you find issues please file issue reports.
+
 `asusd` is a utility for Linux to control many aspects of various ASUS laptops
 but can also be used with non-asus laptops with reduced features.
 
@@ -8,11 +10,10 @@ but can also be used with non-asus laptops with reduced features.
 - `asusd`: The main system daemon. It is autostarted by a udev rule and systemd unit.
 - `asusd-user`: The user level daemon. Currently will run an anime sequence, with RGB keyboard sequences soon.
 - `asusctl`: The CLI for interacting with the system daemon
-- `asus-notify`: A notification daemon with a user systemd unit that can be enabled.
 
 ## `asusd`
 
-`asusd` is the main system-level daemon which will control/load/save various settings in a safe way for the user, along with exposing a *safe* dbus interface for these interactions. This section covers only the daemon plus the various configuration file options.
+`asusd` is the main system-level daemon which will control/load/save various settings in a safe way for the user, along with exposing a _safe_ dbus interface for these interactions. This section covers only the daemon plus the various configuration file options.
 
 The functionality that `asusd` exposes is:
 
@@ -56,6 +57,7 @@ Almost all modern ASUS laptops have charging limit control now. This can be cont
 ```json
 "bat_charge_limit": 80,
 ```
+
 where the number is a percentage.
 
 ### Bios control
@@ -63,7 +65,7 @@ where the number is a percentage.
 Some options that you find in Armory Crate are available under this controller, so far there is:
 
 - POST sound: this is the sound you hear on bios boot post
-- GPU MUX: this controls if the dGPU is the *only* GPU, making it the main GPU and disabling the iGPU
+- GPU MUX: this controls if the dGPU is the _only_ GPU, making it the main GPU and disabling the iGPU
 
 These options are not written to the config file as they are stored in efivars. The only way to change these is to use the exposed safe dbus methods, or use the `asusctl` CLI tool.
 
@@ -72,6 +74,7 @@ These options are not written to the config file as they are stored in efivars.
 asusctl can support setting a power profile via platform_profile drivers. This requires [power-profiles-daemon](https://gitlab.freedesktop.org/hadess/power-profiles-daemon) v0.10.0 minimum. It also requires the kernel patch for platform_profile support to be applied form [here](https://lkml.org/lkml/2021/8/18/1022) - this patch is merged to 5.15 kernel upstream.
 
 A common use of asusctl is to bind the `fn+f5` (fan) key to `asusctl profile -n` to cycle through the 3 profiles:
+
 1. Balanced
 2. Performance
 3. Quiet
@@ -97,7 +100,7 @@ There is one more controller; the support controller. The sole pupose of this co
 
 ## asusd-user
 
-`asusd-user` is a usermode daemon. The intended purpose is to provide a method for users to run there own custom per-key keyboard effects and modes, AniMe sequences, and possibly their own profiles - all without overwriting the *base* system config. As such some parts of the system daemon will migrate to the user daemon over time with the expectation that the Linux system runs both.
+`asusd-user` is a usermode daemon. The intended purpose is to provide a method for users to run there own custom per-key keyboard effects and modes, AniMe sequences, and possibly their own profiles - all without overwriting the _base_ system config. As such some parts of the system daemon will migrate to the user daemon over time with the expectation that the Linux system runs both.
 
 As of now only AniMe is active in this with configuration in `~/.config/rog/`. On first run defaults are created that are intended to work as examples.
 
@@ -177,6 +180,7 @@ An Aura config itself is a file with contents:
 ```
 
 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
@@ -238,6 +242,7 @@ Each object in the array can be one of:
 ##### AsusAnimation
 
 `AsusAnimation` is specifically for running the gif files that Armory Crate comes with. `asusctl` includes all of these in `/usr/share/asusd/anime/asus/`
+
 ```json
       "AsusAnimation": {
         "file": "<FILE_PATH>",
@@ -260,7 +265,7 @@ Virtually the same as `AsusAnimation` but for png files, typically created in th
 
 ##### ImageAnimation
 
-`ImageAnimation` can play *any* gif of any size.
+`ImageAnimation` can play _any_ gif of any size.
 
 ```json
       "ImageAnimation": {
@@ -319,6 +324,7 @@ Must be full path: `"/usr/share/asusd/anime/asus/gaming/Controller.gif"` or `/ho
 **<FLOAT>**
 
 A number from 0.0-1.0.
+
 - `brightness`: If it is brightness it is combined with the system daemon global brightness
 - `scale`: 1.0 is the original size with lower number shrinking, larger growing
 - `angle`: Rotation angle in radians
@@ -327,6 +333,7 @@ A number from 0.0-1.0.
 **<TIME>**
 
 Time is the length of time to run the gif for:
+
 ```json
         "time": {
           "Time": {
@@ -335,17 +342,23 @@ Time is the length of time to run the gif for:
           }
         },
 ```
+
 A cycle is how many gif loops to run:
+
 ```json
         "time": {
           "Cycles": 2
         },
 ```
+
 `Infinite` means that this gif will never end:
+
 ```json
         "time": "Infinite",
 ```
+
 `Fade` allows an image or gif to fade in and out, and remain at max brightness to n time:
+
 ```json
         "time": {
           "Fade": {
@@ -364,6 +377,7 @@ A cycle is how many gif loops to run:
           }
         },
 ```
+
 `show_for` can be `null`, if it is `null` then the `show_for` becomes `gif_time_length - fade_in - fade_out`.
 This is period for which the gif or image will be max brightness (as set).
 
@@ -404,26 +418,19 @@ asusctl <command> <subcommand> --help
 
 To switch to next/previous Aura modes you will need to bind both the aura keys (if available) to one of:
 **Next**
+
 ```
 asusctl led-mode -n
 ```
+
 **Previous**
+
 ```
 asusctl led-mode -p
 ```
 
 To switch Fan/Thermal profiles you need to bind the Fn+F5 key to `asusctl profile -n`.
 
-## User NOTIFICATIONS via dbus
-
-If you have a notifications handler set up, or are using KDE or Gnome then you
-can enable the user service to get basic notifications when something changes.
-
-```
-systemctl --user enable asus-notify.service
-systemctl --user start asus-notify.service
-```
-
 # License & Trademarks
 
 Mozilla Public License 2 (MPL-2.0)

Makefile

@@ -1,4 +1,4 @@
-VERSION := $(shell /usr/bin/grep -Pm1 'version = "(\d.\d.\d)"' Cargo.toml | cut -d'"' -f2)
+VERSION := $(shell /usr/bin/grep -Pm1 'version = "(\d+.\d+.\d+)"' Cargo.toml | cut -d'"' -f2)
 
 INSTALL = install
 INSTALL_PROGRAM = ${INSTALL} -D -m 0755
@@ -19,10 +19,15 @@ 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
+	ARGS += --release --features "rog-control-center/x11"
 	TARGET = release
+else
+	ARGS += --profile dev --features "rog-control-center/x11"
+	TARGET = debug
 endif
 
 VENDORED ?= 0
@@ -38,16 +43,18 @@ 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 "*.ron" -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)"
-
 	$(INSTALL_DATA) "./data/$(BIN_D).rules" "$(DESTDIR)$(libdir)/udev/rules.d/99-$(BIN_D).rules"
 	$(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"
@@ -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,33 @@ vendor:
 	echo 'directory = "vendor"' >> .cargo/config
 	mv .cargo/config ./cargo-config
 	rm -rf .cargo
+	rm -rf vendor
+	cargo vendor-filterer --all-features --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
+
+translate:
+	find -name \*.slint | xargs slint-tr-extractor -o rog-control-center/translations/en/rog-control-center.po
+
 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,8 +1,8 @@
 # `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.
+**WARNING:** Many features are developed in tandem with kernel patches. If you see a feature is missing you either need a patched kernel or latest release.
 
 `asusd` is a utility for Linux to control many aspects of various ASUS laptops
 but can also be used with non-asus laptops with reduced features.
@@ -11,27 +11,33 @@ Now includes a GUI, `rog-control-center`.
 
 ## Kernel support
 
-**The minimum supported kernel version is 5.17**
+**The minimum supported kernel version is 6.10**, which will contain the patches from [here](https://lore.kernel.org/platform-driver-x86/20240404001652.86207-1-luke@ljones.dev/). This is especially required for 2023+ devices and possibly some late 2022 devices.
 
-**For TUF laptops, the minimum supported kernel version is 6.1**
+Z13 devices will need [these](https://lore.kernel.org/linux-input/20240416090402.31057-1-luke@ljones.dev/T/#t)
+
+## X11 support
+
+X11 is not supported at all, as in I will not help you with X11 issues if there are any due to limited time and it being unmaintained itself. You can however build `rog-control-center` with it enabled `cargo build --features "rog-control-center/x11"`.
 
 ## Goals
 
-1. To provide an interface for rootless control of some system functions most users wish to control such as fan speeds, keyboard LEDs, graphics modes.
-2. Enable third-party apps to use the above with dbus methods
-3. To make the above as easy as possible for new users
-4. Respect the users resources: be small, light, and fast
+The main goal of this work is to provide a safe and easy to use abstraction over various laptop features via DBUS, and to provide some helpful defaults and other behaviour such as toggling throttle/profile on AC/battery change.
 
-Point 3 means that the list of supported distros is very narrow - fedora is explicitly
-supported. All other distros are *not* supported (while asusd might still run fine on them).
-For best support use fedora 36+ Workstation.
+1. Provide safe dbus interface
+2. Respect the users resources: be small, light, and fast
 
 Point 4? asusd currently uses a tiny fraction of cpu time, and less than 1Mb of ram, the way
-a system-level daemon should.
+a system-level daemon should. Languages such as JS and python should never be used for system level daemons (please stop).
+
+## Keyboard LEDs
+
+The level of support for laptops is dependent on folks submitting data to include in [`./rog-aura/data/layouts/aura_support.ron`](./rog-aura/data/layouts/aura_support.ron), typically installed in `/usr/share/asusd/aura_support.ron`. This is because the controller used for keyboards and LEDs is used across many years and many laptop models, all with different firmware configurations - the only way to track this is with the file mentioned above. Why not just enable all by default? Because it confuses people.
+
+See the [rog-aura readme](./rog-aura/README.md) for more details.
 
 ## Discord
 
-[Discord server link](https://discord.gg/4ZKGd7Un5t)
+[![Discord](https://img.shields.io/badge/Discord-7289DA?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/z8y99XqPb7)
 
 ## SUPPORTED LAPTOPS
 
@@ -42,56 +48,43 @@ to this:
 Bus 001 Device 002: ID 0b05:1866 ASUSTek Computer, Inc. N-KEY Device
 ```
 
+or
+
+```
+Bus 003 Device 002: ID 0b05:19b6 ASUSTek Computer, Inc. [unknown]
+```
+
 then it may work without tweaks. Technically all other functions except the LED
 and AniMe parts should work regardless of your latop make.
 
 ## Implemented
 
-- [X] System daemon
-- [X] GUI app
-- [X] User notifications daemon
-- [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] 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
-- [X] Toggle GPU MUX (g-sync, or called MUX on 2022+ laptops)
+The list is a bit outdated as many features have been enabled in the Linux kernel with upstream patches and then supported in asusctl suite.
+
+- [x] System 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] 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
+- [x] Toggle GPU MUX (g-sync, or called MUX on 2022+ laptops)
 
 # GUI
 
 A gui is now in the repo - ROG Control Center. At this time it is still a WIP, but it has almost all features in place already.
 
-![](/extra/system.png)
-![](/extra/fan-curves.png)
-![](/extra/keyboard.png)
+**NOTE**: Xorg is not supported.
 
 # BUILDING
 
-Requirements are rust >= 1.57 installed from rustup.io if the distro provided version is too old, and `make`.
-
-**Ubuntu (unsuported):**
-
-    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 ibclang-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
-    
+Rust and cargo are required, they can be installed from [rustup.rs](https://rustup.rs/) or from the distro repos if newer than 1.75.
 
 **fedora:**
 
-    dnf install cmake clang-devel systemd-devel glib2-devel cairo-devel atkmm-devel pangomm-devel gdk-pixbuf-devel gtk3-devel libappindicator-gtk3
+    dnf install cmake clang-devel libinput-devel libseat-devel libgbm-devel libxkbcommon-devel systemd-devel libdrm-devel expat-devel pcre2-devel libzstd-devel gtk3-devel
     make
     sudo make install
 
@@ -100,34 +93,52 @@ 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 clang-devel libinput-devel libseat-devel libgbm-devel libxkbcommon-devel systemd-devel libdrm-devel expat-devel pcre2-devel libzstd-devel gtk3-devel
     make
     sudo make install
 
+**Ubuntu, Popos (unsuported):**
+
+instructions removed as outdated
+
 ## Installing
+
 - Fedora copr = https://copr.fedorainfracloud.org/coprs/lukenukem/asus-linux/
 - openSUSE = https://download.opensuse.org/repositories/home:/luke_nukem:/asus/
-- Ubuntu = not supported due to packaging woes, but you can build and install on your own.
 
 =======
 
 The default init method is to use the udev rule, this ensures that the service is
 started when the device is initialised and ready.
 
+You may also need to activate the service for debian install. If running Pop!\_OS, I suggest disabling `system76-power` gnome-shell extension and systemd service.
+
+## Upgrading
+
 If you are upgrading from a previous installed version, you will need to restart the service or reboot.
 
 ```
 $ systemctl daemon-reload && systemctl restart asusd
 ```
 
-You may also need to activate the service for debian install. If running Pop!_OS, I suggest disabling `system76-power` gnome-shell extension and systemd service.
-
 ## Uninstalling
 
 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

@@ -1,24 +1,28 @@
 [package]
 name = "asusctl"
-license = "MPL-2.0"
-authors = ["Luke D Jones <luke@ljones.dev>"]
-edition = "2021"
+license.workspace = true
 version.workspace = true
+readme.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+edition.workspace = true
 
 [dependencies]
 rog_anime = { path = "../rog-anime" }
+rog_slash = { path = "../rog-slash" }
 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" }
 
+ron.workspace = true
 gumdrop.workspace = true
-toml.workspace = true
-sysfs-class.workspace = true
+zbus.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

@@ -3,14 +3,16 @@ use std::error::Error;
 use std::path::Path;
 use std::process::exit;
 
-use rog_anime::usb::get_anime_type;
+use rog_anime::usb::get_maybe_anime_type;
 use rog_anime::{AnimeDiagonal, AnimeType};
-use rog_dbus::RogDbusClientBlocking;
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let (client, _) = RogDbusClientBlocking::new().unwrap();
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).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");
@@ -24,13 +26,9 @@ fn main() -> Result<(), Box<dyn Error>> {
         AnimeType::GA401,
     )?;
 
-    let anime_type = get_anime_type()?;
+    let anime_type = get_maybe_anime_type()?;
 
-    client
-        .proxies()
-        .anime()
-        .write(matrix.into_data_buffer(anime_type)?)
-        .unwrap();
+    proxy.write(matrix.into_data_buffer(anime_type)?).unwrap();
 
     Ok(())
 }

asusctl/examples/anime-diag.rs

@@ -1,9 +1,10 @@
 use std::thread::sleep;
 use std::time::Duration;
 
-use rog_anime::usb::get_anime_type;
+use rog_anime::usb::get_maybe_anime_type;
 use rog_anime::{AnimeDiagonal, AnimeType};
-use rog_dbus::RogDbusClientBlocking;
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
 
 // In usable data:
 // Top row start at 1, ends at 32
@@ -11,26 +12,25 @@ use rog_dbus::RogDbusClientBlocking;
 // 74w x 36h diagonal used by the windows app
 
 fn main() {
-    let (client, _) = RogDbusClientBlocking::new().unwrap();
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).unwrap();
 
     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;
             }
         }
 
-        let anime_type = get_anime_type().unwrap();
-        client
-            .proxies()
-            .anime()
+        let anime_type = get_maybe_anime_type().unwrap();
+        proxy
             .write(matrix.into_data_buffer(anime_type).unwrap())
             .unwrap();
         sleep(Duration::from_millis(300));

asusctl/examples/anime-gif.rs

@@ -2,14 +2,16 @@ use std::env;
 use std::path::Path;
 use std::thread::sleep;
 
-use rog_anime::usb::get_anime_type;
+use rog_anime::usb::get_maybe_anime_type;
 use rog_anime::{ActionData, ActionLoader, Sequences};
-use rog_dbus::RogDbusClientBlocking;
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
 
 fn main() {
-    let (client, _) = RogDbusClientBlocking::new().unwrap();
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).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;
@@ -17,7 +19,7 @@ fn main() {
 
     let path = Path::new(&args[1]);
     let brightness = args[2].parse::<f32>().unwrap();
-    let anime_type = get_anime_type().unwrap();
+    let anime_type = get_maybe_anime_type().unwrap();
     let mut seq = Sequences::new(anime_type);
     seq.insert(
         0,
@@ -33,11 +35,7 @@ fn main() {
         for action in seq.iter() {
             if let ActionData::Animation(frames) = action {
                 for frame in frames.frames() {
-                    client
-                        .proxies()
-                        .anime()
-                        .write(frame.frame().clone())
-                        .unwrap();
+                    proxy.write(frame.frame().clone()).unwrap();
                     sleep(frame.delay());
                 }
             }

asusctl/examples/anime-grid.rs

@@ -1,8 +1,9 @@
 use std::convert::TryFrom;
 
-use rog_anime::usb::get_anime_type;
+use rog_anime::usb::get_maybe_anime_type;
 use rog_anime::{AnimeDataBuffer, AnimeGrid};
-use rog_dbus::RogDbusClientBlocking;
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
 
 // In usable data:
 // Top row start at 1, ends at 32
@@ -10,8 +11,10 @@ use rog_dbus::RogDbusClientBlocking;
 // 74w x 36h diagonal used by the windows app
 
 fn main() {
-    let (client, _) = RogDbusClientBlocking::new().unwrap();
-    let anime_type = get_anime_type().unwrap();
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).unwrap();
+
+    let anime_type = get_maybe_anime_type().unwrap();
     let mut matrix = AnimeGrid::new(anime_type);
     let tmp = matrix.get_mut();
 
@@ -43,5 +46,5 @@ fn main() {
 
     let matrix = <AnimeDataBuffer>::try_from(matrix).unwrap();
 
-    client.proxies().anime().write(matrix).unwrap();
+    proxy.write(matrix).unwrap();
 }

asusctl/examples/anime-outline.rs

@@ -1,13 +1,15 @@
-use rog_anime::usb::get_anime_type;
+use rog_anime::usb::get_maybe_anime_type;
 use rog_anime::AnimeDataBuffer;
-use rog_dbus::RogDbusClientBlocking;
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
 
 // In usable data:
 // Top row start at 1, ends at 32
 
 fn main() {
-    let (client, _) = RogDbusClientBlocking::new().unwrap();
-    let anime_type = get_anime_type().unwrap();
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).unwrap();
+    let anime_type = get_maybe_anime_type().unwrap();
     let mut matrix = AnimeDataBuffer::new(anime_type);
     matrix.data_mut()[1] = 100; // start = 1
     for n in matrix.data_mut()[2..32].iter_mut() {
@@ -127,5 +129,5 @@ fn main() {
     matrix.data_mut()[1244] = 100; // end
     println!("{:?}", &matrix);
 
-    client.proxies().anime().write(matrix).unwrap();
+    proxy.write(matrix).unwrap();
 }

asusctl/examples/anime-png.rs

@@ -4,21 +4,23 @@ use std::error::Error;
 use std::path::Path;
 use std::process::exit;
 
-use rog_anime::usb::get_anime_type;
+use rog_anime::usb::get_maybe_anime_type;
 use rog_anime::{AnimeDataBuffer, AnimeImage, Vec2};
-use rog_dbus::RogDbusClientBlocking;
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let (client, _) = RogDbusClientBlocking::new().unwrap();
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).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");
         exit(-1);
     }
 
-    let anime_type = get_anime_type()?;
+    let anime_type = get_maybe_anime_type()?;
     let matrix = AnimeImage::from_png(
         Path::new(&args[1]),
         args[2].parse::<f32>().unwrap(),
@@ -31,11 +33,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         anime_type,
     )?;
 
-    client
-        .proxies()
-        .anime()
-        .write(<AnimeDataBuffer>::try_from(&matrix)?)
-        .unwrap();
+    proxy.write(<AnimeDataBuffer>::try_from(&matrix)?).unwrap();
 
     Ok(())
 }

asusctl/examples/anime-spinning.rs

@@ -7,21 +7,23 @@ use std::process::exit;
 use std::thread::sleep;
 use std::time::Duration;
 
-use rog_anime::usb::get_anime_type;
+use rog_anime::usb::get_maybe_anime_type;
 use rog_anime::{AnimeDataBuffer, AnimeImage, Vec2};
-use rog_dbus::RogDbusClientBlocking;
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let (client, _) = RogDbusClientBlocking::new().unwrap();
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).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");
         exit(-1);
     }
 
-    let anime_type = get_anime_type()?;
+    let anime_type = get_maybe_anime_type()?;
     let mut matrix = AnimeImage::from_png(
         Path::new(&args[1]),
         args[2].parse::<f32>().unwrap(),
@@ -41,11 +43,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         }
         matrix.update();
 
-        client
-            .proxies()
-            .anime()
-            .write(<AnimeDataBuffer>::try_from(&matrix)?)
-            .unwrap();
+        proxy.write(<AnimeDataBuffer>::try_from(&matrix)?).unwrap();
         sleep(Duration::from_micros(500));
     }
 }

asusctl/examples/aura-zoned-breathe.rs

@@ -1,16 +1,17 @@
 //! Using a combination of key-colour array plus a key layout to generate
 //! outputs.
 
-use rog_aura::advanced::LedCode;
 use rog_aura::effects::{AdvancedEffects, Effect};
-use rog_aura::layouts::KeyLayout;
+use rog_aura::keyboard::{KeyLayout, LedCode};
 use rog_aura::Colour;
-use rog_dbus::RogDbusClientBlocking;
+use rog_dbus::zbus_aura::AuraProxyBlocking;
+use zbus::blocking::Connection;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let layout = KeyLayout::default_layout();
 
-    let (client, _) = RogDbusClientBlocking::new().unwrap();
+    let conn = Connection::system().unwrap();
+    let proxy = AuraProxyBlocking::new(&conn).unwrap();
 
     let mut seq = AdvancedEffects::new(true);
 
@@ -32,7 +33,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let zone = Effect::DoomFlicker(rog_aura::effects::DoomFlicker::new(
         LedCode::SingleZone,
-        Colour(200, 110, 0),
+        Colour {
+            r: 200,
+            g: 110,
+            b: 0,
+        },
         100,
         10,
     ));
@@ -58,7 +63,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         seq.next_state(&layout);
         let packets = seq.create_packets();
 
-        client.proxies().led().direct_addressing_raw(packets)?;
+        proxy.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

@@ -4,81 +4,71 @@ use gumdrop::Options;
 use rog_aura::error::Error;
 use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour, Direction, Speed};
 
-#[derive(Options)]
+#[derive(Options, Debug)]
 pub struct LedPowerCommand1 {
     #[options(help = "print help message")]
     pub help: bool,
     #[options(meta = "", help = "Control if LEDs enabled while awake <true/false>")]
     pub awake: Option<bool>,
-    #[options(meta = "", help = "Use with awake option <true/false>")]
-    pub keyboard: Option<bool>,
-    #[options(meta = "", help = "Use with awake option <true/false>")]
-    pub lightbar: Option<bool>,
+    #[options(help = "Use with awake option, if excluded defaults to false")]
+    pub keyboard: bool,
+    #[options(help = "Use with awake option, if excluded defaults to false")]
+    pub lightbar: bool,
     #[options(meta = "", help = "Control boot animations <true/false>")]
     pub boot: Option<bool>,
     #[options(meta = "", help = "Control suspend animations <true/false>")]
     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),
+    #[options(help = "")]
+    Ally(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
     }
 }
@@ -99,6 +89,7 @@ impl FromStr for LedBrightness {
         }
     }
 }
+#[allow(clippy::to_string_trait_impl)]
 impl ToString for LedBrightness {
     fn to_string(&self) -> String {
         let s = match self.level {
@@ -226,29 +217,29 @@ pub struct MultiColourSpeed {
 #[derive(Options)]
 pub enum SetAuraBuiltin {
     #[options(help = "set a single static colour")]
-    Static(SingleColour),
+    Static(SingleColour), // 0
     #[options(help = "pulse between one or two colours")]
-    Breathe(TwoColourSpeed),
+    Breathe(TwoColourSpeed), // 1
     #[options(help = "strobe through all colours")]
-    Strobe(SingleSpeed),
+    RainbowCycle(SingleSpeed), // 2
     #[options(help = "rainbow cycling in one of four directions")]
-    Rainbow(SingleSpeedDirection),
+    RainbowWave(SingleSpeedDirection), // 3
     #[options(help = "rain pattern mimicking raindrops")]
-    Stars(TwoColourSpeed),
+    Stars(TwoColourSpeed), // 4
     #[options(help = "rain pattern of three preset colours")]
-    Rain(SingleSpeed),
+    Rain(SingleSpeed), // 5
     #[options(help = "pressed keys are highlighted to fade")]
-    Highlight(SingleColourSpeed),
+    Highlight(SingleColourSpeed), // 6
     #[options(help = "pressed keys generate horizontal laser")]
-    Laser(SingleColourSpeed),
+    Laser(SingleColourSpeed), // 7
     #[options(help = "pressed keys ripple outwards like a splash")]
-    Ripple(SingleColourSpeed),
+    Ripple(SingleColourSpeed), // 8
     #[options(help = "set a rapid pulse")]
-    Pulse(SingleColour),
+    Pulse(SingleColour), // 10
     #[options(help = "set a vertical line zooming from left")]
-    Comet(SingleColour),
+    Comet(SingleColour), // 11
     #[options(help = "set a wide vertical line zooming from left")]
-    Flash(SingleColour),
+    Flash(SingleColour), // 12
 }
 
 impl Default for SetAuraBuiltin {
@@ -323,14 +314,14 @@ impl From<&SetAuraBuiltin> for AuraEffect {
                 data.mode = AuraModeNum::Breathe;
                 data
             }
-            SetAuraBuiltin::Strobe(x) => {
+            SetAuraBuiltin::RainbowCycle(x) => {
                 let mut data: AuraEffect = x.into();
-                data.mode = AuraModeNum::Strobe;
+                data.mode = AuraModeNum::RainbowCycle;
                 data
             }
-            SetAuraBuiltin::Rainbow(x) => {
+            SetAuraBuiltin::RainbowWave(x) => {
                 let mut data: AuraEffect = x.into();
-                data.mode = AuraModeNum::Rainbow;
+                data.mode = AuraModeNum::RainbowWave;
                 data
             }
             SetAuraBuiltin::Stars(x) => {

asusctl/src/cli_opts.rs

@@ -1,8 +1,10 @@
 use gumdrop::Options;
+use rog_platform::platform::ThrottlePolicy;
 
 use crate::anime_cli::AnimeCommand;
 use crate::aura_cli::{LedBrightness, LedPowerCommand1, LedPowerCommand2, SetAuraBuiltin};
-use crate::profiles_cli::{FanCurveCommand, ProfileCommand};
+use crate::fan_curve_cli::FanCurveCommand;
+use crate::slash_cli::SlashCommand;
 
 #[derive(Default, Options)]
 pub struct CliStart {
@@ -40,10 +42,30 @@ pub enum CliCommand {
     Graphics(GraphicsCommand),
     #[options(name = "anime", help = "Manage AniMe Matrix")]
     Anime(AnimeCommand),
+    #[options(name = "slash", help = "Manage Slash Ledbar")]
+    Slash(SlashCommand),
     #[options(help = "Change bios settings")]
     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<ThrottlePolicy>,
+}
+
 #[derive(Options)]
 pub struct LedModeCommand {
     #[options(help = "print help message")]

asusctl/src/fan_curve_cli.rs

@@ -0,0 +1,49 @@
+use gumdrop::Options;
+use rog_platform::platform::ThrottlePolicy;
+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<ThrottlePolicy>,
+
+    #[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/profiles_cli.rs

@@ -1,52 +0,0 @@
-use gumdrop::Options;
-use rog_profiles::fan_curve_set::CurveData;
-use rog_profiles::{FanCurvePU, Profile};
-
-#[derive(Debug, Clone, Options)]
-pub struct ProfileCommand {
-    #[options(help = "print help message")]
-    pub help: bool,
-    #[options(help = "toggle to next profile in list")]
-    pub next: bool,
-    #[options(help = "list available profiles")]
-    pub list: bool,
-
-    #[options(help = "get profile")]
-    pub profile_get: bool,
-    #[options(meta = "", help = "set the active profile")]
-    pub profile_set: Option<Profile>,
-}
-
-#[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>,
-}

asusctl/src/slash_cli.rs

@@ -0,0 +1,20 @@
+use gumdrop::Options;
+use rog_slash::SlashMode;
+
+#[derive(Options)]
+pub struct SlashCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(help = "Enable the Slash Ledbar")]
+    pub enable: bool,
+    #[options(help = "Ddisable the Slash Ledbar")]
+    pub disable: bool,
+    #[options(meta = "", help = "Set brightness value <0-255>")]
+    pub brightness: Option<u8>,
+    #[options(meta = "", help = "Set interval value <0-255>")]
+    pub interval: Option<u8>,
+    #[options(help = "Set SlashMode (so 'list' for all options)")]
+    pub slash_mode: Option<SlashMode>,
+    #[options(help = "list available animations")]
+    pub list: bool,
+}

asusd-user/Cargo.toml

@@ -1,27 +1,28 @@
 [package]
-name = "daemon-user"
-license = "MPL-2.0"
+name = "asusd-user"
+license.workspace = true
 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"
+readme.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+edition.workspace = true
 
 [[bin]]
 name = "asusd-user"
 path = "src/daemon.rs"
 
+[features]
+default = []
+local_data = []
+
 [dependencies]
 dirs.workspace = true
 smol.workspace = true
 
 # serialisation
 serde.workspace = true
-serde_json.workspace = true
-serde_derive.workspace = true
+ron.workspace = true
 
 rog_anime = { path = "../rog-anime" }
 rog_aura = { path = "../rog-aura" }
@@ -30,7 +31,10 @@ rog_platform = { path = "../rog-platform" }
 config-traits = { path = "../config-traits" }
 
 zbus.workspace = true
+env_logger.workspace = true
 
-# cli and logging
-log.workspace = true
-env_logger.workspace = true
+[dev-dependencies]
+cargo-husky.workspace = true
+
+[package.metadata.cargo-machete]
+ignored = ["serde"]

asusd-user/src/config.rs

@@ -3,10 +3,10 @@ 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::keyboard::LedCode;
 use rog_aura::{Colour, Speed};
-use serde_derive::{Deserialize, Serialize};
+use serde::{Deserialize, Serialize};
 
 use crate::error::Error;
 
@@ -136,8 +136,16 @@ impl Default for ConfigAura {
         let mut seq = AuraSequences::new(false);
         let mut key = Effect::Breathe(Breathe::new(
             LedCode::W,
-            Colour(255, 0, 20),
-            Colour(20, 255, 0),
+            Colour {
+                r: 255,
+                g: 0,
+                b: 20,
+            },
+            Colour {
+                r: 20,
+                g: 255,
+                b: 0,
+            },
             Speed::Low,
         ));
 
@@ -151,20 +159,25 @@ impl Default for ConfigAura {
 
         let key = Effect::Breathe(Breathe::new(
             LedCode::F,
-            Colour(255, 0, 0),
-            Colour(255, 0, 0),
+            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(0, 0, 255)));
+        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(0, 0, 255), 80, 40));
+        let key = Effect::DoomFlicker(DoomFlicker::new(
+            LedCode::N9,
+            Colour { r: 0, g: 0, b: 255 },
+            80,
+            40,
+        ));
         seq.push(key);
 
         Self {

asusd-user/src/ctrl_anime.rs

@@ -7,9 +7,10 @@ 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 zbus::dbus_interface;
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use ron::ser::PrettyConfig;
+use serde::{Deserialize, Serialize};
+use zbus::interface;
 use zbus::zvariant::{ObjectPath, Type};
 
 use crate::config::ConfigAnime;
@@ -22,22 +23,18 @@ pub struct Timer {
     /// 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 {
@@ -65,14 +62,14 @@ pub enum TimeType {
 /// thread and a zbus server behind `Arc<Mutex<T>>`
 pub struct CtrlAnimeInner<'a> {
     sequences: Sequences,
-    client: RogDbusClientBlocking<'a>,
+    client: AnimeProxyBlocking<'a>,
     do_early_return: Arc<AtomicBool>,
 }
 
 impl<'a> CtrlAnimeInner<'static> {
     pub fn new(
         sequences: Sequences,
-        client: RogDbusClientBlocking<'static>,
+        client: AnimeProxyBlocking<'static>,
         do_early_return: Arc<AtomicBool>,
     ) -> Result<Self, Error> {
         Ok(Self {
@@ -97,19 +94,13 @@ impl<'a> CtrlAnimeInner<'static> {
                             return Ok(true); // Do safe exit
                         }
                         self.client
-                            .proxies()
-                            .anime()
                             .write(output)
                             .map_err(|e| AnimeError::Dbus(format!("{}", e)))
                             .map(|_| false)
                     });
                 }
                 ActionData::Image(image) => {
-                    self.client
-                        .proxies()
-                        .anime()
-                        .write(image.as_ref().clone())
-                        .ok();
+                    self.client.write(image.as_ref().clone()).ok();
                 }
                 ActionData::Pause(duration) => {
                     let start = Instant::now();
@@ -136,7 +127,7 @@ impl<'a> CtrlAnimeInner<'static> {
 
 pub struct CtrlAnime<'a> {
     config: Arc<Mutex<ConfigAnime>>,
-    client: RogDbusClientBlocking<'a>,
+    client: AnimeProxyBlocking<'a>,
     inner: Arc<Mutex<CtrlAnimeInner<'a>>>,
     /// Must be the same Atomic as in CtrlAnimeInner
     inner_early_return: Arc<AtomicBool>,
@@ -146,7 +137,7 @@ impl CtrlAnime<'static> {
     pub fn new(
         config: Arc<Mutex<ConfigAnime>>,
         inner: Arc<Mutex<CtrlAnimeInner<'static>>>,
-        client: RogDbusClientBlocking<'static>,
+        client: AnimeProxyBlocking<'static>,
         inner_early_return: Arc<AtomicBool>,
     ) -> Result<Self, Error> {
         Ok(CtrlAnime {
@@ -179,7 +170,7 @@ impl CtrlAnime<'static> {
 // - Do actions
 // - Write config if required
 // - Unset inner_early_return
-#[dbus_interface(name = "org.asuslinux.Daemon")]
+#[interface(name = "org.asuslinux.Daemon")]
 impl CtrlAnime<'static> {
     pub fn insert_asus_gif(
         &mut self,
@@ -209,11 +200,12 @@ impl CtrlAnime<'static> {
             config.anime.push(action);
             config.write();
 
-            let json = serde_json::to_string_pretty(&*config).expect("Parse config to JSON failed");
+            let ron = ron::ser::to_string_pretty(&*config, PrettyConfig::new().depth_limit(4))
+                .expect("Parse config to RON failed");
 
             // Release the inner run loop again
             self.inner_early_return.store(false, Ordering::SeqCst);
-            return Ok(json);
+            return Ok(ron);
         }
         Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
     }
@@ -254,12 +246,11 @@ impl CtrlAnime<'static> {
             config.anime.push(action);
             config.write();
 
-            let json =
-                serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
-
+            let ron = ron::ser::to_string_pretty(&*config, PrettyConfig::new().depth_limit(4))
+                .expect("Parse config to RON failed");
             // Release the inner run loop again
             self.inner_early_return.store(false, Ordering::SeqCst);
-            return Ok(json);
+            return Ok(ron);
         }
         Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
     }
@@ -299,12 +290,11 @@ impl CtrlAnime<'static> {
             config.anime.push(action);
             config.write();
 
-            let json =
-                serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
-
+            let ron = ron::ser::to_string_pretty(&*config, PrettyConfig::new().depth_limit(4))
+                .expect("Parse config to RON failed");
             // Release the inner run loop again
             self.inner_early_return.store(false, Ordering::SeqCst);
-            return Ok(json);
+            return Ok(ron);
         }
         Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
     }
@@ -324,12 +314,11 @@ impl CtrlAnime<'static> {
             config.anime.push(action);
             config.write();
 
-            let json =
-                serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
-
+            let ron = ron::ser::to_string_pretty(&*config, PrettyConfig::new().depth_limit(4))
+                .expect("Parse config to RON failed");
             // Release the inner run loop again
             self.inner_early_return.store(false, Ordering::SeqCst);
-            return Ok(json);
+            return Ok(ron);
         }
         Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
     }
@@ -347,12 +336,11 @@ impl CtrlAnime<'static> {
             }
             config.write();
 
-            let json =
-                serde_json::to_string_pretty(&*config.anime).expect("Parse config to JSON failed");
-
+            let ron = ron::ser::to_string_pretty(&*config, PrettyConfig::new().depth_limit(4))
+                .expect("Parse config to RON failed");
             // Release the inner run loop again
             self.inner_early_return.store(false, Ordering::SeqCst);
-            return Ok(json);
+            return Ok(ron);
         }
         Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
     }
@@ -360,13 +348,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.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.set_enable_display(on).ok();
         }
         Ok(())
     }

asusd-user/src/daemon.rs

@@ -1,17 +1,17 @@
-use std::fs::OpenOptions;
-use std::io::{Read, Write};
+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;
-use rog_user::config::*;
-use rog_user::ctrl_anime::{CtrlAnime, CtrlAnimeInner};
-use rog_user::DBUS_NAME;
+use rog_anime::usb::get_maybe_anime_type;
+use rog_aura::aura_detection::LedSupportData;
+use rog_aura::keyboard::KeyLayout;
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use rog_dbus::zbus_aura::AuraProxyBlocking;
+use rog_dbus::{list_iface_blocking, DBUS_NAME};
 use smol::Executor;
 use zbus::Connection;
 
@@ -29,27 +29,27 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()))
         .init();
 
-    println!("  user daemon v{}", rog_user::VERSION);
+    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 conn = zbus::blocking::Connection::system().unwrap();
 
+    let supported = list_iface_blocking()?;
     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.contains(&"org.asuslinux.Anime".to_string()) {
         if let Some(cfg) = config.active_anime {
-            let anime_type = get_anime_type()?;
+            let anime_type = get_maybe_anime_type()?;
             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));
 
+            let anime_proxy_blocking = AnimeProxyBlocking::new(&conn).unwrap();
             executor
                 .spawn(async move {
                     // Create server
@@ -58,12 +58,21 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
                     // Inner behind mutex required for thread safety
                     let inner = Arc::new(Mutex::new(
-                        CtrlAnimeInner::new(anime, client, early_return.clone()).unwrap(),
+                        CtrlAnimeInner::new(
+                            anime,
+                            anime_proxy_blocking.clone(),
+                            early_return.clone(),
+                        )
+                        .unwrap(),
                     ));
                     // Need new client object for dbus control part
-                    let (client, _) = RogDbusClientBlocking::new().unwrap();
-                    let anime_control =
-                        CtrlAnime::new(anime_config, inner.clone(), client, early_return).unwrap();
+                    let anime_control = CtrlAnime::new(
+                        anime_config,
+                        inner.clone(),
+                        anime_proxy_blocking,
+                        early_return,
+                    )
+                    .unwrap();
                     anime_control.add_to_server(&mut connection).await;
                     loop {
                         if let Ok(inner) = inner.clone().try_lock() {
@@ -78,19 +87,9 @@ 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 = 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 led_support = LedSupportData::get_data("");
 
         let layout = KeyLayout::find_layout(led_support, PathBuf::from(DATA_DIR))
             .map_err(|e| {
@@ -98,22 +97,14 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             })
             .unwrap_or_else(|_| KeyLayout::default_layout());
 
+        let aura_proxy_blocking = AuraProxyBlocking::new(&conn).unwrap();
         executor
             .spawn(async move {
-                // Create server
-                let (client, _) = RogDbusClientBlocking::new().unwrap();
-                // let connection = Connection::session().await.unwrap();
-                // connection.request_name(DBUS_NAME).await.unwrap();
-
                 loop {
                     aura_config.aura.next_state(&layout);
                     let packets = aura_config.aura.create_packets();
 
-                    client
-                        .proxies()
-                        .led()
-                        .direct_addressing_raw(packets)
-                        .unwrap();
+                    aura_proxy_blocking.direct_addressing_raw(packets).unwrap();
                     std::thread::sleep(std::time::Duration::from_millis(33));
                 }
             })

asusd-user/src/lib.rs

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

asusd-user/src/zbus_anime.rs

@@ -1,6 +1,6 @@
-//! # 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
+//! 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`.
 //!
@@ -10,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`]
@@ -21,9 +21,12 @@
 //! …consequently `zbus-xmlgen` did not generate code for the above interfaces.
 #![allow(clippy::too_many_arguments)]
 
-use zbus::dbus_proxy;
+use zbus::proxy;
 
-#[dbus_proxy(interface = "org.asuslinux.Daemon")]
+#[proxy(
+    interface = "org.asuslinux.Daemon",
+    default_path = "/org/asuslinux/Anime"
+)]
 trait Daemon {
     /// InsertAsusGif method
     fn insert_asus_gif(

asusd/Cargo.toml

@@ -1,17 +1,13 @@
 [package]
-name = "daemon"
-license = "MPL-2.0"
+name = "asusd"
+license.workspace = true
 version.workspace = true
-readme = "README.md"
-authors = ["Luke <luke@ljones.dev>"]
-repository = "https://gitlab.com/asus-linux/asus-nb-ctrl"
-homepage = "https://gitlab.com/asus-linux/asus-nb-ctrl"
-description = "A daemon app for ASUS GX502 and similar laptops to control missing features"
-edition = "2021"
-
-[lib]
-name = "daemon"
-path = "src/lib.rs"
+readme.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+description.workspace = true
+edition.workspace = true
 
 [[bin]]
 name = "asusd"
@@ -20,13 +16,18 @@ path = "src/daemon.rs"
 [dependencies]
 config-traits = { path = "../config-traits" }
 rog_anime = { path = "../rog-anime", features = ["dbus"] }
+rog_slash = { path = "../rog-slash", features = ["dbus"] }
 rog_aura = { path = "../rog-aura", features = ["dbus"] }
 rog_platform = { path = "../rog-platform" }
 rog_profiles = { path = "../rog-profiles" }
-rog_dbus = { path = "../rog-dbus" }
+dmi_id = { path = "../dmi-id" }
+futures-lite = "*"
+udev.workspace = true
+inotify.workspace = true
 
-async-trait.workspace = true
+mio.workspace = true
 tokio.workspace = true
+# console-subscriber = "0.2.0"
 
 # cli and logging
 log.workspace = true
@@ -37,11 +38,11 @@ logind-zbus.workspace = true
 
 # serialisation
 serde.workspace = true
-serde_derive.workspace = true
-
-# Device control
-sysfs-class.workspace = true # used for backlight control and baord ID
 
 concat-idents.workspace = true
 
-systemd-zbus = "*"
+[dev-dependencies]
+cargo-husky.workspace = true
+
+[package.metadata.cargo-machete]
+ignored = ["serde"]

asusd/src/config.rs

@@ -0,0 +1,167 @@
+use config_traits::{StdConfig, StdConfigLoad1};
+use rog_platform::cpu::CPUEPP;
+use rog_platform::platform::ThrottlePolicy;
+use serde::{Deserialize, Serialize};
+
+const CONFIG_FILE: &str = "asusd.ron";
+
+#[derive(Deserialize, Serialize, Debug, PartialEq, PartialOrd)]
+pub struct Config {
+    /// Save charge limit for restoring on boot/resume
+    pub charge_control_end_threshold: u8,
+    pub panel_od: bool,
+    pub boot_sound: bool,
+    pub mini_led_mode: bool,
+    pub disable_nvidia_powerd_on_battery: bool,
+    /// An optional command/script to run when power is changed to AC
+    pub ac_command: String,
+    /// An optional command/script to run when power is changed to battery
+    pub bat_command: String,
+    /// Set true if energy_performance_preference should be set if the
+    /// throttle/platform profile is changed
+    pub throttle_policy_linked_epp: bool,
+    /// Which throttle/profile to use on battery power
+    pub throttle_policy_on_battery: ThrottlePolicy,
+    /// Should the throttle policy be set on bat/ac change?
+    pub change_throttle_policy_on_battery: bool,
+    /// Which throttle/profile to use on AC power
+    pub throttle_policy_on_ac: ThrottlePolicy,
+    /// Should the throttle policy be set on bat/ac change?
+    pub change_throttle_policy_on_ac: bool,
+    /// The energy_performance_preference for this throttle/platform profile
+    pub throttle_quiet_epp: CPUEPP,
+    /// The energy_performance_preference for this throttle/platform profile
+    pub throttle_balanced_epp: CPUEPP,
+    /// The energy_performance_preference for this throttle/platform profile
+    pub throttle_performance_epp: CPUEPP,
+    /// Defaults to `None` if not supported
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub ppt_pl1_spl: Option<u8>,
+    /// Defaults to `None` if not supported
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub ppt_pl2_sppt: Option<u8>,
+    /// Defaults to `None` if not supported
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub ppt_fppt: Option<u8>,
+    /// Defaults to `None` if not supported
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub ppt_apu_sppt: Option<u8>,
+    /// Defaults to `None` if not supported
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub ppt_platform_sppt: Option<u8>,
+    /// Defaults to `None` if not supported
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub nv_dynamic_boost: Option<u8>,
+    /// Defaults to `None` if not supported
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub nv_temp_target: Option<u8>,
+    /// Temporary state for AC/Batt
+    #[serde(skip)]
+    pub last_power_plugged: u8,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            charge_control_end_threshold: 100,
+            panel_od: false,
+            boot_sound: false,
+            mini_led_mode: false,
+            disable_nvidia_powerd_on_battery: true,
+            ac_command: Default::default(),
+            bat_command: Default::default(),
+            throttle_policy_linked_epp: true,
+            throttle_policy_on_battery: ThrottlePolicy::Quiet,
+            change_throttle_policy_on_battery: true,
+            throttle_policy_on_ac: ThrottlePolicy::Performance,
+            change_throttle_policy_on_ac: true,
+            throttle_quiet_epp: CPUEPP::Power,
+            throttle_balanced_epp: CPUEPP::BalancePower,
+            throttle_performance_epp: CPUEPP::Performance,
+            ppt_pl1_spl: Default::default(),
+            ppt_pl2_sppt: Default::default(),
+            ppt_fppt: Default::default(),
+            ppt_apu_sppt: Default::default(),
+            ppt_platform_sppt: Default::default(),
+            nv_dynamic_boost: Default::default(),
+            nv_temp_target: Default::default(),
+            last_power_plugged: Default::default(),
+        }
+    }
+}
+
+impl StdConfig for Config {
+    fn new() -> Self {
+        Config {
+            charge_control_end_threshold: 100,
+            disable_nvidia_powerd_on_battery: true,
+            throttle_policy_on_battery: ThrottlePolicy::Quiet,
+            throttle_policy_on_ac: ThrottlePolicy::Performance,
+            ac_command: String::new(),
+            bat_command: String::new(),
+            ..Default::default()
+        }
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+}
+
+impl StdConfigLoad1<Config507> for Config {}
+
+#[derive(Deserialize, Serialize)]
+pub struct Config507 {
+    /// 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,
+    pub platform_policy_linked_epp: bool,
+    pub platform_policy_on_battery: ThrottlePolicy,
+    pub platform_policy_on_ac: ThrottlePolicy,
+    //
+    pub ppt_pl1_spl: Option<u8>,
+    pub ppt_pl2_sppt: Option<u8>,
+    pub ppt_fppt: Option<u8>,
+    pub ppt_apu_sppt: Option<u8>,
+    pub ppt_platform_sppt: Option<u8>,
+    pub nv_dynamic_boost: Option<u8>,
+    pub nv_temp_target: Option<u8>,
+}
+
+impl From<Config507> for Config {
+    fn from(c: Config507) -> Self {
+        Self {
+            charge_control_end_threshold: c.charge_control_end_threshold,
+            panel_od: c.panel_od,
+            boot_sound: false,
+            disable_nvidia_powerd_on_battery: c.disable_nvidia_powerd_on_battery,
+            ac_command: c.ac_command,
+            bat_command: c.bat_command,
+            mini_led_mode: c.mini_led_mode,
+            throttle_policy_linked_epp: true,
+            throttle_policy_on_battery: c.platform_policy_on_battery,
+            change_throttle_policy_on_battery: true,
+            throttle_policy_on_ac: c.platform_policy_on_ac,
+            change_throttle_policy_on_ac: true,
+            throttle_quiet_epp: CPUEPP::Power,
+            throttle_balanced_epp: CPUEPP::BalancePower,
+            throttle_performance_epp: CPUEPP::Performance,
+            ppt_pl1_spl: c.ppt_pl1_spl,
+            ppt_pl2_sppt: c.ppt_pl2_sppt,
+            ppt_fppt: c.ppt_fppt,
+            ppt_apu_sppt: c.ppt_apu_sppt,
+            ppt_platform_sppt: c.ppt_platform_sppt,
+            nv_dynamic_boost: c.nv_dynamic_boost,
+            nv_temp_target: c.nv_temp_target,
+            last_power_plugged: 0,
+        }
+    }
+}

asusd/src/ctrl_anime/config.rs

@@ -1,73 +1,15 @@
 use std::time::Duration;
 
-use config_traits::{StdConfig, StdConfigLoad2};
+use config_traits::{StdConfig, StdConfigLoad};
 use rog_anime::error::AnimeError;
-use rog_anime::{ActionData, ActionLoader, AnimTime, AnimeType, Fade, Vec2};
-use serde_derive::{Deserialize, Serialize};
+use rog_anime::usb::Brightness;
+use rog_anime::{
+    ActionData, ActionLoader, AnimTime, Animations, AnimeType, DeviceState, Fade, Vec2,
+};
+use serde::{Deserialize, Serialize};
 
 const CONFIG_FILE: &str = "anime.ron";
 
-#[derive(Deserialize, Serialize)]
-pub struct AnimeConfigV341 {
-    pub system: Option<ActionLoader>,
-    pub boot: Option<ActionLoader>,
-    pub suspend: Option<ActionLoader>,
-    pub shutdown: Option<ActionLoader>,
-}
-
-impl From<AnimeConfigV341> for AnimeConfig {
-    fn from(c: AnimeConfigV341) -> AnimeConfig {
-        AnimeConfig {
-            system: if let Some(ani) = c.system {
-                vec![ani]
-            } else {
-                vec![]
-            },
-            boot: if let Some(ani) = c.boot {
-                vec![ani]
-            } else {
-                vec![]
-            },
-            wake: if let Some(ani) = c.suspend {
-                vec![ani]
-            } else {
-                vec![]
-            },
-            shutdown: if let Some(ani) = c.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 From<AnimeConfigV352> for AnimeConfig {
-    fn from(c: AnimeConfigV352) -> AnimeConfig {
-        AnimeConfig {
-            system: c.system,
-            boot: c.boot,
-            wake: c.wake,
-            shutdown: c.shutdown,
-            brightness: 1.0,
-            awake_enabled: true,
-            boot_anim_enabled: true,
-        }
-    }
-}
-
 #[derive(Deserialize, Serialize, Default)]
 pub struct AnimeConfigCached {
     pub system: Vec<ActionData>,
@@ -110,15 +52,21 @@ impl AnimeConfigCached {
 }
 
 /// Config for base system actions for the anime display
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, Serialize, Debug, Clone)]
 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,
+    // 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 {
@@ -128,9 +76,15 @@ impl Default for AnimeConfig {
             boot: Vec::new(),
             wake: Vec::new(),
             shutdown: Vec::new(),
-            brightness: 1.0,
-            awake_enabled: true,
-            boot_anim_enabled: true,
+            // 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(),
         }
     }
 }
@@ -140,16 +94,31 @@ impl StdConfig for AnimeConfig {
         Self::create_default()
     }
 
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+
     fn config_dir() -> std::path::PathBuf {
         std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
     }
-
-    fn file_name(&self) -> String {
-        CONFIG_FILE.to_string()
-    }
 }
 
-impl StdConfigLoad2<AnimeConfigV341, AnimeConfigV352> for AnimeConfig {}
+impl StdConfigLoad 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) {
@@ -164,7 +133,7 @@ impl AnimeConfig {
 
     fn create_default() -> Self {
         // create a default config here
-        let config = AnimeConfig {
+        AnimeConfig {
             system: vec![],
             boot: vec![ActionLoader::ImageAnimation {
                 file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
@@ -198,11 +167,7 @@ impl AnimeConfig {
                 brightness: 1.0,
                 time: AnimTime::Infinite,
             }],
-            brightness: 1.0,
-            awake_enabled: true,
-            boot_anim_enabled: true,
-        };
-        config.write();
-        config
+            ..Default::default()
+        }
     }
 }

asusd/src/ctrl_anime/mod.rs

@@ -3,34 +3,55 @@ pub mod config;
 pub mod trait_impls;
 
 use std::convert::TryFrom;
-use std::error::Error;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use std::thread::sleep;
 
 use ::zbus::export::futures_util::lock::Mutex;
+use config_traits::{StdConfig, StdConfigLoad};
 use log::{error, info, warn};
 use rog_anime::error::AnimeError;
-use rog_anime::usb::{get_anime_type, pkt_for_flush, pkts_for_init};
+use rog_anime::usb::{
+    get_maybe_anime_type, pkt_flush, pkt_set_brightness, pkt_set_enable_display,
+    pkt_set_enable_powersave_anim, pkts_for_init, Brightness,
+};
 use rog_anime::{ActionData, AnimeDataBuffer, AnimePacketType, AnimeType};
 use rog_platform::hid_raw::HidRaw;
-use rog_platform::supported::AnimeSupportedFunctions;
 use rog_platform::usb_raw::USBRaw;
 
 use self::config::{AnimeConfig, AnimeConfigCached};
 use crate::error::RogError;
-use crate::GetSupported;
 
-impl GetSupported for CtrlAnime {
-    type A = AnimeSupportedFunctions;
+enum Node {
+    Usb(USBRaw),
+    Hid(HidRaw),
+}
 
-    fn get_supported() -> Self::A {
-        AnimeSupportedFunctions(HidRaw::new("193b").is_ok())
+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,
@@ -42,13 +63,49 @@ 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() -> Result<CtrlAnime, RogError> {
+        let anime_type = get_maybe_anime_type()?;
+        if matches!(anime_type, AnimeType::Unsupported) {
+            info!("No Anime Matrix capable laptop found");
+            return Err(RogError::Anime(AnimeError::NoDevice));
+        }
 
-        info!("Device has an AniMe Matrix display");
+        let usb = USBRaw::new(0x193b).ok();
+        let hid = HidRaw::new("193b").ok();
+        let node = if usb.is_some() {
+            info!("Anime using the USB interface");
+            unsafe { Node::Usb(usb.unwrap_unchecked()) }
+        } else if hid.is_some() {
+            info!("Anime using the HID interface");
+            unsafe { Node::Hid(hid.unwrap_unchecked()) }
+        } else {
+            return Err(RogError::Anime(AnimeError::NoDevice));
+        };
+
+        // TODO: something better to set wakeups disabled
+        // if matches!(node, Node::Usb(_)) {
+        //     if let Ok(mut enumerator) = udev::Enumerator::new() {
+        //         enumerator.match_subsystem("usb").ok();
+        //         enumerator.match_attribute("idProduct", "193b").ok();
+
+        //         if let Ok(mut enumer) = enumerator.scan_devices() {
+        //             if let Some(mut dev) = enumer.next() {
+        //                 dev.set_attribute_value("power/wakeup", "disabled").ok();
+        //             }
+        //         }
+        //     }
+        // }
+
+        let mut config = AnimeConfig::new().load();
+
+        info!("Device has an AniMe Matrix display: {anime_type:?}");
         let mut cache = AnimeConfigCached::default();
-        cache.init_from_config(&config, anime_type)?;
+        if let Err(e) = cache.init_from_config(&config, anime_type) {
+            error!("Trying to cache the Anime Config failed, will reset to default config: {e:?}");
+            config.rename_file_old();
+            config = AnimeConfig::new();
+            config.write();
+        }
 
         let ctrl = CtrlAnime {
             node,
@@ -70,12 +127,21 @@ impl CtrlAnime {
     ///
     /// 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) {
+    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;
         }
 
+        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();
+        }
+
         // Loop rules:
         // - Lock the mutex **only when required**. That is, the lock must be held for
         //   the shortest duration possible.
@@ -113,9 +179,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;
@@ -124,7 +189,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
@@ -148,6 +213,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;
@@ -183,6 +252,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);
@@ -196,7 +273,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;
             }
@@ -206,7 +283,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,522 @@
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
+
+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::{interface, CacheProperties, Connection, SignalContext};
+
+use super::config::AnimeConfig;
+use super::CtrlAnime;
+use crate::error::RogError;
+
+pub const ANIME_ZBUS_NAME: &str = "Anime";
+pub const ANIME_ZBUS_PATH: &str = "/org/asuslinux";
+
+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
+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.
+#[interface(name = "org.asuslinux.Anime")]
+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<()> {
+        self.0
+            .lock()
+            .await
+            .thread_exit
+            .store(true, Ordering::SeqCst);
+        self.0
+            .lock()
+            .await
+            .write_data_buffer(input)
+            .map_err(|err| {
+                warn!("ctrl_anime::run_animation:callback {}", err);
+                err
+            })?;
+        Ok(())
+    }
+
+    /// Set base brightness level
+    #[zbus(property)]
+    async fn brightness(&self) -> Brightness {
+        self.0.lock().await.config.display_brightness
+    }
+
+    /// Set base brightness level
+    #[zbus(property)]
+    async fn set_brightness(&self, brightness: Brightness) {
+        self.0
+            .lock()
+            .await
+            .node
+            .write_bytes(&pkt_set_brightness(brightness))
+            .map_err(|err| {
+                warn!("ctrl_anime::set_brightness {}", err);
+            })
+            .ok();
+        self.0
+            .lock()
+            .await
+            .node
+            .write_bytes(&pkt_set_enable_display(brightness != Brightness::Off))
+            .map_err(|err| {
+                warn!("ctrl_anime::set_brightness {}", err);
+            })
+            .ok();
+
+        self.0.lock().await.config.display_enabled = brightness != Brightness::Off;
+        self.0.lock().await.config.display_brightness = brightness;
+        self.0.lock().await.config.write();
+    }
+
+    #[zbus(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
+    #[zbus(property)]
+    async fn set_builtins_enabled(&self, enabled: bool) {
+        let brightness = self.0.lock().await.config.display_brightness;
+        self.0
+            .lock()
+            .await
+            .node
+            .set_builtins_enabled(enabled, brightness)
+            .map_err(|err| {
+                warn!("ctrl_anime::set_builtins_enabled {}", err);
+            })
+            .ok();
+
+        if !enabled {
+            let anime_type = self.0.lock().await.anime_type;
+            let data = vec![255u8; anime_type.data_length()];
+            if let Ok(tmp) = AnimeDataBuffer::from_vec(anime_type, data).map_err(|err| {
+                warn!("ctrl_anime::set_builtins_enabled {}", err);
+            }) {
+                self.0
+                    .lock()
+                    .await
+                    .node
+                    .write_bytes(tmp.data())
+                    .map_err(|err| {
+                        warn!("ctrl_anime::set_builtins_enabled {}", err);
+                    })
+                    .ok();
+            }
+        }
+
+        self.0.lock().await.config.builtin_anims_enabled = enabled;
+        self.0.lock().await.config.write();
+        if enabled {
+            self.0
+                .lock()
+                .await
+                .thread_exit
+                .store(true, Ordering::Release);
+        }
+    }
+
+    #[zbus(property)]
+    async fn builtin_animations(&self) -> Animations {
+        self.0.lock().await.config.builtin_anims
+    }
+
+    /// Set which builtin animation is used for each stage
+    #[zbus(property)]
+    async fn set_builtin_animations(&self, settings: Animations) {
+        self.0
+            .lock()
+            .await
+            .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();
+        self.0
+            .lock()
+            .await
+            .node
+            .write_bytes(&pkt_set_enable_powersave_anim(true))
+            .map_err(|err| {
+                warn!("ctrl_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        self.0.lock().await.config.display_enabled = true;
+        self.0.lock().await.config.builtin_anims = settings;
+        self.0.lock().await.config.write();
+    }
+
+    #[zbus(property)]
+    async fn enable_display(&self) -> bool {
+        self.0.lock().await.config.display_enabled
+    }
+
+    /// Set whether the AniMe is enabled at all
+    #[zbus(property)]
+    async fn set_enable_display(&self, enabled: bool) {
+        self.0
+            .lock()
+            .await
+            .node
+            .write_bytes(&pkt_set_enable_display(enabled))
+            .map_err(|err| {
+                warn!("ctrl_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        self.0.lock().await.config.display_enabled = enabled;
+        self.0.lock().await.config.write();
+    }
+
+    #[zbus(property)]
+    async fn off_when_unplugged(&self) -> bool {
+        self.0.lock().await.config.off_when_unplugged
+    }
+
+    /// Set if to turn the AniMe Matrix off when external power is unplugged
+    #[zbus(property)]
+    async fn set_off_when_unplugged(&self, enabled: bool) {
+        let manager = get_logind_manager().await;
+        let pow = manager.on_external_power().await.unwrap_or_default();
+
+        self.0
+            .lock()
+            .await
+            .node
+            .write_bytes(&pkt_set_enable_display(!pow && !enabled))
+            .map_err(|err| {
+                warn!("create_sys_event_tasks::off_when_lid_closed {}", err);
+            })
+            .ok();
+
+        self.0.lock().await.config.off_when_unplugged = enabled;
+        self.0.lock().await.config.write();
+    }
+
+    #[zbus(property)]
+    async fn off_when_suspended(&self) -> bool {
+        self.0.lock().await.config.off_when_suspended
+    }
+
+    /// Set if to turn the AniMe Matrix off when the laptop is suspended
+    #[zbus(property)]
+    async fn set_off_when_suspended(&self, enabled: bool) {
+        self.0.lock().await.config.off_when_suspended = enabled;
+        self.0.lock().await.config.write();
+    }
+
+    #[zbus(property)]
+    async fn off_when_lid_closed(&self) -> bool {
+        self.0.lock().await.config.off_when_lid_closed
+    }
+
+    /// Set if to turn the AniMe Matrix off when the lid is closed
+    #[zbus(property)]
+    async fn set_off_when_lid_closed(&self, enabled: bool) {
+        let manager = get_logind_manager().await;
+        let lid = manager.lid_closed().await.unwrap_or_default();
+
+        self.0
+            .lock()
+            .await
+            .node
+            .write_bytes(&pkt_set_enable_display(lid && !enabled))
+            .map_err(|err| {
+                warn!("create_sys_event_tasks::off_when_lid_closed {}", err);
+            })
+            .ok();
+
+        self.0.lock().await.config.off_when_lid_closed = enabled;
+        self.0.lock().await.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 {
+            self.0
+                .lock()
+                .await
+                .thread_exit
+                .store(true, Ordering::SeqCst);
+            CtrlAnime::run_thread(
+                self.0.clone(),
+                self.0.lock().await.cache.system.clone(),
+                false,
+            )
+            .await;
+        }
+    }
+
+    /// Get the device state as stored by asusd
+    // #[zbus(property)]
+    async fn device_state(&self) -> DeviceState {
+        DeviceState::from(&self.0.lock().await.config)
+    }
+}
+
+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 config = inner.lock().await.config.clone();
+                    if config.display_enabled {
+                        inner
+                            .lock()
+                            .await
+                            .thread_exit
+                            .store(true, Ordering::Release); // ensure clean slate
+
+                        inner
+                            .lock()
+                            .await
+                            .node
+                            .write_bytes(&pkt_set_enable_display(
+                                !(sleeping && config.off_when_suspended),
+                            ))
+                            .map_err(|err| {
+                                warn!("create_sys_event_tasks::off_when_suspended {}", err);
+                            })
+                            .ok();
+
+                        if config.builtin_anims_enabled {
+                            inner
+                                .lock()
+                                .await
+                                .node
+                                .write_bytes(&pkt_set_enable_powersave_anim(
+                                    !(sleeping && config.off_when_suspended),
+                                ))
+                                .map_err(|err| {
+                                    warn!("create_sys_event_tasks::off_when_suspended {}", err);
+                                })
+                                .ok();
+                        } else if !sleeping && !config.builtin_anims_enabled {
+                            // Run custom wake animation
+                            inner
+                                .lock()
+                                .await
+                                .node
+                                .write_bytes(&pkt_set_enable_powersave_anim(false))
+                                .ok(); // ensure builtins are disabled
+
+                            CtrlAnime::run_thread(
+                                inner.clone(),
+                                inner.lock().await.cache.wake.clone(),
+                                true,
+                            )
+                            .await;
+                        }
+                    }
+                }
+            },
+            move |shutting_down| {
+                // on_shutdown
+                let inner = inner2.clone();
+                async move {
+                    let AnimeConfig {
+                        display_enabled,
+                        builtin_anims_enabled,
+                        ..
+                    } = inner.lock().await.config;
+                    if display_enabled && !builtin_anims_enabled {
+                        if shutting_down {
+                            CtrlAnime::run_thread(
+                                inner.clone(),
+                                inner.lock().await.cache.shutdown.clone(),
+                                true,
+                            )
+                            .await;
+                        } else {
+                            CtrlAnime::run_thread(
+                                inner.clone(),
+                                inner.lock().await.cache.boot.clone(),
+                                true,
+                            )
+                            .await;
+                        }
+                    }
+                }
+            },
+            move |lid_closed| {
+                let inner = inner3.clone();
+                // on lid change
+                async move {
+                    let AnimeConfig {
+                        off_when_lid_closed,
+                        builtin_anims_enabled,
+                        ..
+                    } = inner.lock().await.config;
+                    if off_when_lid_closed {
+                        if builtin_anims_enabled {
+                            inner
+                                .lock()
+                                .await
+                                .node
+                                .write_bytes(&pkt_set_enable_powersave_anim(!lid_closed))
+                                .map_err(|err| {
+                                    warn!("create_sys_event_tasks::off_when_suspended {}", err);
+                                })
+                                .ok();
+                        }
+                        inner
+                            .lock()
+                            .await
+                            .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 AnimeConfig {
+                        off_when_unplugged,
+                        builtin_anims_enabled,
+                        brightness_on_battery,
+                        ..
+                    } = inner.lock().await.config;
+                    if off_when_unplugged {
+                        if builtin_anims_enabled {
+                            inner
+                                .lock()
+                                .await
+                                .node
+                                .write_bytes(&pkt_set_enable_powersave_anim(power_plugged))
+                                .map_err(|err| {
+                                    warn!("create_sys_event_tasks::off_when_suspended {}", err);
+                                })
+                                .ok();
+                        }
+                        inner
+                            .lock()
+                            .await
+                            .node
+                            .write_bytes(&pkt_set_enable_display(power_plugged))
+                            .map_err(|err| {
+                                warn!("create_sys_event_tasks::off_when_unplugged {}", err);
+                            })
+                            .ok();
+                    } else {
+                        inner
+                            .lock()
+                            .await
+                            .node
+                            .write_bytes(&pkt_set_brightness(brightness_on_battery))
+                            .map_err(|err| {
+                                warn!("create_sys_event_tasks::off_when_unplugged {}", err);
+                            })
+                            .ok();
+                    }
+                }
+            },
+        )
+        .await;
+
+        Ok(())
+    }
+}
+
+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,212 +1,75 @@
-use std::collections::{BTreeMap, HashSet};
+use std::collections::BTreeMap;
 
 use config_traits::{StdConfig, StdConfigLoad};
-use rog_aura::aura_detection::{LaptopLedData, ASUS_KEYBOARD_DEVICES};
-use rog_aura::usb::{AuraDev1866, AuraDev19b6, 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 log::{debug, info, warn};
+use rog_aura::aura_detection::LedSupportData;
+use rog_aura::keyboard::LaptopAuraPower;
+use rog_aura::{
+    AuraDeviceType, AuraEffect, AuraModeNum, AuraZone, Direction, LedBrightness, Speed, GRADIENT,
+};
+use serde::{Deserialize, Serialize};
 
-const CONFIG_FILE: &str = "aura.ron";
+use crate::error::RogError;
 
-/// Enable/disable LED control in various states such as
-/// when the device is awake, suspended, shutting down or
-/// booting.
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub enum AuraPowerConfig {
-    AuraDevTuf(HashSet<AuraDevTuf>),
-    AuraDev1866(HashSet<AuraDev1866>),
-    AuraDev19b6(HashSet<AuraDev19b6>),
-}
-
-impl AuraPowerConfig {
-    /// Invalid for TUF laptops
-    pub fn to_bytes(control: &Self) -> [u8; 3] {
-        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)
-            }
-        }
-    }
-
-    pub fn to_tuf_bool_array(control: &Self) -> Option<[bool; 5]> {
-        if let Self::AuraDevTuf(c) = control {
-            return Some([
-                true,
-                c.contains(&AuraDevTuf::Boot),
-                c.contains(&AuraDevTuf::Awake),
-                c.contains(&AuraDevTuf::Sleep),
-                c.contains(&AuraDevTuf::Keyboard),
-            ]);
-        }
-
-        if let Self::AuraDev1866(c) = control {
-            return Some([
-                true,
-                c.contains(&AuraDev1866::Boot),
-                c.contains(&AuraDev1866::Awake),
-                c.contains(&AuraDev1866::Sleep),
-                c.contains(&AuraDev1866::Keyboard),
-            ]);
-        }
-
-        None
-    }
-
-    pub fn set_tuf(&mut self, power: AuraDevTuf, on: bool) {
-        if let Self::AuraDevTuf(p) = self {
-            if on {
-                p.insert(power);
-            } else {
-                p.remove(&power);
-            }
-        }
-    }
-
-    pub fn set_0x1866(&mut self, power: AuraDev1866, on: bool) {
-        if let Self::AuraDev1866(p) = self {
-            if on {
-                p.insert(power);
-            } else {
-                p.remove(&power);
-            }
-        }
-    }
-
-    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);
-            }
-        }
-    }
-}
-
-impl From<&AuraPowerConfig> for AuraPowerDev {
-    fn from(config: &AuraPowerConfig) -> Self {
-        match config {
-            AuraPowerConfig::AuraDevTuf(d) => AuraPowerDev {
-                tuf: d.iter().copied().collect(),
-                x1866: vec![],
-                x19b6: vec![],
-            },
-            AuraPowerConfig::AuraDev1866(d) => AuraPowerDev {
-                tuf: vec![],
-                x1866: d.iter().copied().collect(),
-                x19b6: vec![],
-            },
-            AuraPowerConfig::AuraDev19b6(d) => AuraPowerDev {
-                tuf: vec![],
-                x1866: vec![],
-                x19b6: d.iter().copied().collect(),
-            },
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, Serialize, Default, Debug, Clone)]
 // #[serde(default)]
 pub struct AuraConfig {
+    pub config_name: String,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub ally_fix: Option<bool>,
     pub brightness: LedBrightness,
     pub current_mode: AuraModeNum,
     pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
     pub multizone: Option<BTreeMap<AuraModeNum, Vec<AuraEffect>>>,
     pub multizone_on: bool,
-    pub enabled: AuraPowerConfig,
-}
-
-impl Default for AuraConfig {
-    fn default() -> Self {
-        let mut prod_id = AuraDevice::Unknown;
-        for prod in &ASUS_KEYBOARD_DEVICES {
-            if HidRaw::new(prod).is_ok() {
-                prod_id = AuraDevice::from(*prod);
-                break;
-            }
-        }
-
-        if prod_id == AuraDevice::Unknown {
-            if let Ok(p) = KeyboardLed::new() {
-                if p.has_kbd_rgb_mode() {
-                    prod_id = AuraDevice::Tuf;
-                }
-            }
-        }
-
-        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 {
-            AuraPowerConfig::AuraDevTuf(HashSet::from([
-                AuraDevTuf::Awake,
-                AuraDevTuf::Boot,
-                AuraDevTuf::Sleep,
-                AuraDevTuf::Keyboard,
-            ]))
-        } else {
-            AuraPowerConfig::AuraDev1866(HashSet::from([
-                AuraDev1866::Awake,
-                AuraDev1866::Boot,
-                AuraDev1866::Sleep,
-                AuraDev1866::Keyboard,
-                AuraDev1866::Lightbar,
-            ]))
-        };
-
-        AuraConfig {
-            brightness: LedBrightness::Med,
-            current_mode: AuraModeNum::Static,
-            builtins: BTreeMap::new(),
-            multizone: None,
-            multizone_on: false,
-            enabled,
-        }
-    }
+    pub enabled: LaptopAuraPower,
 }
 
 impl StdConfig for AuraConfig {
+    /// Detect the keyboard type and load from default DB if data available
     fn new() -> Self {
-        Self::create_default(&LaptopLedData::get_data())
+        panic!("This should not be used");
+    }
+
+    fn file_name(&self) -> String {
+        if self.config_name.is_empty() {
+            panic!("Config file name should not be empty");
+        }
+        self.config_name.to_owned()
     }
 
     fn config_dir() -> std::path::PathBuf {
         std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
     }
-
-    fn file_name(&self) -> String {
-        CONFIG_FILE.to_string()
-    }
 }
 
 impl StdConfigLoad for AuraConfig {}
 
 impl AuraConfig {
-    fn create_default(support_data: &LaptopLedData) -> Self {
+    /// Detect the keyboard type and load from default DB if data available
+    pub fn new(prod_id: &str) -> Self {
+        info!("Setting up AuraConfig for {prod_id:?}");
         // create a default config here
-        let mut config = AuraConfig::default();
+        let device_type = AuraDeviceType::from(prod_id);
+        if device_type == AuraDeviceType::Unknown {
+            warn!("idProduct:{prod_id:?} is unknown");
+        }
+        let support_data = LedSupportData::get_data(prod_id);
+        let enabled = LaptopAuraPower::new(device_type, &support_data);
+        let mut config = AuraConfig {
+            config_name: format!("aura_{prod_id}.ron"),
+            ally_fix: None,
+            brightness: LedBrightness::Med,
+            current_mode: AuraModeNum::Static,
+            builtins: BTreeMap::new(),
+            multizone: None,
+            multizone_on: false,
+            enabled,
+        };
 
         for n in &support_data.basic_modes {
+            debug!("creating default for {n}");
             config
                 .builtins
                 .insert(*n, AuraEffect::default_with_mode(*n));
@@ -232,7 +95,6 @@ impl AuraConfig {
                 }
             }
         }
-        config.write();
         config
     }
 
@@ -273,20 +135,59 @@ impl AuraConfig {
         }
         None
     }
+
+    /// Create a default for the `current_mode` if multizone and no config
+    /// exists.
+    pub(super) fn create_multizone_default(
+        &mut self,
+        supported_data: &LedSupportData,
+    ) -> Result<(), RogError> {
+        let mut default = vec![];
+        for (i, tmp) in supported_data.basic_zones.iter().enumerate() {
+            default.push(AuraEffect {
+                mode: self.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.multizone.as_mut() {
+            multizones.insert(self.current_mode, default);
+        } else {
+            let mut tmp = BTreeMap::new();
+            tmp.insert(self.current_mode, default);
+            self.multizone = Some(tmp);
+        }
+        Ok(())
+    }
 }
 
 #[cfg(test)]
 mod tests {
-    use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour};
+    use rog_aura::keyboard::AuraPowerState;
+    use rog_aura::{
+        AuraEffect, AuraModeNum, AuraZone, Colour, Direction, LedBrightness, PowerZones, Speed,
+    };
 
     use super::AuraConfig;
 
     #[test]
     fn set_multizone_4key_config() {
-        let mut config = AuraConfig::default();
+        std::env::set_var("BOARD_NAME", "");
+        let mut config = AuraConfig::new("19b6");
 
         let effect = AuraEffect {
-            colour1: Colour(0xff, 0x00, 0xff),
+            colour1: Colour {
+                r: 0xff,
+                g: 0x00,
+                b: 0xff,
+            },
             zone: AuraZone::Key1,
             ..Default::default()
         };
@@ -295,21 +196,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()
         };
@@ -321,15 +234,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();
+        std::env::set_var("BOARD_NAME", "");
+        let mut config = AuraConfig::new("19b6");
 
         let effect = AuraEffect {
             zone: AuraZone::Key1,
@@ -373,4 +315,66 @@ mod tests {
         let sta = res.get(&AuraModeNum::Pulse).unwrap();
         assert_eq!(sta.len(), 1);
     }
+
+    #[test]
+    fn verify_0x1866_g531i() {
+        std::env::set_var("BOARD_NAME", "G513I");
+        let mut config = AuraConfig::new("1866");
+
+        assert_eq!(config.brightness, LedBrightness::Med);
+        assert_eq!(config.builtins.len(), 5);
+        assert_eq!(
+            config.builtins.first_entry().unwrap().get(),
+            &AuraEffect {
+                mode: AuraModeNum::Static,
+                zone: AuraZone::None,
+                colour1: Colour { r: 166, g: 0, b: 0 },
+                colour2: Colour { r: 0, g: 0, b: 0 },
+                speed: Speed::Med,
+                direction: Direction::Right
+            }
+        );
+        assert_eq!(config.enabled.states.len(), 1);
+        assert_eq!(
+            config.enabled.states[0],
+            AuraPowerState {
+                zone: PowerZones::KeyboardAndLightbar,
+                boot: true,
+                awake: true,
+                sleep: true,
+                shutdown: true
+            }
+        );
+    }
+
+    #[test]
+    fn verify_0x19b6_g634j() {
+        std::env::set_var("BOARD_NAME", "G634J");
+        let mut config = AuraConfig::new("19b6");
+
+        assert_eq!(config.brightness, LedBrightness::Med);
+        assert_eq!(config.builtins.len(), 12);
+        assert_eq!(
+            config.builtins.first_entry().unwrap().get(),
+            &AuraEffect {
+                mode: AuraModeNum::Static,
+                zone: AuraZone::None,
+                colour1: Colour { r: 166, g: 0, b: 0 },
+                colour2: Colour { r: 0, g: 0, b: 0 },
+                speed: Speed::Med,
+                direction: Direction::Right
+            }
+        );
+        assert_eq!(config.enabled.states.len(), 4);
+        assert_eq!(
+            config.enabled.states[0],
+            AuraPowerState {
+                zone: PowerZones::Keyboard,
+                boot: true,
+                awake: true,
+                sleep: true,
+                shutdown: true
+            }
+        );
+    }
 }

asusd/src/ctrl_aura/controller.rs

@@ -0,0 +1,573 @@
+use std::collections::HashSet;
+
+use config_traits::{StdConfig, StdConfigLoad};
+use dmi_id::DMIID;
+use inotify::Inotify;
+use log::{debug, info, warn};
+use rog_aura::aura_detection::LedSupportData;
+use rog_aura::keyboard::{LedUsbPackets, UsbPackets};
+use rog_aura::usb::{LED_APPLY, LED_SET};
+use rog_aura::{AuraDeviceType, AuraEffect, LedBrightness, PowerZones, LED_MSG_LEN};
+use rog_platform::hid_raw::HidRaw;
+use rog_platform::keyboard_led::KeyboardBacklight;
+use udev::Device;
+use zbus::zvariant::OwnedObjectPath;
+use zbus::Connection;
+
+use super::config::AuraConfig;
+use crate::ctrl_aura::manager::{dbus_path_for_dev, dbus_path_for_tuf, start_tasks};
+use crate::ctrl_aura::trait_impls::CtrlAuraZbus;
+use crate::error::RogError;
+use crate::CtrlTask;
+
+#[derive(Debug)]
+pub enum LEDNode {
+    /// Brightness and/or TUF RGB controls
+    KbdLed(KeyboardBacklight),
+    /// Raw HID handle
+    Rog(Option<KeyboardBacklight>, HidRaw),
+}
+
+impl LEDNode {
+    // TODO: move various methods upwards to this
+    pub fn set_brightness(&self, value: u8) -> Result<(), RogError> {
+        match self {
+            LEDNode::KbdLed(k) => k.set_brightness(value)?,
+            LEDNode::Rog(k, r) => {
+                if let Some(k) = k {
+                    k.set_brightness(value)?;
+                    let x = k.get_brightness()?;
+                    if x != value {
+                        debug!(
+                            "Kernel brightness control didn't read back correct value, setting \
+                             with raw hid"
+                        );
+                        r.write_bytes(&[0x5a, 0xba, 0xc5, 0xc4, value])?;
+                    }
+                } else {
+                    debug!("No brightness control found, trying raw write");
+                    r.write_bytes(&[0x5a, 0xba, 0xc5, 0xc4, value])?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub fn get_brightness(&self) -> Result<u8, RogError> {
+        Ok(match self {
+            LEDNode::KbdLed(k) => k.get_brightness()?,
+            LEDNode::Rog(k, _) => {
+                if let Some(k) = k {
+                    k.get_brightness()?
+                } else {
+                    debug!("No brightness control found");
+                    return Err(RogError::MissingFunction(
+                        "No keyboard brightness control found".to_string(),
+                    ));
+                }
+            }
+        })
+    }
+
+    pub fn monitor_brightness(&self) -> Result<Inotify, RogError> {
+        Ok(match self {
+            LEDNode::KbdLed(k) => k.monitor_brightness()?,
+            LEDNode::Rog(k, _) => {
+                if let Some(k) = k {
+                    k.monitor_brightness()?
+                } else {
+                    debug!("No brightness control found");
+                    return Err(RogError::MissingFunction(
+                        "No keyboard brightness control found".to_string(),
+                    ));
+                }
+            }
+        })
+    }
+
+    pub fn has_brightness_control(&self) -> bool {
+        match self {
+            LEDNode::KbdLed(k) => k.has_brightness(),
+            LEDNode::Rog(k, _) => {
+                if let Some(k) = k {
+                    k.has_brightness()
+                } else {
+                    false
+                }
+            }
+        }
+    }
+}
+
+/// Individual controller for one Aura device
+pub struct CtrlKbdLed {
+    pub led_type: AuraDeviceType,
+    pub led_node: LEDNode,
+    pub supported_data: LedSupportData, // TODO: is storing this really required?
+    pub per_key_mode_active: bool,
+    pub config: AuraConfig,
+    pub dbus_path: OwnedObjectPath,
+}
+
+impl CtrlKbdLed {
+    pub fn add_to_dbus_and_start(
+        self,
+        interfaces: &mut HashSet<OwnedObjectPath>,
+        conn: Connection,
+    ) -> Result<(), RogError> {
+        let dbus_path = self.dbus_path.clone();
+        let dbus_path_cpy = self.dbus_path.clone();
+        info!(
+            "AuraManager starting device at: {:?}, {:?}",
+            dbus_path, self.led_type
+        );
+        let conn_copy = conn.clone();
+        let sig_ctx1 = CtrlAuraZbus::signal_context(&conn_copy)?;
+        let sig_ctx2 = CtrlAuraZbus::signal_context(&conn_copy)?;
+        let zbus = CtrlAuraZbus::new(self, sig_ctx1);
+        tokio::spawn(
+            async move { start_tasks(zbus, conn_copy.clone(), sig_ctx2, dbus_path).await },
+        );
+        interfaces.insert(dbus_path_cpy);
+        Ok(())
+    }
+
+    /// Build and init a `CtrlKbdLed` from a udev device. Maybe.
+    /// This will initialise the config also.
+    pub fn maybe_device(
+        device: Device,
+        interfaces: &mut HashSet<OwnedObjectPath>,
+    ) -> Result<Option<Self>, RogError> {
+        // usb_device gives us a product and vendor ID
+        if let Some(usb_device) = device.parent_with_subsystem_devtype("usb", "usb_device")? {
+            let dbus_path = dbus_path_for_dev(&usb_device).unwrap_or_default();
+            if interfaces.contains(&dbus_path) {
+                debug!("Already a ctrl at {dbus_path:?}, ignoring this end-point");
+                return Ok(None);
+            }
+
+            // The asus_wmi driver latches MCU that controls the USB endpoints
+            if let Some(parent) = device.parent() {
+                if let Some(driver) = parent.driver() {
+                    // There is a tree of devices added so filter by driver
+                    if driver != "asus" {
+                        return Ok(None);
+                    }
+                } else {
+                    return Ok(None);
+                }
+            }
+            // Device is something like 002, while its parent is the MCU
+            // Think of it like the device is an endpoint of the USB device attached
+            let mut prod_id = String::new();
+            if let Some(usb_id) = usb_device.attribute_value("idProduct") {
+                prod_id = usb_id.to_string_lossy().to_string();
+                let aura_device = AuraDeviceType::from(prod_id.as_str());
+                if aura_device == AuraDeviceType::Unknown {
+                    log::debug!("Unknown or invalid device: {usb_id:?}, skipping");
+                    return Ok(None);
+                }
+            }
+
+            let dev_node = if let Some(dev_node) = usb_device.devnode() {
+                dev_node
+            } else {
+                debug!("Device has no devnode, skipping");
+                return Ok(None);
+            };
+            info!("AuraControl found device at: {:?}", dev_node);
+            let dev = HidRaw::from_device(device)?;
+            let mut controller = Self::from_hidraw(dev, dbus_path.clone())?;
+            controller.config = Self::load_and_update_config(&prod_id);
+            interfaces.insert(dbus_path);
+            return Ok(Some(controller));
+        }
+        Ok(None)
+    }
+
+    pub fn find_all() -> Result<Vec<Self>, RogError> {
+        info!("Searching for all Aura devices");
+        let mut devices = Vec::new();
+        let mut interfaces = HashSet::new(); // track and ensure we use only one hidraw per prod_id
+
+        let mut enumerator = udev::Enumerator::new().map_err(|err| {
+            warn!("{}", err);
+            err
+        })?;
+
+        enumerator.match_subsystem("hidraw").map_err(|err| {
+            warn!("{}", err);
+            err
+        })?;
+
+        for end_point in enumerator.scan_devices()? {
+            // maybe?
+            if let Some(device) = Self::maybe_device(end_point, &mut interfaces)? {
+                devices.push(device);
+            }
+        }
+
+        // Check for a TUF laptop LED. Assume there is only ever one.
+        if let Ok(kbd_backlight) = KeyboardBacklight::new() {
+            if kbd_backlight.has_kbd_rgb_mode() {
+                // Extra sure double-check that this isn't a laptop with crap
+                // ACPI with borked return on the TUF rgb methods
+                let dmi = DMIID::new().unwrap_or_default();
+                info!("Found a TUF with product family: {}", dmi.product_family);
+                info!("and board name: {}", dmi.board_name);
+
+                if dmi.product_family.contains("TUF") {
+                    info!("AuraControl found a TUF laptop keyboard");
+                    let ctrl = CtrlKbdLed {
+                        led_type: AuraDeviceType::LaptopTuf,
+                        led_node: LEDNode::KbdLed(kbd_backlight),
+                        supported_data: LedSupportData::get_data("tuf"),
+                        per_key_mode_active: false,
+                        config: Self::load_and_update_config("tuf"),
+                        dbus_path: dbus_path_for_tuf(),
+                    };
+                    devices.push(ctrl);
+                }
+            }
+        } else {
+            let dmi = DMIID::new().unwrap_or_default();
+            warn!("No asus::kbd_backlight found for {} ??", dmi.product_family);
+        }
+
+        info!("Found {} Aura devices", devices.len());
+
+        Ok(devices)
+    }
+
+    /// The generated data from this function has a default config. This config
+    /// should be overwritten. The reason for the default config is because
+    /// of async issues between this and udev/hidraw
+    fn from_hidraw(device: HidRaw, dbus_path: OwnedObjectPath) -> Result<Self, RogError> {
+        let rgb_led = KeyboardBacklight::new()
+            .map_err(|e| {
+                log::error!(
+                    "{} is missing a keyboard backlight brightness control: {e:?}",
+                    device.prod_id()
+                );
+            })
+            .ok();
+        let prod_id = AuraDeviceType::from(device.prod_id());
+        if prod_id == AuraDeviceType::Unknown {
+            log::error!("{} is AuraDevice::Unknown", device.prod_id());
+            return Err(RogError::NoAuraNode);
+        }
+
+        // New loads data from the DB also
+        // let config = Self::init_config(prod_id, data);
+
+        let data = LedSupportData::get_data(device.prod_id());
+        let ctrl = CtrlKbdLed {
+            led_type: prod_id,
+            led_node: LEDNode::Rog(rgb_led, device),
+            supported_data: data.clone(),
+            per_key_mode_active: false,
+            config: AuraConfig::default(),
+            dbus_path,
+        };
+        Ok(ctrl)
+    }
+
+    /// Reload the config from disk then verify and update it if required
+    fn load_and_update_config(prod_id: &str) -> AuraConfig {
+        // New loads data from the DB also
+        let mut config_init = AuraConfig::new(prod_id);
+        // config_init.set_filename(prod_id);
+        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;
+
+        // Check the powerzones and replace, if the len is different then the support
+        // file was updated
+        if config_loaded.enabled.states.len() != config_init.enabled.states.len() {
+            config_loaded.enabled.states = config_init.enabled.states;
+        }
+
+        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();
+                    let data = LedSupportData::get_data(prod_id);
+                    // only reuse a zone mode if the mode is supported
+                    for mode in loaded {
+                        if data.basic_modes.contains(&mode.mode) {
+                            new_set.push(mode.clone());
+                        }
+                    }
+                    *mode.1 = new_set;
+                }
+            }
+            *multizone_loaded = multizone_init;
+        }
+
+        config_loaded
+    }
+
+    pub(super) fn fix_ally_power(&mut self) -> Result<(), RogError> {
+        if self.led_type == AuraDeviceType::Ally {
+            if let LEDNode::Rog(_, hid_raw) = &self.led_node {
+                if let Some(fix) = self.config.ally_fix.as_mut() {
+                    if !*fix {
+                        let msg = [0x5d, 0xbd, 0x01, 0xff, 0xff, 0xff, 0xff];
+                        hid_raw.write_bytes(&msg)?;
+                        info!("Reset Ally power settings to base");
+                    }
+                    *fix = true;
+                }
+                self.config.write();
+            }
+        }
+        Ok(())
+    }
+
+    /// 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 {
+            // TODO: tuf bool array
+            let buf = self.config.enabled.to_bytes(self.led_type);
+            platform.set_kbd_rgb_state(&buf)?;
+        } else if let LEDNode::Rog(_, hid_raw) = &self.led_node {
+            if let Some(p) = self.config.enabled.states.first() {
+                if p.zone == PowerZones::Ally {
+                    let msg = [0x5d, 0xd1, 0x09, 0x01, p.new_to_byte() as u8, 0x0, 0x0];
+                    hid_raw.write_bytes(&msg)?;
+                    return Ok(());
+                }
+            }
+
+            let bytes = self.config.enabled.to_bytes(self.led_type);
+            let msg = [0x5d, 0xbd, 0x01, bytes[0], bytes[1], bytes[2], bytes[3]];
+            hid_raw.write_bytes(&msg)?;
+        }
+        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(())
+    }
+
+    /// Write the AuraEffect to the device
+    pub fn write_effect_and_apply(&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.config.create_multizone_default(&self.supported_data)?;
+            }
+
+            if let Some(multizones) = self.config.multizone.as_mut() {
+                if let Some(set) = multizones.get(&mode) {
+                    for mode in set.clone() {
+                        self.write_effect_and_apply(&mode)?;
+                    }
+                }
+            }
+        } else {
+            let mode = self.config.current_mode;
+            if let Some(effect) = self.config.builtins.get(&mode).cloned() {
+                self.write_effect_and_apply(&effect)?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rog_aura::aura_detection::LedSupportData;
+    use rog_aura::{AuraDeviceType, AuraModeNum, AuraZone, PowerZones};
+    use rog_platform::hid_raw::HidRaw;
+    use rog_platform::keyboard_led::KeyboardBacklight;
+    use zbus::zvariant::OwnedObjectPath;
+
+    use super::CtrlKbdLed;
+    use crate::ctrl_aura::config::AuraConfig;
+    use crate::ctrl_aura::controller::LEDNode;
+
+    #[test]
+    #[ignore = "Unable to run in CI as the HIDRAW device is required"]
+    fn create_multizone_if_no_config() {
+        // Checking to ensure set_mode errors when unsupported modes are tried
+        let config = AuraConfig::new("19b6");
+        let supported_basic_modes = LedSupportData {
+            device_name: String::new(),
+            product_id: String::new(),
+            layout_name: "ga401".to_owned(),
+            basic_modes: vec![AuraModeNum::Static],
+            basic_zones: vec![],
+            advanced_type: rog_aura::keyboard::AdvancedAuraType::None,
+            power_zones: vec![PowerZones::Keyboard, PowerZones::RearGlow],
+        };
+        let mut controller = CtrlKbdLed {
+            led_type: AuraDeviceType::LaptopPost2021,
+            led_node: LEDNode::Rog(
+                Some(KeyboardBacklight::default()),
+                HidRaw::new("19b6").unwrap(),
+            ),
+            supported_data: supported_basic_modes,
+            per_key_mode_active: false,
+            config,
+            dbus_path: OwnedObjectPath::default(),
+        };
+
+        assert!(controller.config.multizone.is_none());
+        assert!(controller
+            .config
+            .create_multizone_default(&controller.supported_data)
+            .is_err());
+        assert!(controller.config.multizone.is_none());
+
+        controller.supported_data.basic_zones.push(AuraZone::Key1);
+        controller.supported_data.basic_zones.push(AuraZone::Key2);
+        assert!(controller
+            .config
+            .create_multizone_default(&controller.supported_data)
+            .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]
+    #[ignore = "Unable to run in CI as the HIDRAW device is required"]
+    // TODO: use sim device
+    fn next_mode_create_multizone_if_no_config() {
+        // Checking to ensure set_mode errors when unsupported modes are tried
+        let config = AuraConfig::new("19b6");
+        let supported_basic_modes = LedSupportData {
+            device_name: String::new(),
+            product_id: String::new(),
+            layout_name: "ga401".to_owned(),
+            basic_modes: vec![AuraModeNum::Static],
+            basic_zones: vec![AuraZone::Key1, AuraZone::Key2],
+            advanced_type: rog_aura::keyboard::AdvancedAuraType::None,
+            power_zones: vec![PowerZones::Keyboard, PowerZones::RearGlow],
+        };
+        let mut controller = CtrlKbdLed {
+            led_type: AuraDeviceType::LaptopPost2021,
+            led_node: LEDNode::Rog(
+                Some(KeyboardBacklight::default()),
+                HidRaw::new("19b6").unwrap(),
+            ),
+            supported_data: supported_basic_modes,
+            per_key_mode_active: false,
+            config,
+            dbus_path: OwnedObjectPath::default(),
+        };
+
+        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/manager.rs

@@ -0,0 +1,139 @@
+// Plan:
+// - Manager has udev monitor on USB looking for ROG devices
+// - If a device is found, add it to watch
+// - Add it to Zbus server
+// - If udev sees device removed then remove the zbus path
+
+use std::collections::HashSet;
+
+use log::{error, info, warn};
+use mio::{Events, Interest, Poll, Token};
+use tokio::task::spawn_blocking;
+use udev::{Device, MonitorBuilder};
+use zbus::object_server::SignalContext;
+use zbus::zvariant::{ObjectPath, OwnedObjectPath};
+use zbus::Connection;
+
+use crate::ctrl_aura::controller::CtrlKbdLed;
+use crate::ctrl_aura::trait_impls::{CtrlAuraZbus, AURA_ZBUS_PATH};
+use crate::error::RogError;
+use crate::{CtrlTask, Reloadable};
+
+pub struct AuraManager {
+    _connection: Connection,
+}
+
+impl AuraManager {
+    pub async fn new(connection: Connection) -> Result<Self, RogError> {
+        let conn_copy = connection.clone();
+        let mut interfaces = HashSet::new();
+
+        // Do the initial keyboard detection:
+        let all = CtrlKbdLed::find_all()?;
+        for ctrl in all {
+            let path = ctrl.dbus_path.clone();
+            interfaces.insert(path.clone()); // ensure we record the initial stuff
+            let sig_ctx = CtrlAuraZbus::signal_context(&connection)?;
+            let sig_ctx2 = sig_ctx.clone();
+            let zbus = CtrlAuraZbus::new(ctrl, sig_ctx);
+            start_tasks(zbus, connection.clone(), sig_ctx2, path).await?;
+        }
+
+        let manager = Self {
+            _connection: connection,
+        };
+
+        // detect all plugged in aura devices (eventually)
+        // only USB devices are detected for here
+        spawn_blocking(move || {
+            let mut monitor = MonitorBuilder::new()?.match_subsystem("hidraw")?.listen()?;
+            let mut poll = Poll::new()?;
+            let mut events = Events::with_capacity(1024);
+            poll.registry()
+                .register(&mut monitor, Token(0), Interest::READABLE)?;
+
+            loop {
+                if poll.poll(&mut events, None).is_err() {
+                    continue;
+                }
+                for event in monitor.iter() {
+                    let action = event.action().unwrap_or_default();
+
+                    if let Some(parent) =
+                        event.parent_with_subsystem_devtype("usb", "usb_device")?
+                    {
+                        if action == "remove" {
+                            if let Some(path) = dbus_path_for_dev(&parent) {
+                                if interfaces.remove(&path) {
+                                    info!("AuraManager removing: {path:?}");
+                                    let conn_copy = conn_copy.clone();
+                                    tokio::spawn(async move {
+                                        let res = conn_copy
+                                            .object_server()
+                                            .remove::<CtrlAuraZbus, _>(&path)
+                                            .await
+                                            .map_err(|e| {
+                                                error!("Failed to remove {path:?}, {e:?}");
+                                                e
+                                            })?;
+                                        info!("AuraManager removed: {path:?}, {res}");
+                                        Ok::<(), RogError>(())
+                                    });
+                                }
+                            }
+                        } else if action == "add" {
+                            if let Ok(Some(ctrl)) =
+                                CtrlKbdLed::maybe_device(event.device(), &mut interfaces)
+                            {
+                                ctrl.add_to_dbus_and_start(&mut interfaces, conn_copy.clone())
+                                    .map_err(|e| {
+                                        error!("Couldn't start aura device on dbus: {e:?}")
+                                    })
+                                    .ok();
+                            }
+                        };
+                    }
+                }
+            }
+            // Required for return type on spawn
+            #[allow(unreachable_code)]
+            Ok::<(), RogError>(())
+        });
+        Ok(manager)
+    }
+}
+
+pub(crate) fn dbus_path_for_dev(parent: &Device) -> Option<OwnedObjectPath> {
+    if let Some(filename) = super::filename_partial(parent) {
+        return Some(
+            ObjectPath::from_str_unchecked(&format!("{AURA_ZBUS_PATH}/{filename}")).into(),
+        );
+    }
+    None
+}
+
+pub(crate) fn dbus_path_for_tuf() -> OwnedObjectPath {
+    ObjectPath::from_str_unchecked(&format!("{AURA_ZBUS_PATH}/tuf")).into()
+}
+
+pub async fn start_tasks(
+    mut zbus: CtrlAuraZbus,
+    connection: Connection,
+    _signal_ctx: SignalContext<'static>,
+    path: OwnedObjectPath,
+) -> Result<(), RogError> {
+    // let task = zbus.clone();
+    // let signal_ctx = signal_ctx.clone();
+    zbus.reload()
+        .await
+        .unwrap_or_else(|err| warn!("Controller error: {}", err));
+    connection
+        .object_server()
+        .at(path.clone(), zbus)
+        .await
+        .map_err(|e| error!("Couldn't add server at path: {path}, {e:?}"))
+        .ok();
+    // TODO: skip this until we keep handles to tasks so they can be killed
+    // task.create_tasks(signal_ctx).await
+    Ok(())
+}

asusd/src/ctrl_aura/mod.rs

@@ -0,0 +1,34 @@
+use log::warn;
+use udev::Device;
+use zbus::zvariant::{ObjectPath, OwnedObjectPath};
+
+pub mod config;
+pub mod controller;
+pub mod manager;
+/// Implements `CtrlTask`, `Reloadable`, `ZbusRun`
+pub mod trait_impls;
+
+/// Returns only the Device details concatenated in a form usable for
+/// adding/appending to a filename
+pub(super) fn filename_partial(parent: &Device) -> Option<OwnedObjectPath> {
+    if let Some(id_product) = parent.attribute_value("idProduct") {
+        let id_product = id_product.to_string_lossy();
+        let mut path = if let Some(devnum) = parent.attribute_value("devnum") {
+            let devnum = devnum.to_string_lossy();
+            if let Some(devpath) = parent.attribute_value("devpath") {
+                let devpath = devpath.to_string_lossy();
+                format!("{id_product}_{devnum}_{devpath}")
+            } else {
+                format!("{id_product}_{devnum}")
+            }
+        } else {
+            format!("{id_product}")
+        };
+        if path.contains('.') {
+            warn!("dbus path for {id_product} contains `.`, removing");
+            path.replace('.', "").clone_into(&mut path);
+        }
+        return Some(ObjectPath::from_str_unchecked(&path).into());
+    }
+    None
+}

asusd/src/ctrl_aura/trait_impls.rs

@@ -0,0 +1,306 @@
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+use config_traits::StdConfig;
+use log::{debug, error, info, warn};
+use rog_aura::keyboard::{LaptopAuraPower, UsbPackets};
+use rog_aura::{AuraDeviceType, AuraEffect, AuraModeNum, AuraZone, LedBrightness, PowerZones};
+use zbus::export::futures_util::lock::{Mutex, MutexGuard};
+use zbus::export::futures_util::StreamExt;
+use zbus::fdo::Error as ZbErr;
+use zbus::{interface, 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";
+
+#[derive(Clone)]
+pub struct CtrlAuraZbus(Arc<Mutex<CtrlKbdLed>>, SignalContext<'static>);
+
+impl CtrlAuraZbus {
+    pub fn new(controller: CtrlKbdLed, signal: SignalContext<'static>) -> Self {
+        Self(Arc::new(Mutex::new(controller)), signal)
+    }
+
+    fn update_config(lock: &mut CtrlKbdLed) -> Result<(), RogError> {
+        let bright = lock.led_node.get_brightness().unwrap_or_default();
+        lock.config.read();
+        lock.config.brightness = bright.into();
+        lock.config.write();
+        Ok(())
+    }
+}
+
+/// The main interface for changing, reading, or notfying
+///
+/// LED commands are split between Brightness, Modes, Per-Key
+#[interface(name = "org.asuslinux.Aura")]
+impl CtrlAuraZbus {
+    /// Return the device type for this Aura keyboard
+    #[zbus(property)]
+    async fn device_type(&self) -> AuraDeviceType {
+        let ctrl = self.0.lock().await;
+        ctrl.led_type
+    }
+
+    /// Return the current LED brightness
+    #[zbus(property)]
+    async fn brightness(&self) -> Result<LedBrightness, ZbErr> {
+        let ctrl = self.0.lock().await;
+        Ok(ctrl.led_node.get_brightness().map(|n| n.into())?)
+    }
+
+    /// Set the keyboard brightness level (0-3)
+    #[zbus(property)]
+    async fn set_brightness(&mut self, brightness: LedBrightness) -> Result<(), ZbErr> {
+        let ctrl = self.0.lock().await;
+        Ok(ctrl.led_node.set_brightness(brightness.into())?)
+    }
+
+    /// Total levels of brightness available
+    #[zbus(property)]
+    async fn supported_brightness(&self) -> Vec<LedBrightness> {
+        vec![
+            LedBrightness::Off,
+            LedBrightness::Low,
+            LedBrightness::Med,
+            LedBrightness::High,
+        ]
+    }
+
+    /// The total available modes
+    #[zbus(property)]
+    async fn supported_basic_modes(&self) -> Result<Vec<AuraModeNum>, ZbErr> {
+        let ctrl = self.0.lock().await;
+        Ok(ctrl.config.builtins.keys().cloned().collect())
+    }
+
+    #[zbus(property)]
+    async fn supported_basic_zones(&self) -> Result<Vec<AuraZone>, ZbErr> {
+        let ctrl = self.0.lock().await;
+        Ok(ctrl.supported_data.basic_zones.clone())
+    }
+
+    #[zbus(property)]
+    async fn supported_power_zones(&self) -> Result<Vec<PowerZones>, ZbErr> {
+        let ctrl = self.0.lock().await;
+        Ok(ctrl.supported_data.power_zones.clone())
+    }
+
+    /// The current mode data
+    #[zbus(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.
+    #[zbus(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;
+        }
+        if ctrl.led_node.has_brightness_control() {
+            ctrl.led_node
+                .set_brightness(ctrl.config.brightness.into())?;
+        }
+        ctrl.config.write();
+
+        self.led_mode_data_invalidate(&self.1).await.ok();
+        Ok(())
+    }
+
+    /// The current mode data
+    #[zbus(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.
+    #[zbus(property)]
+    async fn set_led_mode_data(&mut self, effect: AuraEffect) -> Result<(), ZbErr> {
+        let mut ctrl = self.0.lock().await;
+        if !ctrl.supported_data.basic_modes.contains(&effect.mode)
+            || effect.zone != AuraZone::None
+                && !ctrl.supported_data.basic_zones.contains(&effect.zone)
+        {
+            return Err(ZbErr::NotSupported(format!(
+                "The Aura effect is not supported: {effect:?}"
+            )));
+        }
+
+        ctrl.write_effect_and_apply(&effect)?;
+        if ctrl.config.brightness == LedBrightness::Off {
+            ctrl.config.brightness = LedBrightness::Med;
+        }
+        if ctrl.led_node.has_brightness_control() {
+            ctrl.led_node
+                .set_brightness(ctrl.config.brightness.into())?;
+        }
+        ctrl.config.set_builtin(effect);
+        ctrl.config.write();
+
+        self.led_mode_invalidate(&self.1).await.ok();
+        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?)
+    #[zbus(property)]
+    async fn led_power(&self) -> LaptopAuraPower {
+        let ctrl = self.0.lock().await;
+        ctrl.config.enabled.clone()
+    }
+
+    /// 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.
+    #[zbus(property)]
+    async fn set_led_power(&mut self, options: LaptopAuraPower) -> Result<(), ZbErr> {
+        let mut ctrl = self.0.lock().await;
+        for opt in options.states {
+            let zone = opt.zone;
+            for config in ctrl.config.enabled.states.iter_mut() {
+                if config.zone == zone {
+                    *config = opt;
+                }
+            }
+        }
+        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(())
+    }
+}
+
+impl CtrlTask for CtrlAuraZbus {
+    fn zbus_path() -> &'static str {
+        "/org/asuslinux"
+    }
+
+    async fn create_tasks(&self, _: SignalContext<'static>) -> Result<(), RogError> {
+        let load_save =
+            |start: bool, mut lock: MutexGuard<'_, CtrlKbdLed>| -> Result<(), RogError> {
+                // If waking up
+                if !start {
+                    info!("CtrlKbdLedTask reloading brightness and modes");
+                    if lock.led_node.has_brightness_control() {
+                        lock.led_node
+                            .set_brightness(lock.config.brightness.into())
+                            .map_err(|e| {
+                                error!("CtrlKbdLedTask: {e}");
+                                e
+                            })?;
+                    }
+                    lock.write_current_config_mode().map_err(|e| {
+                        error!("CtrlKbdLedTask: {e}");
+                        e
+                    })?;
+                } else if start {
+                    Self::update_config(&mut lock).map_err(|e| {
+                        error!("CtrlKbdLedTask: {e}");
+                        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).unwrap(); // unwrap as we want to
+                                                        // bomb out of the task
+                }
+            },
+            move |_shutting_down| {
+                let inner3 = inner3.clone();
+                async move {
+                    let lock = inner3.lock().await;
+                    load_save(false, lock).unwrap(); // unwrap as we want to
+                                                     // bomb out of the task
+                }
+            },
+            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;
+        if ctrl.led_node.has_brightness_control() {
+            let watch = ctrl.led_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).unwrap(); // unwrap as we want
+                                                            // to
+                                                            // bomb out of the
+                                                            // task
+                        }
+                    })
+                    .await;
+            });
+        }
+
+        Ok(())
+    }
+}
+
+impl crate::Reloadable for CtrlAuraZbus {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.fix_ally_power()?;
+        debug!("reloading keyboard mode");
+        ctrl.write_current_config_mode()?;
+        debug!("reloading power states");
+        ctrl.set_power_states().map_err(|err| warn!("{err}")).ok();
+        Ok(())
+    }
+}

asusd/src/ctrl_fancurves.rs

@@ -0,0 +1,286 @@
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use config_traits::{StdConfig, StdConfigLoad};
+use futures_lite::StreamExt;
+use log::{debug, error, info, warn};
+use rog_platform::platform::{RogPlatform, ThrottlePolicy};
+use rog_profiles::error::ProfileError;
+use rog_profiles::fan_curve_set::CurveData;
+use rog_profiles::{find_fan_curve_node, FanCurvePU, FanCurveProfiles};
+use serde::{Deserialize, Serialize};
+use tokio::sync::Mutex;
+use zbus::{interface, Connection, SignalContext};
+
+use crate::error::RogError;
+use crate::{CtrlTask, CONFIG_PATH_BASE};
+
+pub const FAN_CURVE_ZBUS_NAME: &str = "FanCurves";
+pub const FAN_CURVE_ZBUS_PATH: &str = "/org/asuslinux";
+
+#[derive(Deserialize, Serialize, Debug, Default)]
+pub struct FanCurveConfig {
+    pub profiles: FanCurveProfiles,
+    #[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>>,
+    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!("Device has profile control available");
+            find_fan_curve_node()?;
+            info!("Device has fan curves available");
+            let mut config = FanCurveConfig::new().load();
+            let mut fan_curves = FanCurveProfiles::default();
+
+            // Only do defaults if the config doesn't already exist\
+            if config.profiles.balanced.is_empty() || !config.file_path().exists() {
+                info!("Fetching default fan curves");
+
+                let current = platform.get_throttle_thermal_policy()?;
+                for this in [
+                    ThrottlePolicy::Balanced,
+                    ThrottlePolicy::Performance,
+                    ThrottlePolicy::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.
+                    platform.set_throttle_thermal_policy(this.into())?;
+                    let mut dev = find_fan_curve_node()?;
+                    fan_curves.set_active_curve_to_defaults(this, &mut dev)?;
+
+                    info!("{this:?}:");
+                    for curve in fan_curves.get_fan_curves_for(this) {
+                        info!("{}", String::from(curve));
+                    }
+                }
+                platform.set_throttle_thermal_policy(current)?;
+                config.profiles = fan_curves;
+                config.write();
+            } else {
+                info!("Fan curves previously stored, loading...");
+                config = config.load();
+            }
+
+            return Ok(Self {
+                config: Arc::new(Mutex::new(config)),
+                platform,
+            });
+        }
+
+        Err(ProfileError::NotSupported.into())
+    }
+}
+
+#[interface(name = "org.asuslinux.FanCurves")]
+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: ThrottlePolicy,
+        enabled: bool,
+    ) -> zbus::fdo::Result<()> {
+        self.config
+            .lock()
+            .await
+            .profiles
+            .set_profile_curves_enabled(profile, enabled);
+        self.config
+            .lock()
+            .await
+            .profiles
+            .write_profile_curve_to_platform(profile, &mut find_fan_curve_node()?)?;
+        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: ThrottlePolicy,
+        fan: FanCurvePU,
+        enabled: bool,
+    ) -> zbus::fdo::Result<()> {
+        self.config
+            .lock()
+            .await
+            .profiles
+            .set_profile_fan_curve_enabled(profile, fan, enabled);
+        self.config
+            .lock()
+            .await
+            .profiles
+            .write_profile_curve_to_platform(profile, &mut find_fan_curve_node()?)?;
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    /// Get the fan-curve data for the currently active ThrottlePolicy
+    async fn fan_curve_data(
+        &mut self,
+        profile: ThrottlePolicy,
+    ) -> zbus::fdo::Result<Vec<CurveData>> {
+        let curve = self
+            .config
+            .lock()
+            .await
+            .profiles
+            .get_fan_curves_for(profile)
+            .to_vec();
+        Ok(curve)
+    }
+
+    /// Set the fan curve for the specified profile.
+    /// Will also activate the fan curve if the user is in the same mode.
+    async fn set_fan_curve(
+        &mut self,
+        profile: ThrottlePolicy,
+        curve: CurveData,
+    ) -> zbus::fdo::Result<()> {
+        self.config
+            .lock()
+            .await
+            .profiles
+            .save_fan_curve(curve, profile)?;
+        let active: ThrottlePolicy = self.platform.get_throttle_thermal_policy()?.into();
+        if active == profile {
+            self.config
+                .lock()
+                .await
+                .profiles
+                .write_profile_curve_to_platform(profile, &mut find_fan_curve_node()?)?;
+        }
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    /// Reset the stored (self) and device curves to the defaults of the
+    /// platform.
+    ///
+    /// Each platform_profile has a different default and the default can be
+    /// read only for the currently active profile.
+    async fn set_curves_to_defaults(&mut self, profile: ThrottlePolicy) -> zbus::fdo::Result<()> {
+        let active = self.platform.get_throttle_thermal_policy()?;
+        self.platform.set_throttle_thermal_policy(profile.into())?;
+        self.config
+            .lock()
+            .await
+            .profiles
+            .set_active_curve_to_defaults(profile, &mut find_fan_curve_node()?)?;
+        self.platform.set_throttle_thermal_policy(active)?;
+        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: ThrottlePolicy) -> zbus::fdo::Result<()> {
+        let active = self.platform.get_throttle_thermal_policy()?;
+
+        self.platform.set_throttle_thermal_policy(profile.into())?;
+        self.config
+            .lock()
+            .await
+            .profiles
+            .set_active_curve_to_defaults(active.into(), &mut find_fan_curve_node()?)?;
+        self.platform.set_throttle_thermal_policy(active)?;
+
+        self.config.lock().await.write();
+        Ok(())
+    }
+}
+
+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;
+    }
+}
+
+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.config.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!("get_throttle_thermal_policy error: {e}");
+                    }) {
+                        if profile != config.lock().await.current {
+                            fan_curves
+                                .lock()
+                                .await
+                                .profiles
+                                .write_profile_curve_to_platform(
+                                    profile.into(),
+                                    &mut find_fan_curve_node().unwrap(),
+                                )
+                                .map_err(|e| warn!("write_profile_curve_to_platform, {}", e))
+                                .ok();
+                            config.lock().await.current = profile;
+                        }
+                    }
+                }
+            }
+        });
+
+        Ok(())
+    }
+}
+
+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();
+        let mut config = self.config.lock().await;
+        if let Ok(mut device) = find_fan_curve_node() {
+            config
+                .profiles
+                .write_profile_curve_to_platform(active, &mut device)?;
+        }
+
+        Ok(())
+    }
+}

asusd/src/ctrl_slash/config.rs

@@ -0,0 +1,51 @@
+use config_traits::{StdConfig, StdConfigLoad};
+use rog_slash::{DeviceState, SlashMode};
+use serde::{Deserialize, Serialize};
+
+const CONFIG_FILE: &str = "slash.ron";
+
+/// Config for base system actions for the anime display
+#[derive(Deserialize, Serialize, Debug)]
+pub struct SlashConfig {
+    pub slash_enabled: bool,
+    pub slash_brightness: u8,
+    pub slash_interval: u8,
+    pub slash_mode: SlashMode,
+}
+
+impl Default for SlashConfig {
+    fn default() -> Self {
+        SlashConfig {
+            slash_enabled: true,
+            slash_brightness: 255,
+            slash_interval: 0,
+            slash_mode: SlashMode::Bounce,
+        }
+    }
+}
+impl StdConfig for SlashConfig {
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+}
+
+impl StdConfigLoad for SlashConfig {}
+
+impl From<&SlashConfig> for DeviceState {
+    fn from(config: &SlashConfig) -> Self {
+        DeviceState {
+            slash_enabled: config.slash_enabled,
+            slash_brightness: config.slash_brightness,
+            slash_interval: config.slash_interval,
+            slash_mode: config.slash_mode,
+        }
+    }
+}

asusd/src/ctrl_slash/mod.rs

@@ -0,0 +1,100 @@
+pub mod config;
+pub mod trait_impls;
+
+use config_traits::{StdConfig, StdConfigLoad};
+use log::info;
+use rog_platform::hid_raw::HidRaw;
+use rog_platform::usb_raw::USBRaw;
+use rog_slash::error::SlashError;
+use rog_slash::usb::{get_maybe_slash_type, pkt_set_mode, pkt_set_options, pkts_for_init};
+use rog_slash::{SlashMode, SlashType};
+
+use crate::ctrl_slash::config::SlashConfig;
+use crate::error::RogError;
+
+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 struct CtrlSlash {
+    node: Node,
+    config: SlashConfig,
+}
+
+impl CtrlSlash {
+    #[inline]
+    pub fn new() -> Result<CtrlSlash, RogError> {
+        let slash_type = get_maybe_slash_type()?;
+        if matches!(slash_type, SlashType::Unsupported) {
+            info!("No Slash capable laptop found");
+            return Err(RogError::Slash(SlashError::NoDevice));
+        }
+
+        let usb = USBRaw::new(rog_slash::usb::PROD_ID).ok();
+        let hid = HidRaw::new(rog_slash::usb::PROD_ID_STR).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::Slash(SlashError::NoDevice));
+        };
+
+        let ctrl = CtrlSlash {
+            node,
+            config: SlashConfig::new().load(),
+        };
+        ctrl.do_initialization()?;
+
+        Ok(ctrl)
+    }
+
+    fn do_initialization(&self) -> Result<(), RogError> {
+        let init_packets = pkts_for_init();
+        self.node.write_bytes(&init_packets[0])?;
+        self.node.write_bytes(&init_packets[1])?;
+
+        // Apply config upon initialization
+        let option_packets = pkt_set_options(
+            self.config.slash_enabled,
+            self.config.slash_brightness,
+            self.config.slash_interval,
+        );
+        self.node.write_bytes(&option_packets)?;
+
+        let mode_packets = pkt_set_mode(self.config.slash_mode);
+        self.node.write_bytes(&mode_packets[0])?;
+        self.node.write_bytes(&mode_packets[1])?;
+
+        Ok(())
+    }
+
+    pub fn set_options(&self, enabled: bool, brightness: u8, interval: u8) -> Result<(), RogError> {
+        let command_packets = pkt_set_options(enabled, brightness, interval);
+        self.node.write_bytes(&command_packets)?;
+        Ok(())
+    }
+
+    pub fn set_slash_mode(&self, slash_mode: SlashMode) -> Result<(), RogError> {
+        let command_packets = pkt_set_mode(slash_mode);
+        self.node.write_bytes(&command_packets[0])?;
+        self.node.write_bytes(&command_packets[1])?;
+        Ok(())
+    }
+}

asusd/src/ctrl_slash/trait_impls.rs

@@ -0,0 +1,165 @@
+use std::sync::Arc;
+
+use config_traits::StdConfig;
+use log::warn;
+use rog_slash::usb::{pkt_set_mode, pkt_set_options};
+use rog_slash::{DeviceState, SlashMode};
+use zbus::export::futures_util::lock::Mutex;
+use zbus::{interface, Connection, SignalContext};
+
+use crate::ctrl_slash::CtrlSlash;
+use crate::error::RogError;
+
+pub const SLASH_ZBUS_NAME: &str = "Slash";
+pub const SLASH_ZBUS_PATH: &str = "/org/asuslinux";
+
+#[derive(Clone)]
+pub struct CtrlSlashZbus(pub Arc<Mutex<CtrlSlash>>);
+
+/// The struct with the main dbus methods requires this trait
+impl crate::ZbusRun for CtrlSlashZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, SLASH_ZBUS_PATH, server).await;
+    }
+}
+
+#[interface(name = "org.asuslinux.Slash")]
+impl CtrlSlashZbus {
+    /// Get enabled or not
+    #[zbus(property)]
+    async fn enabled(&self) -> bool {
+        let lock = self.0.lock().await;
+        lock.config.slash_enabled
+    }
+
+    /// Set enabled true or false
+    #[zbus(property)]
+    async fn set_enabled(&self, enabled: bool) {
+        let mut lock = self.0.lock().await;
+        let brightness = if enabled && lock.config.slash_brightness == 0 {
+            0x88
+        } else {
+            lock.config.slash_brightness
+        };
+        lock.node
+            .write_bytes(&pkt_set_options(
+                enabled,
+                brightness,
+                lock.config.slash_interval,
+            ))
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+
+        lock.config.slash_enabled = enabled;
+        lock.config.slash_brightness = brightness;
+        lock.config.write();
+    }
+
+    /// Get brightness level
+    #[zbus(property)]
+    async fn brightness(&self) -> u8 {
+        let lock = self.0.lock().await;
+        lock.config.slash_brightness
+    }
+
+    /// Set brightness level
+    #[zbus(property)]
+    async fn set_brightness(&self, brightness: u8) {
+        let mut lock = self.0.lock().await;
+        let enabled = brightness > 0;
+        lock.node
+            .write_bytes(&pkt_set_options(
+                enabled,
+                brightness,
+                lock.config.slash_interval,
+            ))
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+
+        lock.config.slash_enabled = enabled;
+        lock.config.slash_brightness = brightness;
+        lock.config.write();
+    }
+
+    #[zbus(property)]
+    async fn interval(&self) -> u8 {
+        let lock = self.0.lock().await;
+        lock.config.slash_interval
+    }
+
+    /// Set interval between slash animations (0-255)
+    #[zbus(property)]
+    async fn set_interval(&self, interval: u8) {
+        let mut lock = self.0.lock().await;
+        lock.node
+            .write_bytes(&pkt_set_options(
+                lock.config.slash_enabled,
+                lock.config.slash_brightness,
+                interval,
+            ))
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+
+        lock.config.slash_interval = interval;
+        lock.config.write();
+    }
+
+    #[zbus(property)]
+    async fn slash_mode(&self) -> u8 {
+        let lock = self.0.lock().await;
+        lock.config.slash_interval
+    }
+
+    /// Set interval between slash animations (0-255)
+    #[zbus(property)]
+    async fn set_slash_mode(&self, slash_mode: SlashMode) {
+        let mut lock = self.0.lock().await;
+
+        let command_packets = pkt_set_mode(slash_mode);
+
+        lock.node
+            .write_bytes(&command_packets[0])
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+        lock.node
+            .write_bytes(&command_packets[1])
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+
+        lock.config.slash_mode = slash_mode;
+        lock.config.write();
+    }
+
+    /// Get the device state as stored by asusd
+    // #[zbus(property)]
+    async fn device_state(&self) -> DeviceState {
+        let lock = self.0.lock().await;
+        DeviceState::from(&lock.config)
+    }
+}
+
+impl crate::CtrlTask for CtrlSlashZbus {
+    fn zbus_path() -> &'static str {
+        SLASH_ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, _: SignalContext<'static>) -> Result<(), RogError> {
+        Ok(())
+    }
+}
+
+impl crate::Reloadable for CtrlSlashZbus {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        Ok(())
+    }
+}

asusd/src/daemon.rs

@@ -0,0 +1,134 @@
+use std::env;
+use std::error::Error;
+use std::sync::Arc;
+
+use ::zbus::export::futures_util::lock::Mutex;
+use ::zbus::Connection;
+use asusd::config::Config;
+use asusd::ctrl_anime::trait_impls::CtrlAnimeZbus;
+use asusd::ctrl_anime::CtrlAnime;
+use asusd::ctrl_aura::manager::AuraManager;
+use asusd::ctrl_fancurves::CtrlFanCurveZbus;
+use asusd::ctrl_platform::CtrlPlatform;
+use asusd::ctrl_slash::trait_impls::CtrlSlashZbus;
+use asusd::ctrl_slash::CtrlSlash;
+use asusd::{print_board_info, start_tasks, CtrlTask, DBUS_NAME};
+use config_traits::{StdConfig, StdConfigLoad1};
+use log::{error, info};
+use zbus::fdo::ObjectManager;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // console_subscriber::init();
+    let mut logger = env_logger::Builder::new();
+    logger
+        .parse_default_env()
+        .target(env_logger::Target::Stdout)
+        .format_timestamp(None)
+        .init();
+
+    let is_service = match env::var_os("IS_SERVICE") {
+        Some(val) => val == "1",
+        None => false,
+    };
+
+    if !is_service {
+        println!("asusd schould be only run from the right systemd service");
+        println!(
+            "do not run in your terminal, if you need an logs please use journalctl -b -u asusd"
+        );
+        println!("asusd will now exit");
+        return Ok(());
+    }
+
+    info!("       daemon v{}", asusd::VERSION);
+    info!("    rog-anime v{}", rog_anime::VERSION);
+    info!("    rog-slash v{}", rog_slash::VERSION);
+    info!("     rog-aura v{}", rog_aura::VERSION);
+    info!(" rog-profiles v{}", rog_profiles::VERSION);
+    info!("rog-platform v{}", rog_platform::VERSION);
+
+    start_daemon().await?;
+    Ok(())
+}
+
+/// The actual main loop for the daemon
+async fn start_daemon() -> Result<(), Box<dyn Error>> {
+    // let supported = SupportedFunctions::get_supported();
+    print_board_info();
+    // println!("{:?}", supported.supported_functions());
+
+    // Start zbus server
+    let mut connection = Connection::system().await?;
+    connection
+        .object_server()
+        .at("/", ObjectManager)
+        .await
+        .unwrap();
+
+    let config = Config::new().load();
+    let cfg_path = config.file_path();
+    let config = Arc::new(Mutex::new(config));
+
+    // supported.add_to_server(&mut connection).await;
+
+    match CtrlFanCurveZbus::new() {
+        Ok(ctrl) => {
+            let sig_ctx = CtrlFanCurveZbus::signal_context(&connection)?;
+            start_tasks(ctrl, &mut connection, sig_ctx).await?;
+        }
+        Err(err) => {
+            error!("FanCurves: {}", err);
+        }
+    }
+
+    match CtrlPlatform::new(
+        config.clone(),
+        &cfg_path,
+        CtrlPlatform::signal_context(&connection)?,
+    ) {
+        Ok(ctrl) => {
+            let sig_ctx = CtrlPlatform::signal_context(&connection)?;
+            start_tasks(ctrl, &mut connection, sig_ctx).await?;
+        }
+        Err(err) => {
+            error!("CtrlPlatform: {}", err);
+        }
+    }
+
+    match CtrlAnime::new() {
+        Ok(ctrl) => {
+            let zbus = CtrlAnimeZbus(Arc::new(Mutex::new(ctrl)));
+            let sig_ctx = CtrlAnimeZbus::signal_context(&connection)?;
+            start_tasks(zbus, &mut connection, sig_ctx).await?;
+        }
+        Err(err) => {
+            info!("AniMe control: {}", err);
+        }
+    }
+
+    match CtrlSlash::new() {
+        Ok(ctrl) => {
+            let zbus = CtrlSlashZbus(Arc::new(Mutex::new(ctrl)));
+            // Currently, the Slash has no need for a loop watching power events, however,
+            // it could be cool to have the slash do some power-on/off animation
+            // (It has a built-in power on animation which plays when u plug in the power
+            // supply)
+            let sig_ctx = CtrlSlashZbus::signal_context(&connection)?;
+            start_tasks(zbus, &mut connection, sig_ctx).await?;
+        }
+        Err(err) => {
+            info!("AniMe control: {}", err);
+        }
+    }
+
+    let _ = AuraManager::new(connection.clone()).await?;
+
+    // Request dbus name after finishing initalizing all functions
+    connection.request_name(DBUS_NAME).await?;
+
+    loop {
+        // This is just a blocker to idle and ensure the reator reacts
+        connection.executor().tick().await;
+    }
+}

asusd/src/error.rs

@@ -5,6 +5,7 @@ use config_traits::ron;
 use rog_anime::error::AnimeError;
 use rog_platform::error::PlatformError;
 use rog_profiles::error::ProfileError;
+use rog_slash::error::SlashError;
 
 #[derive(Debug)]
 pub enum RogError {
@@ -31,6 +32,7 @@ pub enum RogError {
     NoAuraKeyboard,
     NoAuraNode,
     Anime(AnimeError),
+    Slash(SlashError),
     Platform(PlatformError),
     SystemdUnitAction(String),
     SystemdUnitWaitTimeout(String),
@@ -72,6 +74,7 @@ impl fmt::Display for RogError {
             RogError::NoAuraKeyboard => write!(f, "No supported Aura keyboard"),
             RogError::NoAuraNode => write!(f, "No Aura keyboard node found"),
             RogError::Anime(deets) => write!(f, "AniMe Matrix error: {}", deets),
+            RogError::Slash(deets) => write!(f, "Slash error: {}", deets),
             RogError::Platform(deets) => write!(f, "Asus Platform error: {}", deets),
             RogError::SystemdUnitAction(action) => {
                 write!(f, "systemd unit action {} failed", action)
@@ -103,6 +106,12 @@ impl From<AnimeError> for RogError {
     }
 }
 
+impl From<SlashError> for RogError {
+    fn from(err: SlashError) -> Self {
+        RogError::Slash(err)
+    }
+}
+
 impl From<PlatformError> for RogError {
     fn from(err: PlatformError) -> Self {
         RogError::Platform(err)

asusd/src/lib.rs

@@ -0,0 +1,314 @@
+#![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;
+/// Control of Slash led bar
+pub mod ctrl_slash;
+
+pub mod error;
+
+use std::future::Future;
+use std::time::Duration;
+
+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 $name_str:literal $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
+                                    if ctrl.config.lock().await.$name != value {
+                                        log::debug!("{} was changed to {} externally", $name_str, value);
+                                        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);
+}
+
+pub trait Reloadable {
+    fn reload(&mut self) -> impl Future<Output = Result<(), RogError>> + Send;
+}
+
+pub trait ReloadAndNotify {
+    type Data: Send;
+
+    fn reload_and_notify(
+        &mut self,
+        signal_context: &SignalContext<'static>,
+        data: Self::Data,
+    ) -> impl Future<Output = Result<(), RogError>> + Send;
+}
+
+pub trait ZbusRun {
+    fn add_to_server(self, server: &mut Connection) -> impl Future<Output = ()> + Send;
+
+    fn add_to_server_helper(
+        iface: impl zbus::Interface,
+        path: &str,
+        server: &mut Connection,
+    ) -> impl Future<Output = ()> + Send {
+        async move {
+            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
+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.
+    fn create_tasks(
+        &self,
+        signal: SignalContext<'static>,
+    ) -> impl Future<Output = Result<(), RogError>> + Send;
+
+    // /// 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.
+    fn create_sys_event_tasks<Fut1, Fut2, Fut3, Fut4, F1, F2, F3, F4>(
+        &self,
+        mut on_prepare_for_sleep: F1,
+        mut on_prepare_for_shutdown: F2,
+        mut on_lid_change: F3,
+        mut on_external_power_change: F4,
+    ) -> impl Future<Output = ()> + Send
+    where
+        F1: FnMut(bool) -> Fut1 + Send + 'static,
+        F2: FnMut(bool) -> Fut2 + Send + 'static,
+        F3: FnMut(bool) -> Fut3 + Send + 'static,
+        F4: FnMut(bool) -> Fut4 + Send + 'static,
+        Fut1: Future<Output = ()> + Send,
+        Fut2: Future<Output = ()> + Send,
+        Fut3: Future<Output = ()> + Send,
+        Fut4: Future<Output = ()> + Send,
+    {
+        async {
+            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;
+}
+
+pub async fn start_tasks<T>(
+    mut zbus: T,
+    connection: &mut Connection,
+    signal_ctx: SignalContext<'static>,
+) -> Result<(), RogError>
+where
+    T: ZbusRun + Reloadable + CtrlTask + Clone,
+{
+    let zbus_clone = zbus.clone();
+
+    zbus.reload()
+        .await
+        .unwrap_or_else(|err| warn!("Controller error: {}", err));
+    zbus.add_to_server(connection).await;
+
+    zbus_clone.create_tasks(signal_ctx).await.ok();
+    Ok(())
+}

config-traits/Cargo.toml

@@ -1,15 +1,18 @@
 [package]
 name = "config-traits"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+license.workspace = true
+version.workspace = true
+readme.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+edition.workspace = true
 
 [dependencies]
 serde.workspace = true
-serde_derive.workspace = true
-serde_json.workspace = true
-toml.workspace = true
 ron.workspace = true
 
-log.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

@@ -1,4 +1,11 @@
-use std::fs::{create_dir, File, OpenOptions};
+//! `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
+
+use std::fs::{self, create_dir, File, OpenOptions};
 use std::io::{Read, Write};
 use std::path::PathBuf;
 
@@ -49,7 +56,7 @@ where
                     "Could not rename. Please remove {} then restart service: Error {}",
                     self.file_name(),
                     err
-                )
+                );
             });
             do_rename = false;
         }
@@ -68,7 +75,7 @@ where
                     "Could not rename. Please remove {} then restart service: Error {}",
                     self.file_name(),
                     err
-                )
+                );
             });
         }
         config
@@ -82,24 +89,17 @@ where
             .read(true)
             .write(true)
             .create(true)
+            .truncate(false)
             .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) {
-        let mut file = match OpenOptions::new().read(true).open(self.file_path()) {
-            Ok(data) => data,
-            Err(err) => {
-                error!("Error reading {:?}: {}", self.file_path(), err);
-                return;
-            }
-        };
-        let mut buf = String::new();
-        if let Ok(l) = file.read_to_string(&mut buf) {
-            if l == 0 {
+        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(&buf) {
+            } else if let Ok(data) = ron::from_str(&data) {
                 *self = data;
             } else {
                 warn!("Could not deserialise {:?}", self.file_path());
@@ -107,6 +107,20 @@ where
         }
     }
 
+    /// Open and parse the config file to self from ron format
+    fn read_new(&self) -> Option<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) {
+                return Some(data);
+            } else {
+                warn!("Could not deserialise {:?}", self.file_path());
+            }
+        }
+        None
+    }
+
     /// Write the config file data to pretty ron format
     fn write(&self) {
         let mut file = match File::create(self.file_path()) {
@@ -132,18 +146,15 @@ where
 
     /// 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 cfg_old = self.file_path().to_string_lossy().to_string() + "-old";
+        warn!("Renaming {} to {}-old", 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
-            )
+            );
         });
     }
 }
@@ -160,13 +171,13 @@ macro_rules! std_config_load {
         /// use serde::{Deserialize, Serialize};
         /// use config_traits::{StdConfig, StdConfigLoad2};
         ///
-        /// #[derive(Deserialize, Serialize)]
+        /// #[derive(Deserialize, Serialize, Debug)]
         /// struct FanCurveConfigOld {}
         ///
-        /// #[derive(Deserialize, Serialize)]
+        /// #[derive(Deserialize, Serialize, Debug)]
         /// struct FanCurveConfigOlder {}
         ///
-        /// #[derive(Deserialize, Serialize)]
+        /// #[derive(Deserialize, Serialize, Debug)]
         /// struct FanCurveConfig {}
         ///
         /// impl From<FanCurveConfigOld> for FanCurveConfig {
@@ -192,7 +203,7 @@ macro_rules! std_config_load {
         /// new one created
         pub trait $trait_name<$($generic),*>
         where
-            Self: $crate::StdConfig + DeserializeOwned + Serialize,
+            Self: $crate::StdConfig +std::fmt::Debug + DeserializeOwned + Serialize,
             $($generic: DeserializeOwned + Into<Self>),*
         {
             fn load(mut self) -> Self {
@@ -202,14 +213,10 @@ macro_rules! std_config_load {
                     if read_len != 0 {
                         if let Ok(data) = ron::from_str(&buf) {
                             self = data;
-                        } else if let Ok(data) = serde_json::from_str(&buf) {
-                            self = data;
-                        } else if let Ok(data) = toml::from_str(&buf) {
-                            self = data;
-                        } $(else if let Ok(data) = serde_json::from_str::<$generic>(&buf) {
-                            self = data.into();
-                        } else if let Ok(data) = toml::from_str::<$generic>(&buf) {
+                            log::info!("Parsed RON 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 {
                             self.rename_file_old();
                             self = Self::new();
@@ -237,10 +244,10 @@ mod tests {
 
     #[test]
     fn check_macro_from_1() {
-        #[derive(serde::Deserialize, serde::Serialize)]
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
         struct Test {}
 
-        #[derive(serde::Deserialize, serde::Serialize)]
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
         struct Old1 {}
 
         impl crate::StdConfig for Test {
@@ -263,21 +270,23 @@ mod tests {
             }
         }
 
+        let _ = Test {};
+
         impl crate::StdConfigLoad1<Old1> for Test {}
     }
 
     #[test]
     fn check_macro_from_3() {
-        #[derive(serde::Deserialize, serde::Serialize)]
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
         struct Test {}
 
-        #[derive(serde::Deserialize, serde::Serialize)]
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
         struct Old1 {}
 
-        #[derive(serde::Deserialize, serde::Serialize)]
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
         struct Old2 {}
 
-        #[derive(serde::Deserialize, serde::Serialize)]
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
         struct Old3 {}
 
         impl crate::StdConfig for Test {
@@ -312,6 +321,8 @@ mod tests {
             }
         }
 
+        let _ = Test {};
+
         impl crate::StdConfigLoad3<Old1, Old2, Old3> for Test {}
     }
 }

cpuctl/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "cpuctl"
+license.workspace = true
+version.workspace = true
+readme.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+edition.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/src/config.rs

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

daemon/src/ctrl_anime/trait_impls.rs

@@ -1,221 +0,0 @@
-use std::sync::atomic::Ordering;
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use config_traits::StdConfig;
-use log::{info, warn};
-use rog_anime::usb::{pkt_for_apply, pkt_for_set_boot, pkt_for_set_on};
-use rog_anime::{AnimeDataBuffer, AnimePowerStates};
-use zbus::export::futures_util::lock::{Mutex, MutexGuard};
-use zbus::{dbus_interface, Connection, SignalContext};
-
-use super::CtrlAnime;
-use crate::error::RogError;
-
-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 std::collections::BTreeMap;
-
-use config_traits::StdConfig;
-use log::{info, warn};
-use rog_aura::advanced::{LedUsbPackets, UsbPackets};
-use rog_aura::aura_detection::{LaptopLedData, ASUS_KEYBOARD_DEVICES};
-use rog_aura::usb::{AuraDevice, LED_APPLY, LED_SET};
-use rog_aura::{AuraEffect, AuraZone, Direction, LedBrightness, Speed, GRADIENT, LED_MSG_LEN};
-use rog_platform::hid_raw::HidRaw;
-use rog_platform::keyboard_led::KeyboardLed;
-use rog_platform::supported::LedSupportedFunctions;
-
-use super::config::{AuraConfig, AuraPowerConfig};
-use crate::error::RogError;
-use crate::GetSupported;
-
-impl GetSupported for CtrlKbdLed {
-    type A = LedSupportedFunctions;
-
-    fn get_supported() -> Self::A {
-        // let mode = <&str>::from(&<AuraModes>::from(*mode));
-        let laptop = LaptopLedData::get_data();
-        let stock_led_modes = laptop.basic_modes;
-        let multizone_led_mode = laptop.basic_zones;
-        let advanced_type = laptop.advanced_type;
-
-        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 {
-            dev_id: prod_id,
-            brightness: rgb.is_ok(),
-            basic_modes: stock_led_modes,
-            basic_zones: multizone_led_mode,
-            advanced_type: advanced_type.into(),
-        }
-    }
-}
-
-#[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.basic_modes.contains(&effect.mode)
-            || effect.zone != AuraZone::None
-                && !self.supported_modes.basic_zones.contains(&effect.zone)
-        {
-            return Err(RogError::AuraEffectNotSupported);
-        }
-
-        self.write_mode(&effect)?;
-        self.config.read(); // refresh config if successful
-        self.config.set_builtin(effect);
-        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: &UsbPackets) -> 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 = 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])?;
-                }
-            }
-            self.flip_effect_write = !self.flip_effect_write;
-        }
-        Ok(())
-    }
-
-    pub(super) fn toggle_mode(&mut self, reverse: bool) -> Result<(), RogError> {
-        let current = self.config.current_mode;
-        if let Some(idx) = self
-            .supported_modes
-            .basic_modes
-            .iter()
-            .position(|v| *v == current)
-        {
-            let mut idx = idx;
-            // goes past end of array
-            if reverse {
-                if idx == 0 {
-                    idx = self.supported_modes.basic_modes.len() - 1;
-                } else {
-                    idx -= 1;
-                }
-            } else {
-                idx += 1;
-                if idx == self.supported_modes.basic_modes.len() {
-                    idx = 0;
-                }
-            }
-            let next = self.supported_modes.basic_modes[idx];
-
-            self.config.read();
-            // if self.config.builtins.contains_key(&next) {
-            self.config.current_mode = next;
-            self.write_current_config_mode()?;
-            // }
-            self.config.write();
-        }
-
-        Ok(())
-    }
-
-    fn write_mode(&mut self, mode: &AuraEffect) -> Result<(), RogError> {
-        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.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;
-    use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour};
-    use rog_platform::keyboard_led::KeyboardLed;
-
-    use super::CtrlKbdLed;
-    use crate::ctrl_aura::config::AuraConfig;
-    use crate::ctrl_aura::controller::LEDNode;
-
-    #[test]
-    // #[ignore = "Must be manually run due to detection stage"]
-    fn check_set_mode_errors() {
-        // Checking to ensure set_mode errors when unsupported modes are tried
-        let config = AuraConfig::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,
-        };
-        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.basic_zones.push(AuraZone::Key2);
-        assert_eq!(
-            controller.set_effect(effect).unwrap_err().to_string(),
-            "No supported Aura keyboard"
-        );
-    }
-
-    #[test]
-    fn create_multizone_if_no_config() {
-        // Checking to ensure set_mode errors when unsupported modes are tried
-        let config = AuraConfig::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,
-        };
-        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.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::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,
-        };
-        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/mod.rs

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

daemon/src/ctrl_aura/trait_impls.rs

@@ -1,327 +0,0 @@
-use std::collections::BTreeMap;
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use config_traits::StdConfig;
-use log::{error, info, warn};
-use rog_aura::advanced::UsbPackets;
-use rog_aura::usb::AuraPowerDev;
-use rog_aura::{AuraEffect, AuraModeNum, LedBrightness};
-use zbus::export::futures_util::lock::{Mutex, MutexGuard};
-use zbus::export::futures_util::StreamExt;
-use zbus::{dbus_interface, Connection, SignalContext};
-
-use super::controller::CtrlKbdLed;
-use crate::error::RogError;
-use crate::CtrlTask;
-
-pub(super) const ZBUS_PATH: &str = "/org/asuslinux/Aura";
-
-#[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()
-    }
-
-    /// On machine that have some form of either per-key keyboard or per-zone
-    /// this can be used to write custom effects over dbus. The input is a
-    /// nested `Vec<Vec<8>>` where `Vec<u8>` is a raw USB packet
-    async fn direct_addressing_raw(&self, data: UsbPackets) -> zbus::fdo::Result<()> {
-        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,388 +0,0 @@
-use std::fs::OpenOptions;
-use std::io::{Read, Write};
-use std::path::Path;
-use std::process::Command;
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use config_traits::StdConfig;
-use log::{info, warn};
-use rog_platform::platform::{AsusPlatform, GpuMode};
-use rog_platform::supported::RogBiosSupportedFunctions;
-use zbus::export::futures_util::lock::Mutex;
-use zbus::{dbus_interface, Connection, SignalContext};
-
-use crate::config::Config;
-use crate::error::RogError;
-use crate::{task_watch_item, CtrlTask, GetSupported};
-
-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,287 +0,0 @@
-use std::process::Command;
-use std::sync::Arc;
-use std::time::Duration;
-
-use async_trait::async_trait;
-use config_traits::StdConfig;
-use log::{error, info, warn};
-use rog_platform::power::AsusPower;
-use rog_platform::supported::ChargeSupportedFunctions;
-use systemd_zbus::{ManagerProxy as SystemdProxy, Mode, UnitFileState};
-use tokio::time::sleep;
-use zbus::export::futures_util::lock::Mutex;
-use zbus::{dbus_interface, Connection, SignalContext};
-
-use crate::config::Config;
-use crate::error::RogError;
-use crate::{task_watch_item, CtrlTask, GetSupported};
-
-const ZBUS_PATH: &str = "/org/asuslinux/Power";
-const NVIDIA_POWERD: &str = "nvidia-powerd.service";
-
-impl GetSupported for CtrlPower {
-    type A = ChargeSupportedFunctions;
-
-    fn get_supported() -> Self::A {
-        ChargeSupportedFunctions {
-            charge_level_set: if let Ok(power) = AsusPower::new() {
-                power.has_charge_control_end_threshold()
-            } else {
-                false
-            },
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct CtrlPower {
-    power: AsusPower,
-    config: Arc<Mutex<Config>>,
-}
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl CtrlPower {
-    async fn set_charge_control_end_threshold(
-        &mut self,
-        #[zbus(signal_context)] ctxt: SignalContext<'_>,
-        limit: u8,
-    ) -> zbus::fdo::Result<()> {
-        if !(20..=100).contains(&limit) {
-            return Err(RogError::ChargeLimit(limit))?;
-        }
-        self.set(limit)
-            .map_err(|err| {
-                warn!("CtrlCharge: set_limit {}", err);
-                err
-            })
-            .ok();
-        Self::notify_charge_control_end_threshold(&ctxt, limit)
-            .await
-            .ok();
-        Ok(())
-    }
-
-    fn charge_control_end_threshold(&self) -> u8 {
-        loop {
-            if let Some(mut config) = self.config.try_lock() {
-                let limit = self
-                    .power
-                    .get_charge_control_end_threshold()
-                    .map_err(|err| {
-                        warn!("CtrlCharge: get_charge_control_end_threshold {}", err);
-                        err
-                    })
-                    .unwrap_or(100);
-
-                config.read();
-                config.bat_charge_limit = limit;
-                config.write();
-
-                return config.bat_charge_limit;
-            }
-        }
-    }
-
-    fn mains_online(&self) -> bool {
-        if self.power.has_online() {
-            if let Ok(v) = self.power.get_online() {
-                return v == 1;
-            }
-        }
-        false
-    }
-
-    #[dbus_interface(signal)]
-    async fn notify_charge_control_end_threshold(
-        ctxt: &SignalContext<'_>,
-        limit: u8,
-    ) -> zbus::Result<()>;
-
-    #[dbus_interface(signal)]
-    async fn notify_mains_online(ctxt: &SignalContext<'_>, on: bool) -> zbus::Result<()>;
-}
-
-#[async_trait]
-impl crate::ZbusRun for CtrlPower {
-    async fn add_to_server(self, server: &mut Connection) {
-        Self::add_to_server_helper(self, ZBUS_PATH, server).await;
-    }
-}
-
-#[async_trait]
-impl crate::Reloadable for CtrlPower {
-    async fn reload(&mut self) -> Result<(), RogError> {
-        if let Some(mut config) = self.config.try_lock() {
-            config.read();
-            self.set(config.bat_charge_limit)?;
-        }
-        Ok(())
-    }
-}
-
-impl CtrlPower {
-    task_watch_item!(charge_control_end_threshold power);
-
-    pub fn new(config: Arc<Mutex<Config>>) -> Result<Self, RogError> {
-        Ok(CtrlPower {
-            power: AsusPower::new()?,
-            config,
-        })
-    }
-
-    pub(super) fn set(&self, limit: u8) -> Result<(), RogError> {
-        if !(20..=100).contains(&limit) {
-            return Err(RogError::ChargeLimit(limit));
-        }
-
-        self.power.set_charge_control_end_threshold(limit)?;
-
-        info!("Battery charge limit: {}", limit);
-
-        if let Some(mut config) = self.config.try_lock() {
-            config.read();
-            config.bat_charge_limit = limit;
-            config.write();
-        }
-
-        Ok(())
-    }
-}
-
-#[async_trait]
-impl CtrlTask for CtrlPower {
-    fn zbus_path() -> &'static str {
-        ZBUS_PATH
-    }
-
-    async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
-        let conn = zbus::Connection::system().await?;
-        let sysd1 = SystemdProxy::new(&conn).await?;
-        let sysd2 = sysd1.clone();
-        let sysd3 = sysd1.clone();
-
-        let power1 = self.clone();
-        let power2 = self.clone();
-        self.create_sys_event_tasks(
-            move || async {},
-            move || {
-                let power = power1.clone();
-                let sysd = sysd1.clone();
-                async move {
-                    info!("CtrlCharge reloading charge limit");
-                    let lock = power.config.lock().await;
-                    power
-                        .set(lock.bat_charge_limit)
-                        .map_err(|err| {
-                            warn!("CtrlCharge: set_limit {}", err);
-                            err
-                        })
-                        .ok();
-
-                    if lock.disable_nvidia_powerd_on_battery {
-                        if let Ok(value) = power.power.get_online() {
-                            do_nvidia_powerd_action(&sysd, value == 1).await;
-                        }
-                    }
-                }
-            },
-            move || async {},
-            move || {
-                let power = power2.clone();
-                let sysd = sysd2.clone();
-                async move {
-                    info!("CtrlCharge reloading charge limit");
-                    let lock = power.config.lock().await;
-                    power
-                        .set(lock.bat_charge_limit)
-                        .map_err(|err| {
-                            warn!("CtrlCharge: set_limit {}", err);
-                            err
-                        })
-                        .ok();
-
-                    if lock.disable_nvidia_powerd_on_battery {
-                        if let Ok(value) = power.power.get_online() {
-                            do_nvidia_powerd_action(&sysd, value == 1).await;
-                        }
-                    }
-                }
-            },
-        )
-        .await;
-
-        let config = self.config.clone();
-        self.watch_charge_control_end_threshold(signal_ctxt.clone())
-            .await?;
-
-        let ctrl = self.clone();
-        tokio::spawn(async move {
-            let mut online = 10;
-            loop {
-                if let Ok(value) = ctrl.power.get_online() {
-                    if online != value {
-                        online = value;
-                        let mut config = config.lock().await;
-                        config.read();
-
-                        if config.disable_nvidia_powerd_on_battery {
-                            do_nvidia_powerd_action(&sysd3, value == 1).await;
-                        }
-
-                        Self::notify_mains_online(&signal_ctxt, value == 1)
-                            .await
-                            .unwrap();
-
-                        let mut prog: Vec<&str> = Vec::new();
-                        if value == 1 {
-                            // AC ONLINE
-                            prog = config.ac_command.split_whitespace().collect();
-                        } else if value == 0 {
-                            // BATTERY
-                            prog = config.bat_command.split_whitespace().collect();
-                        }
-
-                        if prog.len() > 1 {
-                            let mut cmd = Command::new(prog[0]);
-                            for arg in prog.iter().skip(1) {
-                                cmd.arg(*arg);
-                            }
-                            if let Err(e) = cmd.spawn() {
-                                if value == 1 {
-                                    error!("AC power command error: {e}");
-                                } else {
-                                    error!("Battery power command error: {e}");
-                                }
-                            }
-                        }
-                    }
-                }
-                // The inotify doesn't pick up events when the kernel changes internal value
-                // so we need to watch it with a thread and sleep unfortunately
-                sleep(Duration::from_secs(1)).await;
-            }
-        });
-
-        Ok(())
-    }
-}
-
-async fn do_nvidia_powerd_action(proxy: &SystemdProxy<'_>, ac_on: bool) {
-    if let Ok(res) = proxy.get_unit_file_state(NVIDIA_POWERD).await {
-        if res == UnitFileState::Enabled {
-            if ac_on {
-                proxy
-                    .start_unit(NVIDIA_POWERD, Mode::Replace)
-                    .await
-                    .map_err(|e| error!("Error stopping {NVIDIA_POWERD}, {e:?}"))
-                    .ok();
-            } else {
-                proxy
-                    .stop_unit(NVIDIA_POWERD, Mode::Replace)
-                    .await
-                    .map_err(|e| error!("Error stopping {NVIDIA_POWERD}, {e:?}"))
-                    .ok();
-            }
-        }
-    }
-}

daemon/src/ctrl_profiles/config.rs

@@ -1,84 +0,0 @@
-use std::path::PathBuf;
-
-use config_traits::{StdConfig, StdConfigLoad};
-use rog_profiles::fan_curve_set::FanCurveSet;
-use rog_profiles::{FanCurveProfiles, Profile};
-use serde_derive::{Deserialize, Serialize};
-
-use crate::CONFIG_PATH_BASE;
-
-const CONFIG_FILE: &str = "profile.ron";
-const CONFIG_FAN_FILE: &str = "fan_curves.ron";
-
-#[derive(Deserialize, Serialize, Debug)]
-pub struct ProfileConfig {
-    /// For restore on boot
-    pub active_profile: Profile,
-}
-
-impl StdConfig for ProfileConfig {
-    fn new() -> Self {
-        Self {
-            active_profile: Profile::Balanced,
-        }
-    }
-
-    fn config_dir() -> std::path::PathBuf {
-        PathBuf::from(CONFIG_PATH_BASE)
-    }
-
-    fn file_name(&self) -> String {
-        CONFIG_FILE.to_string()
-    }
-}
-
-impl StdConfigLoad for ProfileConfig {}
-
-#[derive(Deserialize, Serialize, Debug, Default)]
-pub struct FanCurveConfig {
-    balanced: FanCurveSet,
-    performance: FanCurveSet,
-    quiet: FanCurveSet,
-    #[serde(skip)]
-    device: FanCurveProfiles,
-}
-
-impl FanCurveConfig {
-    pub fn update_device_config(&mut self) {
-        self.balanced = self.device.balanced.clone();
-        self.performance = self.device.performance.clone();
-        self.quiet = self.device.quiet.clone();
-    }
-
-    pub fn update_config(&mut self) {
-        self.balanced = self.device.balanced.clone();
-        self.performance = self.device.performance.clone();
-        self.quiet = self.device.quiet.clone();
-    }
-
-    pub fn device(&self) -> &FanCurveProfiles {
-        &self.device
-    }
-
-    pub fn device_mut(&mut self) -> &mut FanCurveProfiles {
-        &mut self.device
-    }
-}
-
-impl StdConfig for FanCurveConfig {
-    fn new() -> Self {
-        let mut tmp = Self::default();
-        tmp.update_device_config();
-        tmp
-    }
-
-    fn config_dir() -> std::path::PathBuf {
-        PathBuf::from(CONFIG_PATH_BASE)
-    }
-
-    fn file_name(&self) -> String {
-        CONFIG_FAN_FILE.to_string()
-    }
-}
-
-impl StdConfigLoad for FanCurveConfig {}

daemon/src/ctrl_profiles/controller.rs

@@ -1,141 +0,0 @@
-use config_traits::StdConfig;
-use log::{info, warn};
-use rog_platform::platform::AsusPlatform;
-use rog_platform::supported::PlatformProfileFunctions;
-use rog_profiles::error::ProfileError;
-use rog_profiles::{FanCurveProfiles, Profile};
-
-use super::config::{FanCurveConfig, ProfileConfig};
-use crate::error::RogError;
-use crate::GetSupported;
-
-pub struct CtrlPlatformProfile {
-    pub profile_config: ProfileConfig,
-    pub fan_config: Option<FanCurveConfig>,
-    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 {
-                profile_config: config,
-                fan_config: None,
-                platform,
-            };
-            if FanCurveProfiles::get_device().is_ok() {
-                info!("Device has fan curves available");
-                if controller.fan_config.is_none() {
-                    controller.fan_config = 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.fan_config.as_ref() {
-                            info!(
-                                "{active:?}: {}",
-                                String::from(curves.device().get_fan_curves_for(active))
-                            );
-                            curves.write();
-                        }
-                    }
-                }
-            }
-
-            return Ok(controller);
-        }
-
-        Err(ProfileError::NotSupported.into())
-    }
-
-    pub fn save_config(&mut self) {
-        self.profile_config.write();
-        if let Some(fans) = self.fan_config.as_mut() {
-            fans.update_config();
-            fans.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.profile_config.active_profile {
-            Profile::Balanced => {
-                Profile::set_profile(Profile::Performance)?;
-                self.profile_config.active_profile = Profile::Performance;
-            }
-            Profile::Performance => {
-                Profile::set_profile(Profile::Quiet)?;
-                self.profile_config.active_profile = Profile::Quiet;
-            }
-            Profile::Quiet => {
-                Profile::set_profile(Profile::Balanced)?;
-                self.profile_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.fan_config {
-            if let Ok(mut device) = FanCurveProfiles::get_device() {
-                curves.device_mut().write_profile_curve_to_platform(
-                    self.profile_config.active_profile,
-                    &mut device,
-                )?;
-            }
-        }
-        Ok(())
-    }
-
-    pub(super) fn set_active_curve_to_defaults(&mut self) -> Result<(), RogError> {
-        if let Some(curves) = self.fan_config.as_mut() {
-            if let Ok(mut device) = FanCurveProfiles::get_device() {
-                curves.device_mut().set_active_curve_to_defaults(
-                    self.profile_config.active_profile,
-                    &mut device,
-                )?;
-                curves.update_config();
-            }
-        }
-        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,312 +0,0 @@
-use std::str::FromStr;
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use config_traits::StdConfig;
-use log::{error, info, warn};
-use rog_profiles::fan_curve_set::{CurveData, FanCurveSet};
-use rog_profiles::{FanCurveProfiles, Profile};
-use zbus::export::futures_util::lock::Mutex;
-use zbus::export::futures_util::StreamExt;
-use zbus::fdo::Error;
-use zbus::{dbus_interface, Connection, SignalContext};
-
-use super::controller::CtrlPlatformProfile;
-use crate::error::RogError;
-use crate::CtrlTask;
-
-const 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.profile_config.active_profile)
-            .await
-            .ok();
-    }
-
-    /// Fetch the active profile name
-    async fn active_profile(&mut self) -> zbus::fdo::Result<Profile> {
-        let mut ctrl = self.0.lock().await;
-        ctrl.profile_config.read();
-        Ok(ctrl.profile_config.active_profile)
-    }
-
-    /// Set this platform_profile name as active
-    async fn set_active_profile(
-        &self,
-        #[zbus(signal_context)] ctxt: SignalContext<'_>,
-        profile: Profile,
-    ) {
-        let mut ctrl = self.0.lock().await;
-        // Read first just incase the user has modified the config before calling this
-        ctrl.profile_config.read();
-        Profile::set_profile(profile)
-            .map_err(|e| warn!("set_profile, {}", e))
-            .ok();
-        ctrl.profile_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.profile_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.profile_config.read();
-        if let Some(curves) = &mut ctrl.fan_config {
-            return Ok(curves.device().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.profile_config.read();
-        if let Some(curves) = &mut ctrl.fan_config {
-            curves
-                .device_mut()
-                .set_profile_curve_enabled(profile, enabled);
-            curves.update_config();
-
-            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.profile_config.read();
-        if let Some(curves) = &mut ctrl.fan_config {
-            let curve = curves.device().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.profile_config.read();
-        if let Some(curves) = &mut ctrl.fan_config {
-            curves
-                .device_mut()
-                .save_fan_curve(curve, profile)
-                .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
-            curves.update_config();
-        } 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.profile_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.profile_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 sig_ctx = signal_ctxt.clone();
-        let mut watch = self
-            .0
-            .lock()
-            .await
-            .platform
-            .monitor_throttle_thermal_policy()?;
-
-        tokio::spawn(async move {
-            let mut buffer = [0; 32];
-            if let Ok(stream) = watch.event_stream(&mut buffer) {
-                stream
-                    .for_each(|_| async {
-                        let mut lock = ctrl.lock().await;
-                        if let Ok(profile) =
-                            lock.platform.get_throttle_thermal_policy().map_err(|e| {
-                                error!("get_throttle_thermal_policy error: {e}");
-                            })
-                        {
-                            let new_profile = Profile::from_throttle_thermal_policy(profile);
-                            if new_profile != lock.profile_config.active_profile {
-                                info!("platform_profile changed to {new_profile}");
-                                lock.profile_config.active_profile = new_profile;
-                                lock.write_profile_curve_to_platform().unwrap();
-                                lock.save_config();
-                                Profile::set_profile(lock.profile_config.active_profile)
-                                    .map_err(|e| {
-                                        error!("Profile::set_profile() error: {e}");
-                                    })
-                                    .ok();
-                            }
-                            Self::notify_profile(&sig_ctx, lock.profile_config.active_profile)
-                                .await
-                                .ok();
-                        }
-                    })
-                    .await;
-            }
-        });
-
-        let ctrl = self.0.clone();
-        let mut watch = self.0.lock().await.platform.monitor_platform_profile()?;
-
-        tokio::spawn(async move {
-            let mut buffer = [0; 32];
-            if let Ok(stream) = watch.event_stream(&mut buffer) {
-                stream
-                    .for_each(|_| async {
-                        let mut lock = ctrl.lock().await;
-                        if let Ok(profile) = lock.platform.get_platform_profile().map_err(|e| {
-                            error!("get_platform_profile error: {e}");
-                        }) {
-                            if let Ok(new_profile) = Profile::from_str(&profile).map_err(|e| {
-                                error!("Profile::from_str(&profile) error: {e}");
-                            }) {
-                                if new_profile != lock.profile_config.active_profile {
-                                    info!("platform_profile changed to {new_profile}");
-                                    lock.profile_config.active_profile = new_profile;
-                                    lock.write_profile_curve_to_platform().unwrap();
-                                    lock.save_config();
-                                    Profile::set_profile(lock.profile_config.active_profile)
-                                        .map_err(|e| {
-                                            error!("Profile::set_profile() error: {e}");
-                                        })
-                                        .ok();
-                                }
-                                Self::notify_profile(
-                                    &signal_ctxt,
-                                    lock.profile_config.active_profile,
-                                )
-                                .await
-                                .ok();
-                            }
-                        }
-                    })
-                    .await;
-            }
-        });
-
-        Ok(())
-    }
-}
-
-#[async_trait]
-impl crate::Reloadable for ProfileZbus {
-    /// Fetch the active profile and use that to set all related components up
-    async fn reload(&mut self) -> Result<(), RogError> {
-        let mut ctrl = self.0.lock().await;
-        let active = ctrl.profile_config.active_profile;
-        if let Some(curves) = &mut ctrl.fan_config {
-            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
-                    .device_mut()
-                    .write_profile_curve_to_platform(active, &mut device)?;
-                curves.update_config();
-                ctrl.profile_config.write();
-            }
-        }
-        Ok(())
-    }
-}

daemon/src/ctrl_supported.rs

@@ -1,42 +0,0 @@
-use async_trait::async_trait;
-use serde_derive::{Deserialize, Serialize};
-use zbus::zvariant::Type;
-use zbus::{dbus_interface, Connection};
-
-use crate::ctrl_anime::CtrlAnime;
-use crate::ctrl_aura::controller::CtrlKbdLed;
-use crate::ctrl_platform::CtrlPlatform;
-use crate::ctrl_power::CtrlPower;
-use crate::ctrl_profiles::controller::CtrlPlatformProfile;
-use crate::GetSupported;
-
-#[derive(Serialize, Deserialize, Debug, Type)]
-pub struct SupportedFunctions(rog_platform::supported::SupportedFunctions);
-
-#[dbus_interface(name = "org.asuslinux.Daemon")]
-impl SupportedFunctions {
-    pub fn supported_functions(&self) -> &rog_platform::supported::SupportedFunctions {
-        &self.0
-    }
-}
-
-#[async_trait]
-impl crate::ZbusRun for SupportedFunctions {
-    async fn add_to_server(self, server: &mut Connection) {
-        Self::add_to_server_helper(self, "/org/asuslinux/Supported", server).await;
-    }
-}
-
-impl GetSupported for SupportedFunctions {
-    type A = SupportedFunctions;
-
-    fn get_supported() -> Self::A {
-        Self(rog_platform::supported::SupportedFunctions {
-            anime_ctrl: CtrlAnime::get_supported(),
-            keyboard_led: CtrlKbdLed::get_supported(),
-            charge_ctrl: CtrlPower::get_supported(),
-            platform_profile: CtrlPlatformProfile::get_supported(),
-            rog_bios_ctrl: CtrlPlatform::get_supported(),
-        })
-    }
-}

daemon/src/daemon.rs

@@ -1,165 +0,0 @@
-use std::env;
-use std::error::Error;
-use std::io::Write;
-use std::sync::Arc;
-use std::time::Duration;
-
-use ::zbus::export::futures_util::lock::Mutex;
-use ::zbus::Connection;
-use config_traits::{StdConfig, StdConfigLoad, StdConfigLoad2};
-use daemon::config::Config;
-use daemon::ctrl_anime::config::AnimeConfig;
-use daemon::ctrl_anime::trait_impls::CtrlAnimeZbus;
-use daemon::ctrl_anime::CtrlAnime;
-use daemon::ctrl_aura::config::AuraConfig;
-use daemon::ctrl_aura::controller::CtrlKbdLed;
-use daemon::ctrl_aura::trait_impls::CtrlKbdLedZbus;
-use daemon::ctrl_platform::CtrlPlatform;
-use daemon::ctrl_power::CtrlPower;
-use daemon::ctrl_profiles::config::ProfileConfig;
-use daemon::ctrl_profiles::controller::CtrlPlatformProfile;
-use daemon::ctrl_profiles::trait_impls::ProfileZbus;
-use daemon::ctrl_supported::SupportedFunctions;
-use daemon::{print_board_info, CtrlTask, GetSupported, Reloadable, ZbusRun};
-use log::{error, info, warn};
-use rog_aura::aura_detection::LaptopLedData;
-use rog_dbus::DBUS_NAME;
-use rog_profiles::Profile;
-use tokio::time::sleep;
-use zbus::SignalContext;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut logger = env_logger::Builder::new();
-    logger
-        .parse_default_env()
-        .target(env_logger::Target::Stdout)
-        .format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()))
-        .init();
-
-    let is_service = match env::var_os("IS_SERVICE") {
-        Some(val) => val == "1",
-        None => false,
-    };
-
-    if !is_service {
-        println!("asusd schould be only run from the right systemd service");
-        println!(
-            "do not run in your terminal, if you need an logs please use journalctl -b -u asusd"
-        );
-        println!("asusd will now exit");
-        return Ok(());
-    }
-
-    info!("       daemon v{}", daemon::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);
-
-    start_daemon().await?;
-    Ok(())
-}
-
-/// The actual main loop for the daemon
-async fn start_daemon() -> Result<(), Box<dyn Error>> {
-    let supported = SupportedFunctions::get_supported();
-    print_board_info();
-    println!("{}", supported.supported_functions());
-
-    // Start zbus server
-    let mut connection = Connection::system().await?;
-
-    let config = Config::new().load();
-    let config = Arc::new(Mutex::new(config));
-
-    supported.add_to_server(&mut connection).await;
-
-    match CtrlPlatform::new(config.clone()) {
-        Ok(ctrl) => {
-            let sig_ctx = CtrlPlatform::signal_context(&connection)?;
-            start_tasks(ctrl, &mut connection, sig_ctx).await?;
-        }
-        Err(err) => {
-            error!("CtrlPlatform: {}", err);
-        }
-    }
-
-    match CtrlPower::new(config.clone()) {
-        Ok(ctrl) => {
-            let sig_ctx = CtrlPower::signal_context(&connection)?;
-            start_tasks(ctrl, &mut connection, sig_ctx).await?;
-        }
-        Err(err) => {
-            error!("CtrlPower: {}", err);
-        }
-    }
-
-    if Profile::is_platform_profile_supported() {
-        let profile_config = ProfileConfig::new().load();
-        match CtrlPlatformProfile::new(profile_config) {
-            Ok(ctrl) => {
-                let zbus = ProfileZbus(Arc::new(Mutex::new(ctrl)));
-                let sig_ctx = ProfileZbus::signal_context(&connection)?;
-                start_tasks(zbus, &mut connection, sig_ctx).await?;
-            }
-            Err(err) => {
-                error!("Profile control: {}", err);
-            }
-        }
-    } else {
-        warn!("platform_profile support not found");
-    }
-
-    match CtrlAnime::new(AnimeConfig::new().load()) {
-        Ok(ctrl) => {
-            let zbus = CtrlAnimeZbus(Arc::new(Mutex::new(ctrl)));
-            let sig_ctx = CtrlAnimeZbus::signal_context(&connection)?;
-            start_tasks(zbus, &mut connection, sig_ctx).await?;
-        }
-        Err(err) => {
-            info!("AniMe control: {}", err);
-        }
-    }
-
-    let laptop = LaptopLedData::get_data();
-    let aura_config = AuraConfig::new().load();
-    match CtrlKbdLed::new(laptop, aura_config) {
-        Ok(ctrl) => {
-            let zbus = CtrlKbdLedZbus(Arc::new(Mutex::new(ctrl)));
-            let sig_ctx = CtrlKbdLedZbus::signal_context(&connection)?;
-            start_tasks(zbus, &mut connection, sig_ctx).await?;
-        }
-        Err(err) => {
-            error!("Keyboard control: {}", err);
-        }
-    }
-
-    // Request dbus name after finishing initalizing all functions
-    connection.request_name(DBUS_NAME).await?;
-
-    loop {
-        // This is just a blocker to idle and ensure the reator reacts
-        sleep(Duration::from_millis(1000)).await;
-    }
-}
-
-async fn start_tasks<T>(
-    mut zbus: T,
-    connection: &mut Connection,
-    signal_ctx: SignalContext<'static>,
-) -> Result<(), Box<dyn Error>>
-where
-    T: ZbusRun + Reloadable + CtrlTask + Clone,
-{
-    let task = zbus.clone();
-
-    zbus.reload()
-        .await
-        .unwrap_or_else(|err| warn!("Controller error: {}", err));
-    zbus.add_to_server(connection).await;
-
-    task.create_tasks(signal_ctx).await.ok();
-    Ok(())
-}

daemon/src/lib.rs

@@ -1,229 +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;
-
-/// Fetch all supported functions for the laptop
-pub mod ctrl_supported;
-
-pub mod error;
-
-use std::future::Future;
-
-use async_trait::async_trait;
-use log::{debug, info, warn};
-use logind_zbus::manager::ManagerProxy;
-use zbus::export::futures_util::StreamExt;
-use zbus::zvariant::ObjectPath;
-use zbus::{Connection, SignalContext};
-
-use crate::error::RogError;
-
-const CONFIG_PATH_BASE: &str = "/etc/asusd/";
-
-/// 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");
-
-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());
-}
-
-#[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.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"
 
@@ -10,6 +7,7 @@ ENV{DMI_FAMILY}=="*ROG*", GOTO="asusd_start"
 ENV{DMI_FAMILY}=="*Zephyrus*", GOTO="asusd_start"
 ENV{DMI_FAMILY}=="*Strix*", GOTO="asusd_start"
 ENV{DMI_FAMILY}=="*Vivo*ook*", GOTO="asusd_start"
+ENV{DMI_FAMILY}=="*Zenbook*", GOTO="asusd_start"
 # No match so
 GOTO="asusd_end"
 

data/asusd.service

@@ -1,19 +1,18 @@
 [Unit]
 Description=ASUS Notebook Control
-StartLimitInterval=200
-StartLimitBurst=2
-Before=multi-user.target
-After=power-profiles-daemon.service
-After=nvidia-powerd.service
+StartLimitInterval=500
+StartLimitBurst=5
+After=nvidia-powerd.service systemd-udevd.service
 
 [Service]
 Environment=IS_SERVICE=1
 Environment=RUST_LOG="info"
-ExecStartPre=/bin/sleep 2
+# required to prevent init issues with hid_asus and MCU
+ExecStartPre=/bin/sleep 1
 ExecStart=/usr/bin/asusd
 Restart=on-failure
 RestartSec=1
 Type=dbus
 BusName=org.asuslinux.Daemon
 SELinuxContext=system_u:system_r:unconfined_t:s0
-#SELinuxContext=system_u:object_r:modules_object_t:s0
+#SELinuxContext=system_u:object_r:modules_object_t:s0

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>

distro-packaging/asusctl.spec

@@ -0,0 +1,138 @@
+#
+# spec file for package asus-nb-ctrl
+#
+# Copyright (c) 2020-2021 Luke Jones <luke@ljones.dev>
+#
+# All modifications and additions to the file contributed by third parties
+# remain the property of their copyright owners, unless otherwise agreed
+# upon. The license for this file, and modifications and additions to the
+# file, is the same license as for the pristine package itself (unless the
+# license for the pristine package is not an Open Source License, in which
+# case the license is the MIT License). An "Open Source License" is a
+# license that conforms to the Open Source Definition (Version 1.9)
+# published by the Open Source Initiative.
+
+# 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 https://mozilla.org/MPL/2.0/.
+
+%if %{defined fedora}
+%global debug_package %{nil}
+%endif
+
+%define specrelease %{?dist}
+%define pkg_release 3%{specrelease}
+
+# Use hardening ldflags.
+%global rustflags -Clink-arg=-Wl,-z,relro,-z,now
+Name:           asusctl
+Version:        6.0.7
+Release: %{pkg_release}
+Summary:        Control fan speeds, LEDs, graphics modes, and charge levels for ASUS notebooks
+License:        MPLv2
+
+Group:          System Environment/Kernel
+
+URL:            https://gitlab.com/asus-linux/asusctl
+Source:         %{name}-%{version}.tar.gz
+Source1:        vendor_%{name}_%{version}.tar.xz
+Source2:        cargo-config
+
+BuildRequires:  cargo
+BuildRequires:  rust-packaging
+BuildRequires:  systemd-rpm-macros
+BuildRequires:  clang-devel
+BuildRequires:  cmake
+BuildRequires:  rust
+BuildRequires:  rust-std-static
+BuildRequires:  pkgconfig(expat)
+BuildRequires:  pkgconfig(gbm)
+BuildRequires:  pkgconfig(dbus-1)
+BuildRequires:  pkgconfig(libdrm)
+BuildRequires:  pkgconfig(libinput)
+BuildRequires:  pkgconfig(libseat)
+BuildRequires:  pkgconfig(libudev)
+BuildRequires:  pkgconfig(xkbcommon)
+BuildRequires:  pkgconfig(libzstd)
+BuildRequires:  pkgconfig(gtk+-3.0)
+BuildRequires:  pkgconfig(gdk-3.0)
+BuildRequires:  desktop-file-utils
+
+# expat-devel pcre2-devel
+
+%description
+asus-nb-ctrl is a utility for Linux to control many aspects of various
+ASUS laptops but can also be used with non-Asus laptops with reduced features.
+
+It provides an interface for rootless control of some system functions such as
+fan speeds, keyboard LEDs, battery charge level, and graphics modes.
+asus-nb-ctrl enables third-party apps to use the above with dbus methods.
+
+%package rog-gui
+Summary: An experimental GUI for %{name}
+
+%description rog-gui
+A one-stop-shop GUI tool for asusd/asusctl. It aims to provide most controls,
+a notification service, and ability to run in the background.
+
+%prep
+# %setup -D -T -a 1 -c -n %{name}-%{version}/vendor
+# %setup -D -T -a 0 -c
+%autosetup
+%setup -D -T -a 1
+
+mv Cargo.lock{,.bak}
+%cargo_prep
+mv Cargo.lock{.bak,}
+sed -i 's|replace-with = "local-registry"|replace-with = "vendored-sources"|' .cargo/config
+cat %{SOURCE2} >> .cargo/config
+
+%build
+export RUSTFLAGS="%{rustflags}"
+%cargo_build
+#cargo build --release --frozen --offline --config .cargo/config.toml
+
+%install
+export RUSTFLAGS="%{rustflags}"
+mkdir -p "%{buildroot}/%{_bindir}" "%{buildroot}%{_docdir}"
+%make_install
+
+install -D -m 0644 README.md %{buildroot}/%{_docdir}/%{name}/README.md
+install -D -m 0644 rog-anime/README.md %{buildroot}/%{_docdir}/%{name}/README-anime.md
+install -D -m 0644 rog-anime/data/diagonal-template.png %{buildroot}/%{_docdir}/%{name}/diagonal-template.png
+
+desktop-file-validate %{buildroot}/%{_datadir}/applications/rog-control-center.desktop
+
+%files
+%license LICENSE
+%{_bindir}/asusd
+%{_bindir}/asusd-user
+%{_bindir}/asusctl
+%{_unitdir}/asusd.service
+%{_userunitdir}/asusd-user.service
+%{_udevrulesdir}/99-asusd.rules
+#%dir %{_sysconfdir}/asusd/
+%{_datadir}/asusd/aura_support.ron
+%{_datadir}/dbus-1/system.d/asusd.conf
+%{_datadir}/icons/hicolor/512x512/apps/asus_notif_yellow.png
+%{_datadir}/icons/hicolor/512x512/apps/asus_notif_green.png
+%{_datadir}/icons/hicolor/512x512/apps/asus_notif_red.png
+%{_datadir}/icons/hicolor/512x512/apps/asus_notif_blue.png
+%{_datadir}/icons/hicolor/512x512/apps/asus_notif_orange.png
+%{_datadir}/icons/hicolor/512x512/apps/asus_notif_white.png
+%{_datadir}/icons/hicolor/scalable/status/gpu-compute.svg
+%{_datadir}/icons/hicolor/scalable/status/gpu-hybrid.svg
+%{_datadir}/icons/hicolor/scalable/status/gpu-integrated.svg
+%{_datadir}/icons/hicolor/scalable/status/gpu-nvidia.svg
+%{_datadir}/icons/hicolor/scalable/status/gpu-vfio.svg
+%{_datadir}/icons/hicolor/scalable/status/notification-reboot.svg
+%{_docdir}/%{name}/
+%{_datadir}/asusd/
+
+%files rog-gui
+%{_bindir}/rog-control-center
+%{_datadir}/applications/rog-control-center.desktop
+%{_datadir}/icons/hicolor/512x512/apps/rog-control-center.png
+%{_datadir}/rog-gui
+
+%changelog

dmi-id/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "dmi_id"
+license.workspace = true
+version.workspace = true
+readme.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+edition.workspace = true
+
+[dependencies]
+log.workspace = true
+udev.workspace = true

dmi-id/src/lib.rs

@@ -0,0 +1,113 @@
+use log::{info, warn};
+
+#[derive(Debug, Default, PartialEq, Eq, PartialOrd, Clone)]
+pub struct DMIID {
+    pub id_model: String,
+    pub dmi_family: String,
+    pub dmi_vendor: String,
+    pub board_name: String,
+    pub board_vendor: String,
+    pub bios_date: String,
+    pub bios_release: String,
+    pub bios_vendor: String,
+    pub bios_version: String,
+    pub product_family: String,
+    pub product_name: String,
+}
+
+impl DMIID {
+    pub fn new() -> Result<Self, String> {
+        let mut enumerator = udev::Enumerator::new().map_err(|err| {
+            warn!("{}", err);
+            format!("dmi enumerator failed: {err}")
+        })?;
+
+        enumerator.match_subsystem("dmi").map_err(|err| {
+            warn!("{}", err);
+            format!("dmi match_subsystem failed: {err}")
+        })?;
+
+        let mut result = enumerator.scan_devices().map_err(|err| {
+            warn!("{}", err);
+            format!("dmi scan_devices failed: {err}")
+        })?;
+
+        if let Some(device) = (result).next() {
+            info!("Found dmi ID info at {:?}", device.sysname());
+
+            return Ok(Self {
+                id_model: device
+                    .property_value("ID_MODEL")
+                    .map(|s| s.to_string_lossy().to_string())
+                    .unwrap_or("Unknown".to_string()),
+                dmi_family: device
+                    .property_value("DMI_FAMILY")
+                    .map(|s| s.to_string_lossy().to_string())
+                    .unwrap_or("Unknown".to_string()),
+                dmi_vendor: device
+                    .property_value("DMI_VENDOR")
+                    .map(|s| s.to_string_lossy().to_string())
+                    .unwrap_or("Unknown".to_string()),
+                board_name: device
+                    .attribute_value("board_name")
+                    .map(|s| s.to_string_lossy().to_string())
+                    .unwrap_or("Unknown".to_string()),
+                board_vendor: device
+                    .attribute_value("board_vendor")
+                    .map(|s| s.to_string_lossy().to_string())
+                    .unwrap_or("Unknown".to_string()),
+                bios_date: device
+                    .attribute_value("bios_date")
+                    .map(|s| s.to_string_lossy().to_string())
+                    .unwrap_or("Unknown".to_string()),
+                bios_release: device
+                    .attribute_value("bios_release")
+                    .map(|s| s.to_string_lossy().to_string())
+                    .unwrap_or("Unknown".to_string()),
+                bios_vendor: device
+                    .attribute_value("bios_vendor")
+                    .map(|s| s.to_string_lossy().to_string())
+                    .unwrap_or("Unknown".to_string()),
+                bios_version: device
+                    .attribute_value("bios_version")
+                    .map(|s| s.to_string_lossy().to_string())
+                    .unwrap_or("Unknown".to_string()),
+                product_family: device
+                    .attribute_value("product_family")
+                    .map(|s| s.to_string_lossy().to_string())
+                    .unwrap_or("Unknown".to_string()),
+                product_name: device
+                    .attribute_value("product_name")
+                    .map(|s| s.to_string_lossy().to_string())
+                    .unwrap_or("Unknown".to_string()),
+            });
+        }
+        Err("dmi not found".into())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[ignore = "Does not run in docker images"]
+    fn dmi_sysfs_properties_not_unknown() {
+        let dmi = DMIID::new().unwrap();
+
+        assert_ne!(dmi.id_model, "Unknown".to_string());
+        dbg!(dmi.id_model);
+        assert_ne!(dmi.dmi_family, "Unknown".to_string());
+        dbg!(dmi.dmi_family);
+        assert_ne!(dmi.dmi_vendor, "Unknown".to_string());
+        dbg!(dmi.dmi_vendor);
+        assert_ne!(dmi.board_name, "Unknown".to_string());
+        dbg!(dmi.board_name);
+        assert_ne!(dmi.board_vendor, "Unknown".to_string());
+        dbg!(dmi.board_vendor);
+        assert_ne!(dmi.product_family, "Unknown".to_string());
+        dbg!(dmi.product_family);
+        assert_ne!(dmi.product_name, "Unknown".to_string());
+        dbg!(dmi.product_name);
+    }
+}

rog-anime/Cargo.toml

@@ -1,21 +1,25 @@
 [package]
 name = "rog_anime"
-license = "MPL-2.0"
+license.workspace = true
 version.workspace = true
-readme = "README.md"
-authors = ["Luke <luke@ljones.dev>"]
-repository = "https://gitlab.com/asus-linux/asus-nb-ctrl"
-homepage = "https://gitlab.com/asus-linux/asus-nb-ctrl"
+readme.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+edition.workspace = true
 documentation = "https://docs.rs/rog-anime"
 description = "Types useful for translating images and other data for display on the ASUS AniMe Matrix display"
 keywords = ["ROG", "ASUS", "AniMe"]
-edition = "2021"
 exclude = ["data"]
 
 [features]
 default = ["dbus", "detect"]
 dbus = ["zbus"]
-detect = ["sysfs-class"]
+detect = ["dmi_id"]
+
+[lib]
+name = "rog_anime"
+path = "src/lib.rs"
 
 [dependencies]
 png_pong.workspace = true
@@ -24,12 +28,16 @@ gif.workspace = true
 log.workspace = true
 
 serde.workspace = true
-serde_derive.workspace = true
 
 glam.workspace = true
+typeshare.workspace = true
 
 zbus = { workspace = true, optional = true }
 
-sysfs-class = { workspace = true, optional = true }
+dmi_id = { path = "../dmi-id", optional = true }
 
-uhid-virt = "^0.0.5"
+[dev-dependencies]
+cargo-husky.workspace = true
+
+[package.metadata.cargo-machete]
+ignored = ["serde"]

rog-anime/src/data.rs

@@ -1,13 +1,16 @@
 use std::convert::TryFrom;
+use std::str::FromStr;
 use std::thread::sleep;
 use std::time::{Duration, Instant};
 
 use log::info;
-use serde_derive::{Deserialize, Serialize};
+use serde::{Deserialize, Serialize};
+use typeshare::typeshare;
 #[cfg(feature = "dbus")]
-use zbus::zvariant::Type;
+use zbus::zvariant::{OwnedValue, Type, Value};
 
 use crate::error::{AnimeError, Result};
+use crate::usb::{AnimAwake, AnimBooting, AnimShutdown, AnimSleeping, Brightness};
 use crate::{AnimTime, AnimeGif};
 
 /// The first 7 bytes of a USB packet are accounted for by `USB_PREFIX1` and
@@ -19,32 +22,68 @@ const BLOCK_END: usize = 634;
 const PANE_LEN: usize = BLOCK_END - BLOCK_START;
 
 /// First packet is for GA401 + GA402
-const USB_PREFIX1: [u8; 7] = [0x5e, 0xc0, 0x02, 0x01, 0x00, 0x73, 0x02];
+pub const USB_PREFIX1: [u8; 7] = [0x5e, 0xc0, 0x02, 0x01, 0x00, 0x73, 0x02];
 /// Second packet is for GA401 + GA402
-const USB_PREFIX2: [u8; 7] = [0x5e, 0xc0, 0x02, 0x74, 0x02, 0x73, 0x02];
+pub const USB_PREFIX2: [u8; 7] = [0x5e, 0xc0, 0x02, 0x74, 0x02, 0x73, 0x02];
 /// Third packet is for GA402 matrix
-const USB_PREFIX3: [u8; 7] = [0x5e, 0xc0, 0x02, 0xe7, 0x04, 0x73, 0x02];
+pub const USB_PREFIX3: [u8; 7] = [0x5e, 0xc0, 0x02, 0xe7, 0x04, 0x73, 0x02];
 
-#[cfg_attr(feature = "dbus", derive(Type))]
-#[derive(Debug, PartialEq, Eq, Copy, Clone, Deserialize, Serialize)]
-pub struct AnimePowerStates {
-    pub brightness: u8,
-    pub enabled: bool,
-    pub boot_anim_enabled: bool,
+#[typeshare]
+#[cfg_attr(feature = "dbus", derive(Type, Value, OwnedValue))]
+#[typeshare]
+#[derive(Default, Deserialize, PartialEq, Eq, Clone, Copy, Serialize, Debug)]
+pub struct Animations {
+    pub boot: AnimBooting,
+    pub awake: AnimAwake,
+    pub sleep: AnimSleeping,
+    pub shutdown: AnimShutdown,
 }
 
+// TODO: move this out
+#[typeshare]
 #[cfg_attr(feature = "dbus", derive(Type))]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize)]
+#[typeshare]
+#[derive(Debug, PartialEq, Eq, Copy, Clone, Deserialize, Serialize)]
+pub struct DeviceState {
+    pub display_enabled: bool,
+    pub display_brightness: Brightness,
+    pub builtin_anims_enabled: bool,
+    pub builtin_anims: Animations,
+    pub off_when_unplugged: bool,
+    pub off_when_suspended: bool,
+    pub off_when_lid_closed: bool,
+    pub brightness_on_battery: Brightness,
+}
+
+#[typeshare]
+#[cfg_attr(feature = "dbus", derive(Type), zvariant(signature = "s"))]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Deserialize, Serialize)]
 pub enum AnimeType {
     GA401,
     GA402,
+    GU604,
+    Unsupported,
+}
+
+impl FromStr for AnimeType {
+    type Err = AnimeError;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        Ok(match s {
+            "ga401" | "GA401" => Self::GA401,
+            "ga402" | "GA402" => Self::GA402,
+            "gu604" | "GU604" => Self::GU604,
+            _ => Self::Unsupported,
+        })
+    }
 }
 
 impl AnimeType {
     /// The width of diagonal images
     pub fn width(&self) -> usize {
         match self {
-            AnimeType::GA401 | AnimeType::GA402 => 74,
+            AnimeType::GU604 => 70,
+            _ => 74,
         }
     }
 
@@ -52,7 +91,8 @@ impl AnimeType {
     pub fn height(&self) -> usize {
         match self {
             AnimeType::GA401 => 36,
-            AnimeType::GA402 => 39,
+            AnimeType::GU604 => 43,
+            _ => 39,
         }
     }
 
@@ -60,7 +100,8 @@ impl AnimeType {
     pub fn data_length(&self) -> usize {
         match self {
             AnimeType::GA401 => PANE_LEN * 2,
-            AnimeType::GA402 => PANE_LEN * 3,
+            AnimeType::GU604 => PANE_LEN * 3,
+            _ => PANE_LEN * 3,
         }
     }
 }
@@ -111,7 +152,7 @@ impl AnimeDataBuffer {
     }
 }
 
-/// The two packets to be written to USB
+/// The packets to be written to USB
 pub type AnimePacketType = Vec<[u8; 640]>;
 
 impl TryFrom<AnimeDataBuffer> for AnimePacketType {
@@ -124,7 +165,7 @@ impl TryFrom<AnimeDataBuffer> for AnimePacketType {
 
         let mut buffers = match anime.anime {
             AnimeType::GA401 => vec![[0; 640]; 2],
-            AnimeType::GA402 => vec![[0; 640]; 3],
+            AnimeType::GA402 | AnimeType::GU604 | AnimeType::Unsupported => vec![[0; 640]; 3],
         };
 
         for (idx, chunk) in anime.data.as_slice().chunks(PANE_LEN).enumerate() {
@@ -133,7 +174,10 @@ impl TryFrom<AnimeDataBuffer> for AnimePacketType {
         buffers[0][..7].copy_from_slice(&USB_PREFIX1);
         buffers[1][..7].copy_from_slice(&USB_PREFIX2);
 
-        if matches!(anime.anime, AnimeType::GA402) {
+        if matches!(
+            anime.anime,
+            AnimeType::GA402 | AnimeType::GU604 | AnimeType::Unsupported
+        ) {
             buffers[2][..7].copy_from_slice(&USB_PREFIX3);
         }
         Ok(buffers)
@@ -212,7 +256,7 @@ pub fn run_animation(frames: &AnimeGif, callback: &dyn Fn(AnimeDataBuffer) -> Re
 
             // TODO: Log this error
             if matches!(callback(output), Ok(true)) {
-                info!("rog-anime: frame-loop callback asked to exit early");
+                info!("rog-anime: animation frame-loop callback asked to exit early");
                 return;
             }
 

rog-anime/src/diagonal.rs

@@ -1,13 +1,17 @@
+//! This is full of crap code which is basically bruteforced
+
 use std::path::Path;
 use std::time::Duration;
 
+use log::error;
+
 use crate::data::AnimeDataBuffer;
 use crate::error::{AnimeError, Result};
 use crate::AnimeType;
 
 /// Mostly intended to be used with ASUS gifs, but can be used for other
 /// purposes (like images)
-#[derive(Debug, Clone)]
+#[allow(dead_code)]
 pub struct AnimeDiagonal(AnimeType, Vec<Vec<u8>>, Option<Duration>);
 
 impl AnimeDiagonal {
@@ -47,7 +51,10 @@ impl AnimeDiagonal {
         bright: f32,
         anime_type: AnimeType,
     ) -> Result<Self> {
-        let data = std::fs::read(path)?;
+        let data = std::fs::read(path).map_err(|e| {
+            error!("Could not open {path:?}: {e:?}");
+            e
+        })?;
         let data = std::io::Cursor::new(data);
         let decoder = png_pong::Decoder::new(data)?.into_steps();
         let png_pong::Step { raster, delay: _ } = decoder.last().ok_or(AnimeError::NoFrames)??;
@@ -138,7 +145,8 @@ impl AnimeDiagonal {
     pub fn into_data_buffer(&self, anime_type: AnimeType) -> Result<AnimeDataBuffer> {
         match anime_type {
             AnimeType::GA401 => self.to_ga401_packets(),
-            AnimeType::GA402 => self.to_ga402_packets(),
+            AnimeType::GU604 => self.to_gu604_packets(),
+            _ => self.to_ga402_packets(),
         }
     }
 
@@ -288,388 +296,89 @@ impl AnimeDiagonal {
 
         AnimeDataBuffer::from_vec(crate::AnimeType::GA402, buf)
     }
-}
 
-#[cfg(test)]
-mod tests {
-    use std::convert::TryFrom;
-    use std::path::PathBuf;
+    fn to_gu604_packets(&self) -> Result<AnimeDataBuffer> {
+        let mut buf = vec![0u8; AnimeType::GU604.data_length()];
+        let mut start_index: usize = 0;
 
-    use crate::{AnimeDiagonal, AnimePacketType, AnimeType};
+        fn copy_slice(
+            buf: &mut [u8],
+            anime: &AnimeDiagonal,
+            x: usize,
+            y: usize,
+            start_index: &mut usize,
+            len: usize,
+        ) {
+            buf[*start_index..*start_index + len].copy_from_slice(&anime.get_row(x, y, len));
+            *start_index += len;
+        }
 
-    #[test]
-    fn ga401_diagonal_packet_check() {
-        let pkt0_check = [
-            0x5e, 0xc0, 0x2, 0x1, 0x0, 0x73, 0x2, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0xff, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0xff, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
-            0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0,
-        ];
-        let pkt1_check = [
-            0x5e, 0xc0, 0x2, 0x74, 0x2, 0x73, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        ];
+        let b = &mut buf;
+        let a = &self;
+        copy_slice(b, a, 0, 4, &mut start_index, 38);
+        copy_slice(b, a, 0, 3, &mut start_index, 39);
+        copy_slice(b, a, 1, 3, &mut start_index, 38);
+        copy_slice(b, a, 1, 2, &mut start_index, 39);
+        copy_slice(b, a, 2, 2, &mut start_index, 38);
+        copy_slice(b, a, 2, 1, &mut start_index, 39);
+        copy_slice(b, a, 3, 1, &mut start_index, 38);
+        copy_slice(b, a, 3, 0, &mut start_index, 39);
+        copy_slice(b, a, 4, 0, &mut start_index, 39);
+        copy_slice(b, a, 5, 0, &mut start_index, 39);
+        copy_slice(b, a, 6, 0, &mut start_index, 38);
+        copy_slice(b, a, 7, 0, &mut start_index, 38);
+        copy_slice(b, a, 8, 0, &mut start_index, 37);
+        copy_slice(b, a, 9, 0, &mut start_index, 37);
+        copy_slice(b, a, 10, 0, &mut start_index, 36);
+        copy_slice(b, a, 11, 0, &mut start_index, 36);
+        copy_slice(b, a, 12, 0, &mut start_index, 35);
+        copy_slice(b, a, 13, 0, &mut start_index, 35);
+        copy_slice(b, a, 14, 0, &mut start_index, 34);
+        copy_slice(b, a, 15, 0, &mut start_index, 34);
+        copy_slice(b, a, 16, 0, &mut start_index, 33);
+        copy_slice(b, a, 17, 0, &mut start_index, 33);
+        copy_slice(b, a, 18, 0, &mut start_index, 32);
+        copy_slice(b, a, 19, 0, &mut start_index, 32);
+        copy_slice(b, a, 20, 0, &mut start_index, 31);
+        copy_slice(b, a, 21, 0, &mut start_index, 31);
+        copy_slice(b, a, 22, 0, &mut start_index, 30);
+        copy_slice(b, a, 23, 0, &mut start_index, 30);
+        copy_slice(b, a, 24, 0, &mut start_index, 29);
+        copy_slice(b, a, 25, 0, &mut start_index, 29);
+        copy_slice(b, a, 26, 0, &mut start_index, 28);
+        copy_slice(b, a, 27, 0, &mut start_index, 28);
+        copy_slice(b, a, 28, 0, &mut start_index, 27);
+        copy_slice(b, a, 29, 0, &mut start_index, 27);
+        copy_slice(b, a, 30, 0, &mut start_index, 26);
+        copy_slice(b, a, 31, 0, &mut start_index, 26);
+        copy_slice(b, a, 32, 0, &mut start_index, 25);
+        copy_slice(b, a, 33, 0, &mut start_index, 25);
+        copy_slice(b, a, 34, 0, &mut start_index, 24);
+        copy_slice(b, a, 35, 0, &mut start_index, 24);
+        copy_slice(b, a, 36, 0, &mut start_index, 23);
+        copy_slice(b, a, 37, 0, &mut start_index, 23);
+        copy_slice(b, a, 38, 0, &mut start_index, 22);
+        copy_slice(b, a, 39, 0, &mut start_index, 22);
+        copy_slice(b, a, 40, 0, &mut start_index, 21);
+        copy_slice(b, a, 41, 0, &mut start_index, 21);
+        copy_slice(b, a, 42, 0, &mut start_index, 20);
+        copy_slice(b, a, 43, 0, &mut start_index, 20);
+        copy_slice(b, a, 44, 0, &mut start_index, 19);
+        copy_slice(b, a, 45, 0, &mut start_index, 19);
+        copy_slice(b, a, 46, 0, &mut start_index, 18);
+        copy_slice(b, a, 47, 0, &mut start_index, 18);
+        copy_slice(b, a, 48, 0, &mut start_index, 17);
+        copy_slice(b, a, 49, 0, &mut start_index, 17);
+        copy_slice(b, a, 50, 0, &mut start_index, 16);
+        copy_slice(b, a, 51, 0, &mut start_index, 16);
+        copy_slice(b, a, 52, 0, &mut start_index, 15);
+        copy_slice(b, a, 53, 0, &mut start_index, 15);
+        copy_slice(b, a, 54, 0, &mut start_index, 14);
+        copy_slice(b, a, 55, 0, &mut start_index, 14);
+        copy_slice(b, a, 56, 0, &mut start_index, 13);
+        copy_slice(b, a, 57, 0, &mut start_index, 13);
+        copy_slice(b, a, 58, 0, &mut start_index, 12);
 
-        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-        path.push("test/ga401-diagonal.png");
-
-        let matrix = AnimeDiagonal::from_png(&path, None, 255.0, AnimeType::GA401).unwrap();
-        let data = matrix.into_data_buffer(crate::AnimeType::GA401).unwrap();
-        let pkt = AnimePacketType::try_from(data).unwrap();
-
-        assert_eq!(pkt[0], pkt0_check);
-        assert_eq!(pkt[1], pkt1_check);
-    }
-
-    #[test]
-    fn ga402_diagonal_packet_check() {
-        let pkt0_check = [
-            0x5e, 0xc0, 0x2, 0x1, 0x0, 0x73, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0,
-        ];
-        let pkt1_check = [
-            0x5e, 0xc0, 0x2, 0x74, 0x2, 0x73, 0x2, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        ];
-        let pkt2_check = [
-            0x5e, 0xc0, 0x2, 0xe7, 0x4, 0x73, 0x2, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
-            0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
-            0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        ];
-
-        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-        path.push("test/ga402-diagonal.png");
-
-        let matrix = AnimeDiagonal::from_png(&path, None, 255.0, AnimeType::GA402).unwrap();
-        let data = matrix.into_data_buffer(crate::AnimeType::GA402).unwrap();
-        let pkt = AnimePacketType::try_from(data).unwrap();
-
-        assert_eq!(pkt[0], pkt0_check);
-        assert_eq!(pkt[1], pkt1_check);
-        assert_eq!(pkt[2], pkt2_check);
-    }
-
-    #[test]
-    #[ignore = "Needs the packets verified with capture"]
-    fn ga402_diagonal_fullbright_packet_check() {
-        let pkt0_check = [
-            0x5e, 0xc0, 0x2, 0x1, 0x0, 0x73, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x68, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x67, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        ];
-        let pkt1_check = [
-            0x5e, 0xc0, 0x2, 0x74, 0x2, 0x73, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        ];
-        let pkt2_check = [
-            0x5e, 0xc0, 0x2, 0xe7, 0x4, 0x73, 0x2, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        ];
-
-        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-        path.push("test/ga402-diagonal-fullbright.png");
-
-        let matrix = AnimeDiagonal::from_png(&path, None, 255.0, AnimeType::GA402).unwrap();
-        let data = matrix.into_data_buffer(crate::AnimeType::GA402).unwrap();
-        let pkt = AnimePacketType::try_from(data).unwrap();
-
-        assert_eq!(pkt[0], pkt0_check);
-        assert_eq!(pkt[1], pkt1_check);
-        assert_eq!(pkt[2], pkt2_check);
+        AnimeDataBuffer::from_vec(crate::AnimeType::GA402, buf)
     }
 }

rog-anime/src/error.rs

@@ -24,12 +24,14 @@ pub enum AnimeError {
     DataBufferLength,
     PixelGifWidth(usize),
     PixelGifHeight(usize),
+    ParseError(String),
 }
 
 impl fmt::Display for AnimeError {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
+            AnimeError::ParseError(e) => write!(f, "Could not parse {e}"),
             AnimeError::NoFrames => write!(f, "No frames in PNG"),
             AnimeError::Io(e) => write!(f, "Could not open: {}", e),
             AnimeError::Png(e) => write!(f, "PNG error: {}", e),

rog-anime/src/gif.rs

@@ -4,7 +4,8 @@ use std::path::Path;
 use std::time::Duration;
 
 use glam::Vec2;
-use serde_derive::{Deserialize, Serialize};
+use log::error;
+use serde::{Deserialize, Serialize};
 
 use crate::error::{AnimeError, Result};
 use crate::{AnimeDataBuffer, AnimeDiagonal, AnimeImage, AnimeType, Pixel};
@@ -107,16 +108,18 @@ impl AnimeGif {
         // Configure the decoder such that it will expand the image to RGBA.
         decoder.set_color_output(gif::ColorOutput::RGBA);
         // Read the file header
-        let file = File::open(file_name)?;
+        let file = File::open(file_name).map_err(|e| {
+            error!("Could not open {file_name:?}: {e:?}");
+            e
+        })?;
         let mut decoder = decoder.read_info(file)?;
 
-        let mut frames = Vec::with_capacity(decoder.buffer_size());
-
+        let mut frames = Vec::default();
         while let Some(frame) = decoder.read_next_frame()? {
             let wait = frame.delay * 10;
-            if matches!(frame.dispose, gif::DisposalMethod::Background) {
-                frames = Vec::new();
-            }
+            // if matches!(frame.dispose, gif::DisposalMethod::Background) {
+            //     frames = Vec::new();
+            // }
             for (y, row) in frame.buffer.chunks(frame.width as usize * 4).enumerate() {
                 for (x, px) in row.chunks(4).enumerate() {
                     if px[3] != 255 {
@@ -187,12 +190,14 @@ impl AnimeGif {
         anime_type: AnimeType,
     ) -> Result<Self> {
         let mut frames = Vec::new();
-
         let mut decoder = gif::DecodeOptions::new();
         // Configure the decoder such that it will expand the image to RGBA.
         decoder.set_color_output(gif::ColorOutput::RGBA);
         // Read the file header
-        let file = File::open(file_name)?;
+        let file = File::open(file_name).map_err(|e| {
+            error!("Could not open {file_name:?}: {e:?}");
+            e
+        })?;
         let mut decoder = decoder.read_info(file)?;
 
         let height = decoder.height();

rog-anime/src/image.rs

@@ -3,6 +3,7 @@ use std::path::Path;
 
 pub use glam::Vec2;
 use glam::{Mat3, Vec3};
+use log::error;
 
 use crate::data::AnimeDataBuffer;
 use crate::error::{AnimeError, Result};
@@ -10,7 +11,7 @@ use crate::AnimeType;
 
 /// A single greyscale + alpha pixel in the image
 #[derive(Copy, Clone, Debug)]
-pub(crate) struct Pixel {
+pub struct Pixel {
     pub color: u32,
     pub alpha: f32,
 }
@@ -79,7 +80,8 @@ pub struct AnimeImage {
 }
 
 impl AnimeImage {
-    pub(crate) fn new(
+    /// Exposed only for tests. Please use `from_png()` instead.
+    pub fn new(
         scale: Vec2,
         angle: f32,
         translation: Vec2,
@@ -114,25 +116,29 @@ impl AnimeImage {
     ///
     /// For GA401 this is `26.8 / (33 + 0.5) = 0.8`
     /// For GA402 this is `27.4 / (35 + 0.5) = 0.77`
+    /// For GA402 this is `30.9 / (39 + 0.5) = 0.77`
     fn scale_x(anime_type: AnimeType) -> f32 {
         match anime_type {
             AnimeType::GA401 => 0.8,
-            AnimeType::GA402 => 0.77,
+            AnimeType::GU604 => 0.78,
+            _ => 0.77,
         }
     }
 
     /// Scale ratio in CM
     ///
     /// This is worked out by measuring the physical height of the display from
-    /// pixel center to pixel center, then dividing by  `<vertical LED
-    /// count> + 1.0`, where the LED count is first/longest row.
+    /// pixel center to pixel center, then dividing by 10 divided  `<vertical
+    /// LED count> + 1.0`, where the LED count is first/longest row.
     ///
     /// For GA401 this is `16.5 / (54.0 + 1.0) = 0.3`
     /// For GA402 this is `17.3 / (61.0)       = 0.283`
+    /// For GU604 this is `17.7 / (62.0 + 1)   = 0.28`
     fn scale_y(anime_type: AnimeType) -> f32 {
         match anime_type {
             AnimeType::GA401 => 0.3,
-            AnimeType::GA402 => 0.283,
+            AnimeType::GU604 => 0.28,
+            _ => 0.283,
         }
     }
 
@@ -141,7 +147,9 @@ impl AnimeImage {
     ///
     /// In relation to the display itself you should think of it as a full
     /// square grid, so `first_x` is the x position on that grid where the
-    /// LED is actually positioned in relation to the Y. ```text
+    /// LED is actually positioned in relation to the Y.
+    ///
+    /// ```text
     /// +------------+
     /// |            |
     /// |            |
@@ -163,7 +171,15 @@ impl AnimeImage {
                 }
                 (y + 1) / 2 - 3
             }
-            AnimeType::GA402 => {
+            AnimeType::GU604 => {
+                // first 9 rows start at zero
+                if y <= 9 {
+                    return 0;
+                }
+                // and then their offset grows by one every two rows
+                (y - 9) / 2
+            }
+            _ => {
                 // first 11 rows start at zero
                 if y <= 11 {
                     return 0;
@@ -189,6 +205,7 @@ impl AnimeImage {
     ///       \      |
     ///        ------+
     /// ```
+    // TODO: make this return only width, and move calcs to pitch
     fn width(anime_type: AnimeType, y: u32) -> u32 {
         match anime_type {
             AnimeType::GA401 => {
@@ -198,7 +215,13 @@ impl AnimeImage {
                 }
                 36 - (y + 1) / 2
             }
-            AnimeType::GA402 => {
+            AnimeType::GU604 => {
+                if y <= 9 {
+                    return 38 + y % 2;
+                }
+                38 - Self::first_x(anime_type, y) + y % 2
+            }
+            _ => {
                 if y <= 11 {
                     return 34;
                 }
@@ -212,7 +235,9 @@ impl AnimeImage {
         match anime_type {
             // 33.0 = Longest row LED count (physical) plus half-pixel offset
             AnimeType::GA401 => (33.0 + 0.5) * Self::scale_x(anime_type),
-            AnimeType::GA402 => (35.0 + 0.5) * Self::scale_x(anime_type),
+
+            AnimeType::GU604 => (38.0 + 0.5) * Self::scale_x(anime_type),
+            _ => (35.0 + 0.5) * Self::scale_x(anime_type),
         }
     }
 
@@ -220,7 +245,8 @@ impl AnimeImage {
     fn height(anime_type: AnimeType) -> u32 {
         match anime_type {
             AnimeType::GA401 => 55,
-            AnimeType::GA402 => 61,
+            AnimeType::GU604 => 62,
+            _ => 61,
         }
     }
 
@@ -229,8 +255,9 @@ impl AnimeImage {
         match anime_type {
             // 54.0 = End column LED count (physical) plus one dead pixel
             AnimeType::GA401 => (54.0 + 1.0) * Self::scale_y(anime_type),
+            AnimeType::GU604 => 62.0 * Self::scale_y(anime_type),
             // GA402 may not have dead pixels and require only the physical LED count
-            AnimeType::GA402 => 61.0 * Self::scale_y(anime_type),
+            _ => 61.0 * Self::scale_y(anime_type),
         }
     }
 
@@ -242,8 +269,9 @@ impl AnimeImage {
                 1 | 3 => 35, // Some rows are padded
                 _ => 36 - y / 2,
             },
+            AnimeType::GU604 => AnimeImage::width(anime_type, y),
             // GA402 does not have padding, equivalent to width
-            AnimeType::GA402 => AnimeImage::width(anime_type, y),
+            _ => AnimeImage::width(anime_type, y),
         }
     }
 
@@ -317,7 +345,7 @@ impl AnimeImage {
     }
 
     /// A helper for determining physical position alignment
-    fn _edge_outline(&mut self) {
+    pub fn edge_outline(&mut self) {
         // Janky shit here just to try help align images
         let mut last_x = 0.0;
         let mut last_y = 0.0;
@@ -394,7 +422,10 @@ impl AnimeImage {
         bright: f32,
         anime_type: AnimeType,
     ) -> Result<Self> {
-        let data = std::fs::read(path)?;
+        let data = std::fs::read(path).map_err(|e| {
+            error!("Could not open {path:?}: {e:?}");
+            e
+        })?;
         let data = std::io::Cursor::new(data);
         let decoder = png_pong::Decoder::new(data)?.into_steps();
         let png_pong::Step { raster, delay: _ } = decoder.last().ok_or(AnimeError::NoFrames)??;
@@ -607,149 +638,6 @@ mod tests {
         assert_eq!(AnimeImage::pitch(a, 14), 29);
     }
 
-    #[test]
-    fn ga402_image_edge_packet_check() {
-        let pkt0_check = [
-            0x5e, 0xc0, 0x2, 0x1, 0x0, 0x73, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0,
-        ];
-        let pkt1_check = [
-            0x5e, 0xc0, 0x2, 0x74, 0x2, 0x73, 0x2, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        ];
-        let pkt2_check = [
-            0x5e, 0xc0, 0x2, 0xe7, 0x4, 0x73, 0x2, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
-            0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
-            0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        ];
-
-        let mut matrix = AnimeImage::new(
-            Vec2::new(1.0, 1.0),
-            0.0,
-            Vec2::default(),
-            0.0,
-            vec![Pixel::default(); 1000],
-            100,
-            AnimeType::GA402,
-        )
-        .unwrap();
-        matrix._edge_outline();
-        let data = AnimeDataBuffer::try_from(&matrix).unwrap();
-        let pkt = AnimePacketType::try_from(data).unwrap();
-
-        assert_eq!(pkt[0], pkt0_check);
-        assert_eq!(pkt[1], pkt1_check);
-        assert_eq!(pkt[2], pkt2_check);
-    }
-
     #[test]
     #[ignore = "Just to inspect image packet"]
     fn ga402_image_packet_check() {

rog-anime/src/lib.rs

@@ -33,3 +33,27 @@ pub mod error;
 pub mod usb;
 
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+// #[cfg(feature = "typescript")]
+// #[cfg(test)]
+// mod tests {
+//     use crate::usb::{AnimShutdown, Brightness, AnimSleeping, AnimAwake,
+// AnimBooting};     use crate::{AnimeType, Animations, DeviceState};
+//     use ts_rs::SingleFileExporter;
+//     #[test]
+//     fn test_singlefile() {
+//         let out = SingleFileExporter::new(false)
+//             .and::<AnimeType>()
+//             .and::<Animations>()
+//             .and::<DeviceState>()
+//             .and::<Brightness>()
+//             .and::<AnimShutdown>()
+//             .and::<AnimSleeping>()
+//             .and::<AnimAwake>()
+//             .and::<AnimBooting>()
+//             .finish()
+//             .unwrap();
+//         println!("{out}");
+//         assert_eq!(out, "");
+//     }
+// }