### Build and Install on openSUSE

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/README.md

Installs development patterns and packages, then builds and installs the project using make. Works with KDE Plasma.

```sh
zypper in -t pattern devel_basis
zypper in rustup make cmake clang-devel libxkbcommon-devel systemd-devel expat-devel pcre2-devel libzstd-devel gtk3-devel
make
sudo make install
```

--------------------------------

### Build and Install on Fedora

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/README.md

Installs required development packages and builds/installs the project using make.

```sh
dnf install cmake clang-devel  libxkbcommon-devel systemd-devel expat-devel pcre2-devel libzstd-devel gtk3-devel
make
sudo make install
```

--------------------------------

### Build and Install on Ubuntu/PopOS (Unsupported)

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/README.md

Installs necessary development packages and builds/installs the project using make. Note that Ubuntu and PopOS are officially unsupported.

```sh
sudo apt install make cargo gcc pkg-config openssl libasound2-dev cmake build-essential python3 libfreetype6-dev libexpat1-dev libxcb-composite0-dev libssl-dev libx11-dev libfontconfig1-dev curl libclang-dev libudev-dev checkinstall libseat-dev libinput-dev libxkbcommon-dev libgbm-dev

make
sudo make install
```

--------------------------------

### Build and Install on Debian (Unsupported)

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/README.md

Installs development packages, Rustup, and builds/installs the project using make. Note that Debian is officially unsupported.

```sh
sudo apt install libclang-dev libudev-dev libfontconfig-dev build-essential cmake libxkbcommon-dev
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
make
sudo make install
```

--------------------------------

### Aura Configuration Example (RON)

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/MANUAL.md

Defines a custom Aura effect configuration using the RON format. This example includes Breathe and Static effects for specific keys, and a DoomFlicker effect. Ensure the 'led_type' in rog-user.cfg matches your keyboard's capabilities (Key, Zone, or None).

```ron
(
    name: "aura-default",
    aura: (
        effects: [
            Breathe((
                led: W,
                start_colour1: (255, 0, 20),
                start_colour2: (20, 255, 0),
                speed: Low,
            )),
            Breathe(( 
                led: A,
                start_colour1: (255, 0, 20),
                start_colour2: (20, 255, 0),
                speed: Low,
            )),
            Breathe(( 
                led: S,
                start_colour1: (255, 0, 20),
                start_colour2: (20, 255, 0),
                speed: Low,
            )),
            Breathe(( 
                led: D,
                start_colour1: (255, 0, 20),
                start_colour2: (20, 255, 0),
                speed: Low,
            )),
            Breathe(( 
                led: F,
                start_colour1: (255, 0, 0),
                start_colour2: (255, 0, 0),
                speed: High,
            )),
            Static(( 
                led: RCtrl,
                colour: (0, 0, 255),
            )),
            Static(( 
                led: LCtrl,
                colour: (0, 0, 255),
            )),
            Static(( 
                led: Esc,
                colour: (0, 0, 255),
            )),
            DoomFlicker(( 
                led: N9,
                start_colour: (0, 0, 255),
                max_percentage: 80,
                min_percentage: 40,
            )),
        ],
        zoned: false,
    ),
)

```

--------------------------------

### ROG Aura Support Configuration Example

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/rog-aura/README.md

This RON configuration defines support for a specific laptop board, including its layout name, supported basic modes, and advanced lighting type. Board names can often be found using 'cat /sys/devices/virtual/dmi/id/board_name'.

```ron
    (
        board_name: "G513QR",
        layout_name: "g513i-per-key",
        basic_modes: [Static, Breathe, Strobe, Rainbow, Star, Rain, Highlight, Laser, Ripple, Pulse, Comet, Flash],
        basic_zones: [],
        advanced_type: PerKey,
    ),
```

--------------------------------

### RON Keyboard Layout Configuration

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/rog-aura/README.md

Defines custom keyboard layouts using Rusty Object Notation (RON). This example shows how to specify key shapes with dimensions and padding, and then arrange these keys into rows.

