split out types, dbus

asusctl/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "asusctl"
+version = "2.0.4"
+authors = ["Luke D Jones <luke@ljones.dev>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+# serialisation
+serde_json = "^1.0"
+rog_dbus = { path = "../rog-dbus" }
+rog_types = { path = "../rog-types" }
+daemon = { path = "../daemon" }
+gumdrop = "^0.8"
+yansi-term = "^0.1"
+
+
+[dev-dependencies]
+tinybmp = "^0.2.3"
+rog_dbus = { path = "../rog-dbus" }

asusctl/examples/animatrix.rs

@@ -0,0 +1,44 @@
+use rog_dbus::AuraDbusClient;
+use rog_types::{
+    anime_matrix::{AniMeMatrix, AniMePacketType, HEIGHT, WIDTH},
+};
+use tinybmp::{Bmp, Pixel};
+
+fn main() {
+    let (client, _) = AuraDbusClient::new().unwrap();
+
+    let bmp =
+        Bmp::from_slice(include_bytes!("non-skewed_r.bmp")).expect("Failed to parse BMP image");
+    let pixels: Vec<Pixel> = bmp.into_iter().collect();
+    //assert_eq!(pixels.len(), 56 * 56);
+
+    // Try an outline, top and right
+    let mut matrix = AniMeMatrix::new();
+
+    // Aligned left
+    for (i, px) in pixels.iter().enumerate() {
+        if (px.x as usize / 2) < WIDTH && (px.y as usize) < HEIGHT && px.x % 2 == 0 {
+            let mut c = px.color as u32;
+            matrix.get_mut()[px.y as usize][px.x as usize / 2] = c as u8;
+        }
+    }
+
+    // Throw an alignment border up
+    // {
+    //     let tmp = matrix.get_mut();
+    //     for x in tmp[0].iter_mut() {
+    //         *x = 0xff;
+    //     }
+    //     for row in tmp.iter_mut() {
+    //         row[row.len() - 1] = 0xff;
+    //     }
+    // }
+
+    matrix.debug_print();
+
+    let mut matrix: AniMePacketType = AniMePacketType::from(matrix);
+    // println!("{:?}", matrix[0].to_vec());
+    // println!("{:?}", matrix[1].to_vec());
+
+    //client.proxies().anime().set_brightness(&mut matrix).unwrap();
+}

asusctl/examples/ball.rs

@@ -0,0 +1,96 @@
+use rog_types::{
+    fancy::{GX502Layout, Key, KeyColourArray, KeyLayout},
+};
+use rog_dbus::AuraDbusClient;
+use std::collections::LinkedList;
+
+#[derive(Debug, Clone)]
+struct Ball {
+    position: (i32, i32),
+    direction: (i32, i32),
+    trail: LinkedList<(i32, i32)>,
+}
+impl Ball {
+    fn new(x: i32, y: i32, trail_len: u32) -> Self {
+        let mut trail = LinkedList::new();
+        for _ in 1..=trail_len {
+            trail.push_back((x, y));
+        }
+
+        Ball {
+            position: (x, y),
+            direction: (1, 1),
+            trail,
+        }
+    }
+
+    #[allow(clippy::if_same_then_else)]
+    fn update(&mut self, key_map: &[[Key; 17]]) {
+        let pos = self.position;
+        let dir = self.direction;
+
+        if pos.0 + dir.0 > key_map[pos.1 as usize].len() as i32 - 1 || pos.0 + dir.0 < 0 {
+            self.direction.0 *= -1;
+        } else if key_map[(pos.1) as usize][(pos.0 + dir.0) as usize] == Key::None {
+            self.direction.0 *= -1;
+        }
+
+        if pos.1 + dir.1 > key_map.len() as i32 - 1 || pos.1 + dir.1 < 0 {
+            self.direction.1 *= -1;
+        } else if key_map[(pos.1 + dir.1) as usize][(pos.0) as usize] == Key::None {
+            self.direction.1 *= -1;
+        }
+
+        self.trail.pop_front();
+        self.trail.push_back(self.position);
+
+        self.position.0 += self.direction.0;
+        self.position.1 += self.direction.1;
+
+        if self.position.0 > key_map[self.position.1 as usize].len() as i32 {
+            self.position.0 = key_map[self.position.1 as usize].len() as i32 - 1;
+        }
+    }
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let (dbus, _) = AuraDbusClient::new()?;
+
+    let mut colours = KeyColourArray::new();
+
+    let layout = GX502Layout::default();
+
+    let mut balls = [Ball::new(2, 1, 12), Ball::new(4, 6, 12)];
+
+    dbus.proxies().led().init_effect()?;
+
+    let rows = layout.get_rows();
+    loop {
+        for (n, ball) in balls.iter_mut().enumerate() {
+            ball.update(rows);
+            for (i, pos) in ball.trail.iter().enumerate() {
+                if let Some(c) = colours.key(rows[pos.1 as usize][pos.0 as usize]) {
+                    *c.0 = 0;
+                    *c.1 = 0;
+                    *c.2 = 0;
+                    if n == 0 {
+                        *c.0 = i as u8 * (255 / ball.trail.len() as u8);
+                    } else if n == 1 {
+                        *c.1 = i as u8 * (255 / ball.trail.len() as u8);
+                    } else if n == 2 {
+                        *c.2 = i as u8 * (255 / ball.trail.len() as u8);
+                    }
+                };
+            }
+
+            if let Some(c) = colours.key(rows[ball.position.1 as usize][ball.position.0 as usize]) {
+                *c.0 = 255;
+                *c.1 = 255;
+                *c.2 = 255;
+            };
+        }
+        dbus.proxies().led().set_per_key(&colours)?;
+
+        std::thread::sleep(std::time::Duration::from_millis(10));
+    }
+}

asusctl/examples/comet.rs

@@ -0,0 +1,30 @@
+use rog_types::{
+    fancy::{GX502Layout, KeyColourArray, KeyLayout},
+};
+use rog_dbus::AuraDbusClient;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let (dbus, _) = AuraDbusClient::new()?;
+
+    let layout = GX502Layout::default();
+
+    dbus.proxies().led().init_effect()?;
+    let rows = layout.get_rows();
+
+    let mut column = 0;
+    loop {
+        let mut key_colours = KeyColourArray::new();
+        for row in rows {
+            if let Some(c) = key_colours.key(row[column as usize]) {
+                *c.0 = 255;
+            };
+        }
+        if column == rows[0].len() - 1 {
+            column = 0
+        } else {
+            column += 1;
+        }
+
+        dbus.proxies().led().set_per_key(&key_colours)?;
+    }
+}