```ron
(
    locale: "US",
    key_shapes: {
        // This is a regular LED spot, it has a size (width x height), and padding around each edge.
        // The final size should be (width + pad_left + pad_right, height + pad_top + pad_bottom)
        "regular": Led(
            width: 1.0,
            height: 1.0,
            pad_left: 0.1,
            pad_right: 0.1,
            pad_top: 0.1,
            pad_bottom: 0.1,
        ),
        // There is nothing in this space but it takes up room
        "func_space": Blank(
            width: 0.2,
            height: 0.0,
        ),
        // This backspace button is composed of 3 individual LED
        "backspace1": Led(
            width: 0.65,
            height: 1.0,
            pad_left: 0.1,
            pad_right: 0.0,
            pad_top: 0.1,
            pad_bottom: 0.1,
        ),
        "backspace2": Led(
            width: 0.7,
            height: 1.0,
            pad_left: 0.0,
            pad_right: 0.0,
            pad_top: 0.1,
            pad_bottom: 0.1,
        ),
        "backspace3": Led(
            width: 0.65,
            height: 1.0,
            pad_left: 0.0,
            pad_right: 0.1,
            pad_top: 0.1,
            pad_bottom: 0.1,
        ),
    },
    key_rows: [
        (
            // Padding generally isn't required but is available just in case
            pad_left: 0.1,
            pad_top: 0.1,
            // Each row is a horizontal row of keys of the keyboard
            row: [
                // Declare a tuple of `Key`, and the String name to use from the hashmap above
                (Spacing, "rog_spacer"),
                (VolDown, "rog_row"),
                (VolUp, "rog_row"),
                (MicMute, "rog_row"),
                (Rog, "rog_row"),
            ],
        ),
        (
            pad_left: 0.1,
            pad_top: 0.1,
            row: [
                (Esc, "func_key"),
                // There are two non-led types, `Blocking` which is intended to block something like a row-laser
                (Blocking, "esc_func_spacing"),
                (F1, "func_key"),
                (F2, "func_key"),
                (F3, "func_key"),
                (F4, "func_key"),
                // and `Spacing` which is intended to act like a non-visible LED
                (Spacing, "func_space"),
                (F5, "func_key"),
                (F6, "func_key"),
                (F7, "func_key"),
                (F8, "func_key"),
                (Spacing, "func_space"),
                (F9, "func_key"),
                (F10, "func_key"),
                (F11, "func_key"),
                (F12, "func_key"),
                (Spacing, "func_space"),
                (Del, "func_key"),
            ],
        ),
        (
            pad_left: 0.1,
            pad_top: 0.1,
            row: [
                (Tilde, "regular"),
                (N1, "regular"),
                (N2, "regular"),
                (N3, "regular"),
                (N4, "regular"),
                (N5, "regular"),
                (N6, "regular"),
                (N7, "regular"),
                (N8, "regular"),
                (N9, "regular"),
                (N0, "regular"),
                (Hyphen, "regular"),
                (Equals, "regular"),
                (Backspace3_1, "backspace1"),
                (Backspace3_2, "backspace2"),
                (Backspace3_3, "backspace3"),
                (Spacing, "func_space"),
                (Home, "regular"),
            ],
        )
    ]
)
```

--------------------------------

### Fan Curve Configuration Examples

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/MANUAL.md

Examples of fan curve formats supported by asusd. The format specifies temperature-to-fan-speed mappings, ordered from lowest to highest.

```text
"30c:0%,40c:5%,50c:10%,60c:20%,70c:35%,80c:55%,90c:65%,100c:65%"
```

```text
"30:0,40:5,50:10,60:20,70:35,80:55,90:65,100:65"
```

```text
"30 0,40 5,50 10,60 20,70 35,80 55,90 65,100 65"
```

```text
"30 0 40 5 50 10 60 20 70 35 80 55 90 65 100 65"
```

--------------------------------

### Write Animated Image to AniMe Matrix via DBus

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/rog-anime/README.md

This example demonstrates how to load a PNG image, animate its rotation, and continuously write it to the AniMe matrix display using the AuraDbusClient. Ensure the 'dbus' feature is enabled.