asusctl/examples/iterate-keys.rs

@@ -0,0 +1,56 @@
+use rog_types::{
+    fancy::{GX502Layout, Key, KeyColourArray, KeyLayout},
+};
+use rog_dbus::AuraDbusClient;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let (dbus, _) = AuraDbusClient::new()?;
+
+    let mut key_colours = KeyColourArray::new();
+    let layout = GX502Layout::default();
+
+    dbus.proxies().led().init_effect()?;
+    let rows = layout.get_rows();
+    loop {
+        for (r, row) in rows.iter().enumerate() {
+            for (k, key) in row.iter().enumerate() {
+                if let Some(c) = key_colours.key(*key) {
+                    *c.0 = 255;
+                };
+                // Last key of previous row
+                if k == 0 {
+                    if r == 0 {
+                        let k = &rows[rows.len() - 1][rows[rows.len() - 1].len() - 1];
+                        if let Some(c) = key_colours.key(*k) {
+                            *c.0 = 0;
+                        };
+                    } else {
+                        let k = &rows[r - 1][rows[r - 1].len() - 1];
+                        if let Some(c) = key_colours.key(*k) {
+                            *c.0 = 0;
+                        };
+                    }
+                } else {
+                    let k = &rows[r][k - 1];
+                    if let Some(c) = key_colours.key(*k) {
+                        *c.0 = 0;
+                    };
+                }
+                if let Some(c) = key_colours.key(Key::Up) {
+                    *c.0 = 255;
+                };
+                *key_colours.key(Key::Left).unwrap().0 = 255;
+                *key_colours.key(Key::Right).unwrap().0 = 255;
+                *key_colours.key(Key::Down).unwrap().0 = 255;
+
+                *key_colours.key(Key::W).unwrap().0 = 255;
+                *key_colours.key(Key::A).unwrap().0 = 255;
+                *key_colours.key(Key::S).unwrap().0 = 255;
+                *key_colours.key(Key::D).unwrap().0 = 255;
+
+                dbus.proxies().led().set_per_key(&key_colours)?;
+                std::thread::sleep(std::time::Duration::from_millis(100));
+            }
+        }
+    }
+}