```rust
use std::{
    env,
    error::Error,
    f32::consts::PI,
    path::Path,
    process::exit,
    thread::sleep,
    time::Duration,
};

use rog_anime::{
    AniMeDataBuffer,
    {AniMeImage, Vec2},
};
use rog_dbus::AuraDbusClient;

fn main() -> Result<(), Box<dyn Error>> {
    let (client, _) = AuraDbusClient::new().unwrap();

    let mut image = AniMeImage::from_png(
        Path::new("./doom.png"),
        0.9, // scale
        0.0, // rotation
        Vec2::new(0.0, 0.0), // position
        0.3, // brightness
    )?;

    loop {
        image.angle += 0.05;
        if image.angle > PI * 2.0 {
            image.angle = 0.0
        }
        image.update();

        client
            .proxies()
            .anime()
            .write(<AniMeDataBuffer>::from(&image))
            .unwrap();
        sleep(Duration::from_micros(500));
    }
}
```

--------------------------------

### Single Zone Aura Configuration (RON)

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/MANUAL.md

Example of a single zone Aura configuration in RON format. This is used when 'led_type' is set to 'Zone' and 'zoned' is true in the config. It demonstrates the DoomFlicker effect applied to a single zone.

```ron
(
    name: "aura-default",
    aura: (
        effects: [
            DoomFlicker(( 
                led: SingleZone,
                start_colour: (200, 40, 5),
                max_percentage: 80,
                min_percentage: 40,
            )),
        ],
        zoned: true,
    ),
)

```

--------------------------------

### Asusctl Help Command

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/MANUAL.md

Access help documentation for the asusctl CLI. General help or specific command help can be retrieved.

```bash
asusctl --help
```

```bash
asusctl <command> --help
```

```bash
asusctl <command> <subcommand> --help
```

--------------------------------

### asusctl armoury CLI Commands

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/GPU_MODE_SWITCHING_SUMMARY.md

Demonstrates common commands for interacting with firmware attributes via the asusctl armoury CLI.

```bash
# List all firmware attributes
asusctl armoury list

# Get specific attribute
asusctl armoury get --property dgpu_disable

# Set attribute value
asusctl armoury set --property dgpu_disable --value 1
asusctl armoury set --property gpu_mux_mode --value 0
```

--------------------------------

### Rog Control Center CLI Options

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/rog-aura/README.md

Lists command-line options for testing keyboard layouts with Rog Control Center. Use these options to debug and preview layout configurations.

```bash
  -h, --help            print help message
  -v, --version         show program version number
  -b, --board-name      set board name for testing, this will make ROGCC show only the keyboard page
  -l, --layout-viewing  put ROGCC in layout viewing mode - this is helpful for finding existing layouts that might match your laptop

```

--------------------------------

### Build ROG Control Center with X11 Support

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/rog-control-center/README.md

Enable X11 support during the build process using Cargo. This is useful if you need X11 compatibility.

```bash
cargo build --features x11
```

--------------------------------

### Build and Run AniMe Matrix Simulator

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/README.md

Build the AniMe Matrix simulator using cargo and run it. This requires the rog_simulators package. The simulator can be used with asusd.

```bash
cargo build --package rog_simulators
```

```bash
./target/debug/anime_sim
```

--------------------------------

### Asusctl Keybind - Next Fan/Thermal Profile

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/MANUAL.md

Command to switch to the next fan or thermal profile, typically bound to Fn+F5.

```bash
asusctl profile -n
```

--------------------------------

### AsusAnimation Configuration (JSON)

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/MANUAL.md

Defines an AsusAnimation sequence for AniMe configurations. Specify the file path to a pre-existing ASUS GIF, the duration, and brightness level. These files are typically found in /usr/share/asusd/anime/asus/.

```json
      "AsusAnimation": {
        "file": "<FILE_PATH>",
        "time": <TIME>,
        "brightness": <FLOAT>
      }

```

--------------------------------

### Run ROG Control Center with Local Translations

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/rog-control-center/README.md

Test your local translations by running the application with the RUST_TRANSLATIONS environment variable set. This allows you to see your changes in real-time.

```bash
RUST_TRANSLATIONS=1 rog-control-center
```

--------------------------------

### Asusctl Keybind - Next Aura Mode

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/MANUAL.md

Command to cycle to the next Aura lighting mode using the dedicated keybind.

```bash
asusctl aura -n
```

--------------------------------

### Compile Translation Files

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/rog-control-center/README.md

Compile your translated .po files into binary .mo files using msgfmt. Ensure you replace <YOUR LOCALE> with the correct locale code.

```bash
msgfmt rog-control-center/translations/<YOUR LOCALE>/rog-control-center.po -o rog-control-center/translations/<YOUR LOCALE>/LC_MESSAGES/rog-control-center.mo
```

--------------------------------

### AsusImage Configuration (JSON)

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/MANUAL.md

Defines an AsusImage sequence for AniMe configurations, similar to AsusAnimation but for PNG files. Specify the file path, duration, and brightness. PNGs are often created using a template for consistent pixel display.

```json
      "AsusImage": {
        "file": "<FILE_PATH>",
        "time": <TIME>,
        "brightness": <FLOAT>
      }

```

--------------------------------

### Asusctl Keybind - Previous Aura Mode

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/MANUAL.md

Command to cycle to the previous Aura lighting mode using the dedicated keybind.

```bash
asusctl aura -p
```

--------------------------------

### Asusctl CLI Usage

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/MANUAL.md

Basic command structure for the asusctl command-line interface. Use options and commands to interact with asusd.

```bash
asusctl <option> <command> <command-options>
```

--------------------------------

### Image Configuration

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/MANUAL.md

Defines parameters for displaying greyscale PNG images. Similar to ImageAnimation, it includes file path, scaling, rotation, translation, duration, and brightness.

```json
    {
      "Image": {
        "file": "<FILE_PATH>",
        "scale": <FLOAT>,
        "angle": <FLOAT>,
        "translation": [
          <FLOAT>,
          <FLOAT>
        ],
        "time": <TIME>,
        "brightness": <FLOAT>
      }
    },
```

--------------------------------

### CLI Workaround for 2-Attribute Coordination

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/GPU_MODE_SWITCHING_SUMMARY.md

Manually sets both `dgpu_disable` and `gpu_mux_mode` attributes via the CLI to achieve GUI-like mode switching behavior. Use these commands to switch between Integrated, Ultimate, and Hybrid modes.

```bash
# Integrated mode
asusctl armoury set --property dgpu_disable --value 1
asusctl armoury set --property gpu_mux_mode --value 1
```

```bash
# Ultimate mode
asusctl armoury set --property dgpu_disable --value 0
asusctl armoury set --property gpu_mux_mode --value 0
```

```bash
# Hybrid mode
asusctl armoury set --property dgpu_disable --value 0
asusctl armoury set --property gpu_mux_mode --value 1
```

--------------------------------

### Time Configuration - Infinite

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/MANUAL.md

Configures an animation to run indefinitely without looping.

```json
        "time": "Infinite",
```

--------------------------------

### Calculate Initial GPU Mode Index

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/GPU_MODE_SWITCHING_SUMMARY.md

Determines the initial index for the GPU mode dropdown based on hardware capabilities and current settings.

```pseudocode
If gpu_mux_available:
  - mux value = 0 → "Ultimate" (index 1)
  - mux value = 1 + dgpu = 1 → "Integrated" (index 0)
  - fallback → "Hybrid" (index 2)
Else (no mux support):
  - dgpu = 1 → "Integrated" (index 0)
  - fallback → "Hybrid" (index 1)
```

--------------------------------

### AniMe Configuration Template (JSON)

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/MANUAL.md

Basic JSON structure for an AniMe configuration file. The 'anime' array will contain animation sequences. This is a template and requires specific animation types to be defined within the array.

```json
{
  "name": "<FILENAME>",
  "anime": []
}

```

--------------------------------

### Pause Configuration

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/MANUAL.md

Configures a pause duration after an image display. Specify the duration in seconds and nanoseconds.

```json
    {
      "Pause": {
        "secs": <INT>,
        "nanos": <INT>
      }
    },
```