asusctl/examples/per-key-effect-2.rs

@@ -0,0 +1,33 @@
+use rog_types::{
+    fancy::{Key, KeyColourArray},
+};
+use rog_dbus::AuraDbusClient;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let (dbus, _) = AuraDbusClient::new()?;
+
+    let mut key_colours = KeyColourArray::new();
+
+    dbus.proxies().led().init_effect()?;
+    loop {
+        let count = 49;
+        for _ in 0..count {
+            *key_colours.key(Key::ROG).unwrap().0 += 5;
+            *key_colours.key(Key::L).unwrap().0 += 5;
+            *key_colours.key(Key::I).unwrap().0 += 5;
+            *key_colours.key(Key::N).unwrap().0 += 5;
+            *key_colours.key(Key::U).unwrap().0 += 5;
+            *key_colours.key(Key::X).unwrap().0 += 5;
+            dbus.proxies().led().set_per_key(&key_colours)?;
+        }
+        for _ in 0..count {
+            *key_colours.key(Key::ROG).unwrap().0 -= 5;
+            *key_colours.key(Key::L).unwrap().0 -= 5;
+            *key_colours.key(Key::I).unwrap().0 -= 5;
+            *key_colours.key(Key::N).unwrap().0 -= 5;
+            *key_colours.key(Key::U).unwrap().0 -= 5;
+            *key_colours.key(Key::X).unwrap().0 -= 5;
+            dbus.proxies().led().set_per_key(&key_colours)?;
+        }
+    }
+}

asusctl/examples/pulser.rs

@@ -0,0 +1,40 @@
+use rog_types::{
+    fancy::{GX502Layout, KeyColourArray, KeyLayout},
+};
+use rog_dbus::AuraDbusClient;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let (dbus, _) = AuraDbusClient::new()?;
+
+    let mut key_colours = KeyColourArray::new();
+    let layout = GX502Layout::default();
+
+    dbus.proxies().led().init_effect()?;
+    let rows = layout.get_rows();
+
+    let mut fade = 50;
+    let mut flip = false;
+    loop {
+        for row in rows {
+            for (k, key) in row.iter().enumerate() {
+                if let Some(c) = key_colours.key(*key) {
+                    *c.0 = 255 / fade / (k + 1) as u8;
+                };
+            }
+        }
+
+        dbus.proxies().led().set_per_key(&key_colours)?;
+
+        if flip {
+            if fade > 1 {
+                fade -= 1;
+            } else {
+                flip = !flip;
+            }
+        } else if fade < 17 {
+            fade += 1;
+        } else {
+            flip = !flip;
+        }
+    }
+}

asusctl/src/main.rs