--------------------------------

### ImageAnimation Configuration

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/MANUAL.md

Defines parameters for playing animated GIFs. Specify the file path, scaling, rotation, translation, duration, and brightness.

```json
      "ImageAnimation": {
        "file": "<FILE_PATH>",
        "scale": <FLOAT>,
        "angle": <FLOAT>,
        "translation": [
          <FLOAT>,
          <FLOAT>
        ],
        "time": <TIME>,
        "brightness": <FLOAT>
      }
    },
```

--------------------------------

### Convert Image to USB HID Packets for Direct Write

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/rog-anime/README.md

This snippet shows the process of converting an AniMeImage to an intermediate buffer and then to USB HID packets for direct writing to the device. This method bypasses the asusd daemon.

```rust
let mut image = AniMeImage::from_png(
        Path::new("./doom.png"),
        0.9, // scale
        0.0, // rotation
        Vec2::new(0.0, 0.0), // position
        0.3, // brightness
    )?;

// convert to intermediate packet format
let buffer = <AniMeDataBuffer>::from(&image)
// then to USB HID
let data = AniMePacketType::from(buffer);
// and then write direct
for packet in data.iter() {
    write_usb(packet); // some usb call here
}
```

--------------------------------

### Restart asusd Service

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/README.md

Restart the asusd service after upgrading. This command reloads the systemd daemon configuration and then restarts the asusd service.

```bash
systemctl daemon-reload && systemctl restart asusd
```

--------------------------------

### Time Configuration - Time

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/MANUAL.md

Specifies a fixed duration for an animation or image display using seconds and nanoseconds.

```json
        "time": {
          "Time": {
            "secs": 5,
            "nanos": 0
          }
        },
```

--------------------------------

### Daemon GPU Attribute Queuing Logic

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/GPU_MODE_SWITCHING_SUMMARY.md

Handles queuing of GPU attributes in the asusd daemon, deferring immediate application.

```rust
FirmwareAttributeType::Gpu => {
    debug!("Queueing GPU attribute {name} = {value} for delayed apply");
    self.queued_gpu.lock().await.insert(self.name(), value);
    return Ok(());  // Early return - NOT applied immediately
}
```

--------------------------------

### Main Controller Struct (Simple)

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/design-patterns.md

Defines a simple controller struct that can be cloned across threads. It requires the `CtrlTask` and `ZbusAdd` traits to be implemented.

```rust
#[derive(Clone)]
pub struct CtrlAnime {
    <things the controller requires>
    config: Arc<Mutex<Config>>,
}

// This is the task trait used for such things as file watches, or logind
// notifications (boot/suspend/shutdown etc)
impl crate::CtrlTask for CtrlAnime {}

// The trait to easily add the controller to Zbus to enable the zbus derived functions
// to be polled, run, react etc.
impl crate::ZbusAdd for CtrlAnime {}

impl CtrlAnime {}
```

--------------------------------

### Time Configuration - Cycles

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/MANUAL.md

Sets the number of times a GIF animation should loop.

```json
        "time": {
          "Cycles": 2
        },
```

--------------------------------

### Time Configuration - Fade

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/MANUAL.md

Defines a fade-in, display, and fade-out sequence for animations or images. 'show_for' can be null to default to the GIF's duration minus fade times.

```json
        "time": {
          "Fade": {
            "fade_in": {
              "secs": 2,
              "nanos": 0
            },
            "show_for": {
              "secs": 1,
              "nanos": 0
            },
            "fade_out": {
              "secs": 2,
              "nanos": 0
            }
          }
        },
```

--------------------------------

### Configure Battery Charge Limit

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/MANUAL.md

Set the maximum battery charge percentage in the asusd configuration file. This limits the battery's maximum charge to prolong its lifespan.

```json
"bat_charge_limit": 80,
```

--------------------------------

### Define Regular LED Shape

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/rog-aura/README.md

Defines a regular LED spot with specified dimensions and padding. This configuration is used as a key in keyboard layouts.

```rust
        // This is a regular LED spot, it has a size (width x height), and padding around each edge.
        // The final size should be (width + pad_left + pad_right, height + pad_top + pad_bottom)
        "regular": Led(
            width: 1.0,
            height: 1.0,
            pad_left: 0.1,
            pad_right: 0.1,
            pad_top: 0.1,
            pad_bottom: 0.1,
        ),

```

--------------------------------

### GpuMode Conversion Methods

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/GPU_MODE_SWITCHING_SUMMARY.md

Provides methods to convert GpuMode enum variants to firmware attribute values for `gpu_mux_mode`, `dgpu_disable`, and `egpu_mux_mode`. Also includes methods to convert firmware attribute values back to GpuMode.

```rust
// To firmware attribute values
pub fn to_mux_attr(&self) -> u8 {          // Ultimate(4)→0, others→1
pub fn to_dgpu_attr(&self) -> u8 {         // Integrated(1)→1, others→0
pub fn to_egpu_attr(&self) -> u8 {         // Egpu(2)→1, others→0

// From firmware attribute values
pub fn from_mux(num: u8) -> Self {         // 0→Ultimate, 1→Optimus
pub fn from_dgpu(num: u8) -> Self {        // 1→Integrated, 0→Optimus
pub fn from_egpu(num: u8) -> Self {        // 1→Egpu, 0→Optimus
```

--------------------------------

### Handle Armoury Set Command in Rust

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/GPU_MODE_SWITCHING_SUMMARY.md

Processes the 'set' command for Armoury features, iterating through attributes to find and set a property's value. Handles default values and queues GPU attribute changes.

```rust
fn handle_armoury_command(cmd: &ArmouryCommand) {
    ArmourySubCommand::Set(s) => {
        for attr in attrs.iter() {
            if attr.name()? == s.property {
                let value = if s.value == -1 { 
                    attr.default_value()? 
                } else { 
                    s.value 
                };
                attr.set_current_value(value)?;  // Queues GPU attributes
                print_firmware_attr(attr)?;
            }
        }
    }
}
```

--------------------------------

### Set GPU Mode Attributes (MUX Available)

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/GPU_MODE_SWITCHING_SUMMARY.md

Sets the dgpu_disable and gpu_mux_mode attributes based on the selected mode index when GPU MUX is available.

```rust
match index {
    0 => {
        dgpu_disable = 1
        gpu_mux_mode = 1
    }
    1 => {
        dgpu_disable = 0
        gpu_mux_mode = 0
    }
    2 => {
        dgpu_disable = 0
        gpu_mux_mode = 1
    }
}
```

--------------------------------

### AsusArmoury DBUS Interface Definition

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/GPU_MODE_SWITCHING_SUMMARY.md

Defines the DBUS interface for the AsusArmoury service, including methods for setting and applying GPU values.

```rust
#[proxy(interface = "xyz.ljones.AsusArmoury")]
pub trait AsusArmoury {
    #[zbus(property)]
    fn set_current_value(&self, value: i32) -> zbus::Result<()>;
    
    #[zbus(property)]
    fn queued_gpu_value(&self) -> zbus::Result<i32>;
    
    async fn apply_queued_gpu_value(&self) -> zbus::Result<bool>;
}
```

--------------------------------

### Set GPU Mode Attributes (MUX Not Available)

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/GPU_MODE_SWITCHING_SUMMARY.md

Sets the dgpu_disable attribute based on the selected mode index when GPU MUX is not available.

```rust
match index {
    0 => {
        dgpu_disable = 1
    }
    1 => {
        dgpu_disable = 0
    }
}
```

--------------------------------

### ZbusAdd Trait Implementation

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/design-patterns.md

Implements the `ZbusAdd` trait for a controller, enabling it to be added to a zbus object server. The `add_to_server` method uses a helper function to register the controller.

```rust
pub struct CtrlAnimeZbus(Arc<Mutex<CtrlAnime>>);

#[async_trait]
impl crate::ZbusAdd for CtrlAnimeZbus {
    fn add_to_server(self, server: &mut zbus::ObjectServer) {
        // This is a provided free helper trait with pre-set body. It will move self in-to.
        Self::add_to_server_helper(self, "/org/asuslinux/Anime", server).await;
    }
}

#[dbus_interface(name = "xyz.ljones.Asusd")]
impl CtrlAnimeZbus {
    async fn <zbus method>() {
       let lock = self.inner.lock().await;
        <some action>
    }
}
```