@@ -0,0 +1,373 @@
+use daemon::{ctrl_fan_cpu::FanLevel, ctrl_gfx::vendors::GfxVendors};
+use gumdrop::{Opt, Options};
+use rog_dbus::AuraDbusClient;
+use std::{env::args, process::Command};
+use yansi_term::Colour::Green;
+use yansi_term::Colour::Red;
+use rog_types::{cli_options::{AniMeActions, AniMeStatusValue, LedBrightness, SetAuraBuiltin}, profile::{ProfileCommand, ProfileEvent}};
+
+#[derive(Default, Options)]
+struct CLIStart {
+    #[options(help_flag, help = "print help message")]
+    help: bool,
+    #[options(help = "show program version number")]
+    version: bool,
+    #[options(help = "show supported functions of this laptop")]
+    show_supported: bool,
+    #[options(meta = "", help = "<off, low, med, high>")]
+    kbd_bright: Option<LedBrightness>,
+    #[options(
+        meta = "",
+        help = "<silent, normal, boost>, set fan mode independent of profile"
+    )]
+    fan_mode: Option<FanLevel>,
+    #[options(meta = "", help = "<20-100>")]
+    chg_limit: Option<u8>,
+    #[options(command)]
+    command: Option<CliCommand>,
+}
+
+#[derive(Options)]
+enum CliCommand {
+    #[options(help = "Set the keyboard lighting from built-in modes")]
+    LedMode(LedModeCommand),
+    #[options(help = "Create and configure profiles")]
+    Profile(ProfileCommand),
+    #[options(help = "Set the graphics mode")]
+    Graphics(GraphicsCommand),
+    #[options(name = "anime", help = "Manage AniMe Matrix")]
+    AniMe(AniMeCommand),
+    #[options(help = "Change bios settings")]
+    Bios(BiosCommand),
+}
+
+#[derive(Options)]
+struct LedModeCommand {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(help = "switch to next aura mode")]
+    next_mode: bool,
+    #[options(help = "switch to previous aura mode")]
+    prev_mode: bool,
+    #[options(command)]
+    command: Option<SetAuraBuiltin>,
+}
+
+#[derive(Options)]
+struct GraphicsCommand {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(
+        meta = "",
+        help = "Set graphics mode: <nvidia, hybrid, compute, integrated>"
+    )]
+    mode: Option<GfxVendors>,
+    #[options(help = "Get the current mode")]
+    get: bool,
+    #[options(help = "Get the current power status")]
+    pow: bool,
+    #[options(help = "Do not ask for confirmation")]
+    force: bool,
+}
+
+#[derive(Options)]
+struct AniMeCommand {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(
+        meta = "",
+        help = "turn on/off the panel (accept/reject write requests)"
+    )]
+    turn: Option<AniMeStatusValue>,
+    #[options(meta = "", help = "turn on/off the panel at boot (with Asus effect)")]
+    boot: Option<AniMeStatusValue>,
+    #[options(command)]
+    command: Option<AniMeActions>,
+}
+
+#[derive(Options, Debug)]
+struct BiosCommand {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(meta = "", no_long, help = "toggle bios POST sound")]
+    post_sound_set: Option<bool>,
+    #[options(no_long, help = "read bios POST sound")]
+    post_sound_get: bool,
+    #[options(meta = "", no_long, help = "toggle GPU to/from dedicated mode")]
+    dedicated_gfx_set: Option<bool>,
+    #[options(no_long, help = "get GPU mode")]
+    dedicated_gfx_get: bool,
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut args: Vec<String> = args().collect();
+    args.remove(0);
+
+    let parsed: CLIStart;
+    let missing_argument_k = gumdrop::Error::missing_argument(Opt::Short('k'));
+    match CLIStart::parse_args_default(&args) {
+        Ok(p) => {
+            parsed = p;
+        }
+        Err(err) if err.to_string() == missing_argument_k.to_string() => {
+            parsed = CLIStart {
+                kbd_bright: Some(LedBrightness::new(None)),
+                ..Default::default()
+            };
+        }
+        Err(err) => {
+            eprintln!("source {}", err);
+            std::process::exit(2);
+        }
+    }
+
+    if parsed.help_requested() {
+        // As help option don't work with `parse_args_default`
+        // we will call `parse_args_default_or_exit` instead
+        CLIStart::parse_args_default_or_exit();
+    }
+
+    if parsed.version {
+        println!("  asusctl version {}", env!("CARGO_PKG_VERSION"));
+        println!("   daemon version {}", daemon::VERSION);
+        println!(" rog-dbus version {}", rog_dbus::VERSION);
+        println!("rog-types version {}", rog_types::VERSION);
+    }
+
+    let (dbus, _) = AuraDbusClient::new()?;
+
+    match parsed.command {
+        Some(CliCommand::LedMode(mode)) => {
+            if (mode.command.is_none() && !mode.prev_mode && !mode.next_mode) || mode.help {
+                println!("Missing arg or command\n\n{}", mode.self_usage());
+                if let Some(lst) = mode.self_command_list() {
+                    println!("\n{}", lst);
+                }
+                println!("\nHelp can also be requested on modes, e.g: static --help");
+            }
+            if mode.next_mode && mode.prev_mode {
+                println!("Please specify either next or previous")
+            }
+            if mode.next_mode {
+                dbus.proxies().led().next_led_mode()?;
+            } else if mode.prev_mode {
+                dbus.proxies().led().prev_led_mode()?;
+            } else if let Some(command) = mode.command {
+                dbus.proxies().led().set_led_mode(&command.into())?
+            }
+        }
+        Some(CliCommand::Profile(cmd)) => {
+            if (!cmd.next
+                && !cmd.create
+                && cmd.curve.is_none()
+                && cmd.max_percentage.is_none()
+                && cmd.min_percentage.is_none()
+                && cmd.preset.is_none()
+                && cmd.profile.is_none()
+                && cmd.turbo.is_none())
+                || cmd.help
+            {
+                println!("Missing arg or command\n\n{}", cmd.self_usage());
+                if let Some(lst) = cmd.self_command_list() {
+                    println!("\n{}", lst);
+                }
+            }
+            if cmd.next {
+                dbus.proxies().profile().next_fan()?;
+            } else {
+                dbus.proxies()
+                    .profile()
+                    .write_command(&ProfileEvent::Cli(cmd))?
+            }
+        }
+        Some(CliCommand::Graphics(cmd)) => do_gfx(cmd, &dbus)?,
+        Some(CliCommand::AniMe(cmd)) => {
+            if (cmd.command.is_none() && cmd.boot.is_none() && cmd.turn.is_none()) || cmd.help {
+                println!("Missing arg or command\n\n{}", cmd.self_usage());
+                if let Some(lst) = cmd.self_command_list() {
+                    println!("\n{}", lst);
+                }
+            }
+            if let Some(anime_turn) = cmd.turn {
+                dbus.proxies().anime().toggle_on(anime_turn.into())?
+            }
+            if let Some(anime_boot) = cmd.boot {
+                dbus.proxies().anime().toggle_boot_on(anime_boot.into())?
+            }
+            if let Some(action) = cmd.command {
+                match action {
+                    AniMeActions::Leds(anime_leds) => {
+                        let led_brightness = anime_leds.led_brightness();
+                        dbus.proxies().anime().set_brightness(led_brightness)?;
+                    }
+                }
+            }
+        }
+        Some(CliCommand::Bios(cmd)) => {
+            if (cmd.dedicated_gfx_set.is_none()
+                && !cmd.dedicated_gfx_get
+                && cmd.post_sound_set.is_none()
+                && !cmd.post_sound_get)
+                || cmd.help
+            {
+                println!("Missing arg or command\n\n{}", cmd.self_usage());
+                if let Some(lst) = cmd.self_command_list() {
+                    println!("\n{}", lst);
+                }
+            }
+
+            if let Some(opt) = cmd.post_sound_set {
+                dbus.proxies().rog_bios().set_post_sound(opt)?;
+            }
+            if cmd.post_sound_get {
+                let res = if dbus.proxies().rog_bios().get_post_sound()? == 1 {
+                    true
+                } else {
+                    false
+                };
+                println!("Bios POST sound on: {}", res);
+            }
+            if let Some(opt) = cmd.dedicated_gfx_set {
+                dbus.proxies().rog_bios().set_dedicated_gfx(opt)?;
+            }
+            if cmd.dedicated_gfx_get {
+                let res = if dbus.proxies().rog_bios().get_dedicated_gfx()? == 1 {
+                    true
+                } else {
+                    false
+                };
+                println!("Bios dedicated GPU on: {}", res);
+            }
+        }
+        None => {
+            if (!parsed.show_supported
+                && parsed.kbd_bright.is_none()
+                && parsed.fan_mode.is_none()
+                && parsed.chg_limit.is_none())
+                || parsed.help
+            {
+                println!("{}", CLIStart::usage());
+                println!();
+                println!("{}", CLIStart::command_list().unwrap());
+            }
+        }
+    }
+
+    if let Some(brightness) = parsed.kbd_bright {
+        match brightness.level() {
+            None => {
+                let level = dbus.proxies().led().get_led_brightness()?;
+                println!("Current keyboard led brightness: {}", level.to_string());
+            }
+            Some(level) => dbus.proxies().led().set_brightness(level)?,
+        }
+    }
+
+    if parsed.show_supported {
+        let dat = dbus.proxies().supported().get_supported_functions()?;
+        println!("Supported laptop functions:\n{}", dat.to_string());
+    }
+
+    if let Some(fan_level) = parsed.fan_mode {
+        dbus.proxies().profile().write_fan_mode(fan_level.into())?;
+    }
+    if let Some(chg_limit) = parsed.chg_limit {
+        dbus.proxies().charge().write_limit(chg_limit)?;
+    }
+    Ok(())
+}
+
+fn do_gfx(
+    command: GraphicsCommand,
+    dbus_client: &AuraDbusClient,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if let Some(mode) = command.mode {
+        println!("Updating settings, please wait...");
+        println!("If this takes longer than 30s, ctrl+c then check `journalctl -b -u asusd`");
+
+        dbus_client
+            .proxies()
+            .gfx()
+            .gfx_write_mode(<&str>::from(&mode).into())?;
+        let res = dbus_client.gfx_wait_changed()?;
+        match res.as_str() {
+            "reboot" => {
+                println!(
+                    "{}",
+                    Green.paint("\nGraphics vendor mode changed successfully\n"),
+                );
+                do_gfx_action(
+                    command.force,
+                    Command::new("systemctl").arg("reboot").arg("-i"),
+                    "Reboot Linux PC",
+                    "Please reboot when ready",
+                )?;
+            }
+            "restartx" => {
+                println!(
+                    "{}",
+                    Green.paint("\nGraphics vendor mode changed successfully\n")
+                );
+                do_gfx_action(
+                    command.force,
+                    Command::new("systemctl")
+                        .arg("restart")
+                        .arg("display-manager.service"),
+                    "Restart display-manager server",
+                    "Please restart display-manager when ready",
+                )?;
+                std::process::exit(1)
+            }
+            _ => {
+                println!("{}", Red.paint(&format!("\n{}\n", res.as_str())),);
+                std::process::exit(-1);
+            }
+        }
+        std::process::exit(-1)
+    }
+    if command.get {
+        let res = dbus_client.proxies().gfx().gfx_get_mode()?;
+        println!("Current graphics mode: {}", res);
+    }
+    if command.pow {
+        let res = dbus_client.proxies().gfx().gfx_get_pwr()?;
+        if res.contains("active") {
+            println!("Current power status: {}", Red.paint(&format!("{}", res)));
+        } else {
+            println!("Current power status: {}", Green.paint(&format!("{}", res)));
+        }
+    }
+    Ok(())
+}
+
+fn do_gfx_action(
+    no_confirm: bool,
+    command: &mut Command,
+    ask_msg: &str,
+    cancel_msg: &str,
+) -> Result<(), Box<dyn std::error::Error>> {
+    println!("{}? y/n", ask_msg);
+
+    let mut buf = String::new();
+    if no_confirm {
+        let status = command.status()?;
+
+        if !status.success() {
+            println!("systemctl: returned with {}", status);
+        }
+    }
+
+    std::io::stdin().read_line(&mut buf).expect("Input failed");
+    let input = buf.chars().next().unwrap() as char;
+
+    if input == 'Y' || input == 'y' || no_confirm {
+        let status = command.status()?;
+
+        if !status.success() {
+            println!("systemctl: returned with {}", status);
+        }
+    } else {
+        println!("{}", Red.paint(&format!("{}", cancel_msg)));
+    }
+    Ok(())
+}