--------------------------------

### CtrlTask Implementation with Async Mutex

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/design-patterns.md

Implements the `CtrlTask` trait for a controller, utilizing an async mutex for locking. The `create_tasks` method runs once on creation.

```rust
// Mutex should always be async mutex
pub struct CtrlAnimeTask(Arc<Mutex<CtrlAnime>>);

impl crate::CtrlTask for CtrlAnimeTask {
    // This will run once only
    async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
       let lock self.inner.lock().await;
        <some action>
        Ok(())
    }

    // This will run until the notification stream closes (which in most cases will be never)
    async fn create_tasks(&self, signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
        let inner1 = self.inner.clone();
        let inner2 = self.inner.clone();
        let inner3 = self.inner.clone();
        let inner4 = self.inner.clone();
        // This is a free method on CtrlTask trait
        self.create_sys_event_tasks(
            // Loop is required to try an attempt to get the mutex *without* blocking
            // other threads - it is possible to end up with deadlocks otherwise.
            move || loop {
                if let Some(lock) = inner1.try_lock() {
                    run_action(true, lock, inner1.clone());
                    break;
                }
            },
            move || loop {
                if let Some(lock) = inner2.try_lock() {
                    run_action(false, lock, inner2.clone());
                    break;
                }
            },
            move || loop {
                if let Some(lock) = inner3.try_lock() {
                    run_action(true, lock, inner3.clone());
                    break;
                }
            },
            move || loop {
                if let Some(lock) = inner4.try_lock() {
                    run_action(false, lock, inner4.clone());
                    break;
                }
            },
        )
        .await;
    }
}
```

--------------------------------

### Main Controller Struct (Mutex Shared)

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/design-patterns.md

Defines a controller struct that requires shared access via a mutex. Wrapper structs are created for task and zbus functionalities.

```rust
pub struct CtrlAnime {
    <things the controller requires>
}
// Like this
#[derive(Clone)]
pub struct CtrlAnimeTask(Arc<Mutex<CtrlAnime>>);

#[derive(Clone)]
pub struct CtrlAnimeZbus(Arc<Mutex<CtrlAnime>>);

impl CtrlAnime {}
```

--------------------------------

### Check for ASUS Keyboard Device

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/README.md

Use lsusb to identify if your ASUS laptop has a compatible USB keyboard for asusctl.

```plain
Bus 001 Device 002: ID 0b05:1866 ASUSTek Computer, Inc. N-KEY Device
```

```plain
Bus 003 Device 002: ID 0b05:19b6 ASUSTek Computer, Inc. [unknown]
```

--------------------------------

### GpuMode Enum Definition

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/GPU_MODE_SWITCHING_SUMMARY.md

Defines an enumeration for different GPU modes, including Optimus, Integrated, Egpu, Vfio, Ultimate, and error states. Used for representing and converting GPU states.

```rust
pub enum GpuMode {
    Optimus = 0,        // Hybrid mode (from gpu_mux_mode)
    Integrated = 1,     // iGPU only (from dgpu_disable)
    Egpu = 2,           // External GPU
    Vfio = 3,           // VFIO passthrough mode
    Ultimate = 4,       // dGPU only (from gpu_mux_mode)
    Error = 254,
    NotSupported = 255,
}
```

--------------------------------

### Reloadable Trait Implementation

Source: https://gitlab.com/asus-linux/asusctl/-/blob/main/design-patterns.md

Implements the `Reloadable` trait for a controller, allowing it to be reloaded. The `reload` method acquires a lock on the controller's inner state.

```rust
pub struct CtrlAnimeReloader(Arc<Mutex<CtrlAnime>>);

impl crate::Reloadable for CtrlAnimeReloader {
    async fn reload(&mut self) -> Result<(), RogError> {
        let lock = self.inner.lock().await;
        <some action>
        Ok(())
    }
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.