gilles/asusctl
1
0
Fork 0
mirror of https://gitlab.com/asus-linux/asusctl.git synced 2026-02-06 00:15:04 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' into main

Browse Source
This commit is contained in:
Luke Jones
2024-04-10 08:54:54 +12:00
committed by GitHub
parent 116afb9b6c be7686bb46
commit d89c1ebf26
61 changed files with 1573 additions and 3009 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
asusctl/examples/anime-diag-png.rs
View File

@@ -5,10 +5,12 @@ use std::process::exit;
use rog_anime::usb::get_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().collect();
if args.len() != 3 {
@@ -26,11 +28,7 @@ fn main() -> Result<(), Box<dyn Error>> {
let anime_type = get_anime_type()?;
client
.proxies()
.anime()
.write(matrix.into_data_buffer(anime_type)?)
.unwrap();
proxy.write(matrix.into_data_buffer(anime_type)?).unwrap();
Ok(())
}

10
asusctl/examples/anime-diag.rs
View File

@@ -3,7 +3,8 @@ use std::time::Duration;
use rog_anime::usb::get_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,7 +12,8 @@ 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);
@@ -28,9 +30,7 @@ fn main() {
}
let anime_type = get_anime_type().unwrap();
client
.proxies()
.anime()
proxy
.write(matrix.into_data_buffer(anime_type).unwrap())
.unwrap();
sleep(Duration::from_millis(300));

12
asusctl/examples/anime-gif.rs
View File

@@ -4,10 +4,12 @@ use std::thread::sleep;
use rog_anime::usb::get_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().collect();
if args.len() != 3 {
@@ -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());
}
}

9
asusctl/examples/anime-grid.rs
View File

@@ -2,7 +2,8 @@ use std::convert::TryFrom;
use rog_anime::usb::get_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,7 +11,9 @@ 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();
let anime_type = get_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();
}

8
asusctl/examples/anime-outline.rs
View File

@@ -1,12 +1,14 @@
use rog_anime::usb::get_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 conn = Connection::system().unwrap();
let proxy = AnimeProxyBlocking::new(&conn).unwrap();
let anime_type = get_anime_type().unwrap();
let mut matrix = AnimeDataBuffer::new(anime_type);
matrix.data_mut()[1] = 100; // start = 1
@@ -127,5 +129,5 @@ fn main() {
matrix.data_mut()[1244] = 100; // end
println!("{:?}", &matrix);
client.proxies().anime().write(matrix).unwrap();
proxy.write(matrix).unwrap();
}

12
asusctl/examples/anime-png.rs
View File

@@ -6,10 +6,12 @@ use std::process::exit;
use rog_anime::usb::get_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().collect();
if args.len() != 7 {
@@ -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(())
}

12
asusctl/examples/anime-spinning.rs
View File

@@ -9,10 +9,12 @@ use std::time::Duration;
use rog_anime::usb::get_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().collect();
if args.len() != 7 {
@@ -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));
}
}

11
asusctl/examples/aura-zoned-breathe.rs
View File

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

8
asusctl/src/aura_cli.rs
View File

@@ -10,10 +10,10 @@ pub struct LedPowerCommand1 {
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>")]

274
asusctl/src/main.rs
View File

@@ -12,14 +12,17 @@ use fan_curve_cli::FanCurveCommand;
use gumdrop::{Opt, Options};
use rog_anime::usb::get_anime_type;
use rog_anime::{AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, AnimeType, Vec2};
use rog_aura::power::KbAuraPowerState;
use rog_aura::usb::{AuraDevRog1, AuraDevTuf, AuraDevice, AuraPowerDev};
use rog_aura::{self, AuraEffect};
use rog_aura::aura_detection::PowerZones;
use rog_aura::keyboard::{AuraPowerState, LaptopAuraPower};
use rog_aura::{self, AuraDeviceType, AuraEffect};
use rog_dbus::zbus_anime::AnimeProxyBlocking;
use rog_dbus::zbus_aura::AuraProxyBlocking;
use rog_dbus::RogDbusClientBlocking;
use rog_dbus::zbus_fan_curves::FanCurvesProxyBlocking;
use rog_dbus::zbus_platform::PlatformProxyBlocking;
use rog_platform::platform::{GpuMode, Properties, ThrottlePolicy};
use rog_profiles::error::ProfileError;
use rog_slash::SlashMode;
use zbus::blocking::Connection;
use crate::aura_cli::{AuraPowerStates, LedBrightness};
use crate::cli_opts::*;
@@ -47,13 +50,21 @@ fn main() {
}
};
if let Ok((dbus, _)) = RogDbusClientBlocking::new().map_err(|e| {
let conn = Connection::system().unwrap();
if let Ok(platform_proxy) = PlatformProxyBlocking::new(&conn).map_err(|e| {
check_service("asusd");
println!("\nError: {e}\n");
print_info();
}) {
let supported_properties = dbus.proxies().platform().supported_properties().unwrap();
let supported_interfaces = dbus.proxies().platform().supported_interfaces().unwrap();
let self_version = env!("CARGO_PKG_VERSION");
let asusd_version = platform_proxy.version().unwrap();
if asusd_version != self_version {
println!("Version mismatch: asusctl = {self_version}, asusd = {asusd_version}");
return;
}
let supported_properties = platform_proxy.supported_properties().unwrap();
let supported_interfaces = platform_proxy.supported_interfaces().unwrap();
if parsed.version {
println!("asusctl v{}", env!("CARGO_PKG_VERSION"));
@@ -61,7 +72,7 @@ fn main() {
print_info();
}
if let Err(err) = do_parsed(&parsed, &supported_interfaces, &supported_properties, &dbus) {
if let Err(err) = do_parsed(&parsed, &supported_interfaces, &supported_properties, conn) {
print_error_help(&*err, &supported_interfaces, &supported_properties);
}
}
@@ -146,20 +157,24 @@ fn do_parsed(
parsed: &CliStart,
supported_interfaces: &[String],
supported_properties: &[Properties],
dbus: &RogDbusClientBlocking<'_>,
conn: Connection,
) -> Result<(), Box<dyn std::error::Error>> {
match &parsed.command {
Some(CliCommand::LedMode(mode)) => handle_led_mode(&find_aura_iface()?, mode)?,
Some(CliCommand::LedPow1(pow)) => handle_led_power1(&find_aura_iface()?, pow)?,
Some(CliCommand::LedPow2(pow)) => handle_led_power2(&find_aura_iface()?, pow)?,
Some(CliCommand::Profile(cmd)) => handle_throttle_profile(dbus, supported_properties, cmd)?,
Some(CliCommand::Profile(cmd)) => {
handle_throttle_profile(&conn, supported_properties, cmd)?
}
Some(CliCommand::FanCurve(cmd)) => {
handle_fan_curve(dbus, supported_interfaces, cmd)?;
handle_fan_curve(&conn, supported_interfaces, cmd)?;
}
Some(CliCommand::Graphics(_)) => do_gfx(),
Some(CliCommand::Anime(cmd)) => handle_anime(dbus, cmd)?,
Some(CliCommand::Slash(cmd)) => handle_slash(dbus, cmd)?,
Some(CliCommand::Bios(cmd)) => handle_platform_properties(dbus, supported_properties, cmd)?,
Some(CliCommand::Anime(cmd)) => handle_anime(&conn, cmd)?,
Some(CliCommand::Slash(cmd)) => handle_slash(&conn, cmd)?,
Some(CliCommand::Bios(cmd)) => {
handle_platform_properties(&conn, supported_properties, cmd)?
}
None => {
if (!parsed.show_supported
&& parsed.kbd_bright.is_none()
@@ -177,19 +192,19 @@ fn do_parsed(
.first()
.unwrap()
.device_type()
.unwrap_or(AuraDevice::Unknown)
.unwrap_or(AuraDeviceType::Unknown)
} else {
AuraDevice::Unknown
AuraDeviceType::Unknown
};
let commands: Vec<String> = cmdlist.lines().map(|s| s.to_owned()).collect();
for command in commands.iter().filter(|command| {
if !dev_type.is_old_style()
&& !dev_type.is_tuf_style()
if !dev_type.is_old_laptop()
&& !dev_type.is_tuf_laptop()
&& command.trim().starts_with("led-pow-1")
{
return false;
}
if !dev_type.is_new_style() && command.trim().starts_with("led-pow-2") {
if !dev_type.is_new_laptop() && command.trim().starts_with("led-pow-2") {
return false;
}
true
@@ -265,9 +280,8 @@ fn do_parsed(
}
if let Some(chg_limit) = parsed.chg_limit {
dbus.proxies()
.platform()
.set_charge_control_end_threshold(chg_limit)?;
let proxy = PlatformProxyBlocking::new(&conn)?;
proxy.set_charge_control_end_threshold(chg_limit)?;
}
Ok(())
@@ -281,10 +295,7 @@ fn do_gfx() {
println!("This command will be removed in future");
}
fn handle_anime(
dbus: &RogDbusClientBlocking<'_>,
cmd: &AnimeCommand,
) -> Result<(), Box<dyn std::error::Error>> {
fn handle_anime(conn: &Connection, cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
if (cmd.command.is_none()
&& cmd.enable_display.is_none()
&& cmd.enable_powersave_anim.is_none()
@@ -301,23 +312,24 @@ fn handle_anime(
println!("\n{}", lst);
}
}
let proxy = AnimeProxyBlocking::new(conn)?;
if let Some(enable) = cmd.enable_display {
dbus.proxies().anime().set_enable_display(enable)?;
proxy.set_enable_display(enable)?;
}
if let Some(enable) = cmd.enable_powersave_anim {
dbus.proxies().anime().set_builtins_enabled(enable)?;
proxy.set_builtins_enabled(enable)?;
}
if let Some(bright) = cmd.brightness {
dbus.proxies().anime().set_brightness(bright)?;
proxy.set_brightness(bright)?;
}
if let Some(enable) = cmd.off_when_lid_closed {
dbus.proxies().anime().set_off_when_lid_closed(enable)?;
proxy.set_off_when_lid_closed(enable)?;
}
if let Some(enable) = cmd.off_when_suspended {
dbus.proxies().anime().set_off_when_suspended(enable)?;
proxy.set_off_when_suspended(enable)?;
}
if let Some(enable) = cmd.off_when_unplugged {
dbus.proxies().anime().set_off_when_unplugged(enable)?;
proxy.set_off_when_unplugged(enable)?;
}
if cmd.off_with_his_head.is_some() {
println!("Did Alice _really_ make it back from Wonderland?");
@@ -333,7 +345,7 @@ fn handle_anime(
if cmd.clear {
let data = vec![255u8; anime_type.data_length()];
let tmp = AnimeDataBuffer::from_vec(anime_type, data)?;
dbus.proxies().anime().write(tmp)?;
proxy.write(tmp)?;
}
if let Some(action) = cmd.command.as_ref() {
@@ -357,9 +369,7 @@ fn handle_anime(
anime_type,
)?;
dbus.proxies()
.anime()
.write(<AnimeDataBuffer>::try_from(&matrix)?)?;
proxy.write(<AnimeDataBuffer>::try_from(&matrix)?)?;
}
AnimeActions::PixelImage(image) => {
if image.help_requested() || image.path.is_empty() {
@@ -378,9 +388,7 @@ fn handle_anime(
anime_type,
)?;
dbus.proxies()
.anime()
.write(matrix.into_data_buffer(anime_type)?)?;
proxy.write(matrix.into_data_buffer(anime_type)?)?;
}
AnimeActions::Gif(gif) => {
if gif.help_requested() || gif.path.is_empty() {
@@ -405,7 +413,7 @@ fn handle_anime(
let mut loops = gif.loops as i32;
loop {
for frame in matrix.frames() {
dbus.proxies().anime().write(frame.frame().clone())?;
proxy.write(frame.frame().clone())?;
sleep(frame.delay());
}
if loops >= 0 {
@@ -436,7 +444,7 @@ fn handle_anime(
let mut loops = gif.loops as i32;
loop {
for frame in matrix.frames() {
dbus.proxies().anime().write(frame.frame().clone())?;
proxy.write(frame.frame().clone())?;
sleep(frame.delay());
}
if loops >= 0 {
@@ -457,14 +465,12 @@ fn handle_anime(
return Ok(());
}
dbus.proxies()
.anime()
.set_builtin_animations(rog_anime::Animations {
boot: builtins.boot,
awake: builtins.awake,
sleep: builtins.sleep,
shutdown: builtins.shutdown,
})?;
proxy.set_builtin_animations(rog_anime::Animations {
boot: builtins.boot,
awake: builtins.awake,
sleep: builtins.sleep,
shutdown: builtins.shutdown,
})?;
}
}
}
@@ -606,15 +612,15 @@ fn handle_led_power1(
) -> Result<(), Box<dyn std::error::Error>> {
for aura in aura {
let dev_type = aura.device_type()?;
if !dev_type.is_old_style() && !dev_type.is_tuf_style() {
if !dev_type.is_old_laptop() && !dev_type.is_tuf_laptop() {
println!("This option applies only to keyboards 2021+");
}
if power.awake.is_none()
&& power.sleep.is_none()
&& power.boot.is_none()
&& power.keyboard.is_none()
&& power.lightbar.is_none()
&& !power.keyboard
&& !power.lightbar
{
if !power.help {
println!("Missing arg or command\n");
@@ -623,15 +629,10 @@ fn handle_led_power1(
return Ok(());
}
if dev_type.is_old_style() {
if dev_type.is_old_laptop() || dev_type.is_tuf_laptop() {
handle_led_power_1_do_1866(aura, power)?;
return Ok(());
}
if dev_type.is_tuf_style() {
handle_led_power_1_do_tuf(aura, power)?;
return Ok(());
}
}
println!("These options are for keyboards of product ID 0x1866 or TUF only");
@@ -642,62 +643,24 @@ fn handle_led_power_1_do_1866(
aura: &AuraProxyBlocking,
power: &LedPowerCommand1,
) -> Result<(), Box<dyn std::error::Error>> {
let mut enabled: Vec<AuraDevRog1> = Vec::new();
let mut disabled: Vec<AuraDevRog1> = Vec::new();
let mut check = |e: Option<bool>, a: AuraDevRog1| {
if let Some(arg) = e {
if arg {
enabled.push(a);
} else {
disabled.push(a);
}
}
let zone = if power.keyboard && power.lightbar {
PowerZones::KeyboardAndLightbar
} else if power.lightbar {
PowerZones::Lightbar
} else {
PowerZones::Keyboard
};
let states = LaptopAuraPower {
states: vec![AuraPowerState {
zone,
boot: power.boot.unwrap_or_default(),
awake: power.awake.unwrap_or_default(),
sleep: power.sleep.unwrap_or_default(),
shutdown: false,
}],
};
check(power.awake, AuraDevRog1::Awake);
check(power.boot, AuraDevRog1::Boot);
check(power.sleep, AuraDevRog1::Sleep);
check(power.keyboard, AuraDevRog1::Keyboard);
check(power.lightbar, AuraDevRog1::Lightbar);
let data = AuraPowerDev {
old_rog: enabled,
..Default::default()
};
aura.set_led_power(data.clone())?; // TODO: verify this
Ok(())
}
fn handle_led_power_1_do_tuf(
aura: &AuraProxyBlocking,
power: &LedPowerCommand1,
) -> Result<(), Box<dyn std::error::Error>> {
let mut enabled: Vec<AuraDevTuf> = Vec::new();
let mut disabled: Vec<AuraDevTuf> = Vec::new();
let mut check = |e: Option<bool>, a: AuraDevTuf| {
if let Some(arg) = e {
if arg {
enabled.push(a);
} else {
disabled.push(a);
}
}
};
check(power.awake, AuraDevTuf::Awake);
check(power.boot, AuraDevTuf::Boot);
check(power.sleep, AuraDevTuf::Sleep);
check(power.keyboard, AuraDevTuf::Keyboard);
let data = AuraPowerDev {
tuf: enabled,
..Default::default()
};
aura.set_led_power(data.clone())?; // TODO: verify this
aura.set_led_power(states)?;
Ok(())
}
@@ -708,7 +671,7 @@ fn handle_led_power2(
) -> Result<(), Box<dyn std::error::Error>> {
for aura in aura {
let dev_type = aura.device_type()?;
if !dev_type.is_new_style() {
if !dev_type.is_new_laptop() {
println!("This option applies only to keyboards 2021+");
continue;
}
@@ -737,25 +700,30 @@ fn handle_led_power2(
return Ok(());
}
let set = |power: &mut KbAuraPowerState, set_to: &AuraPowerStates| {
power.boot = set_to.boot;
power.awake = set_to.awake;
power.sleep = set_to.sleep;
power.shutdown = set_to.shutdown;
let mut states = aura.led_power()?;
let mut set = |zone: PowerZones, set_to: &AuraPowerStates| {
for state in states.states.iter_mut() {
if state.zone == zone {
state.boot = set_to.boot;
state.awake = set_to.awake;
state.sleep = set_to.sleep;
state.shutdown = set_to.shutdown;
break;
}
}
};
let mut enabled = aura.led_power()?;
if let Some(cmd) = &power.command {
match cmd {
aura_cli::SetAuraZoneEnabled::Keyboard(k) => set(&mut enabled.rog.keyboard, k),
aura_cli::SetAuraZoneEnabled::Logo(l) => set(&mut enabled.rog.logo, l),
aura_cli::SetAuraZoneEnabled::Lightbar(l) => set(&mut enabled.rog.lightbar, l),
aura_cli::SetAuraZoneEnabled::Lid(l) => set(&mut enabled.rog.lid, l),
aura_cli::SetAuraZoneEnabled::RearGlow(r) => set(&mut enabled.rog.rear_glow, r),
aura_cli::SetAuraZoneEnabled::Keyboard(k) => set(PowerZones::Keyboard, k),
aura_cli::SetAuraZoneEnabled::Logo(l) => set(PowerZones::Logo, l),
aura_cli::SetAuraZoneEnabled::Lightbar(l) => set(PowerZones::Lightbar, l),
aura_cli::SetAuraZoneEnabled::Lid(l) => set(PowerZones::Lid, l),
aura_cli::SetAuraZoneEnabled::RearGlow(r) => set(PowerZones::RearGlow, r),
}
}
aura.set_led_power(enabled)?;
aura.set_led_power(states)?;
}
}
@@ -763,7 +731,7 @@ fn handle_led_power2(
}
fn handle_throttle_profile(
dbus: &RogDbusClientBlocking<'_>,
conn: &Connection,
supported: &[Properties],
cmd: &ProfileCommand,
) -> Result<(), Box<dyn std::error::Error>> {
@@ -783,16 +751,14 @@ fn handle_throttle_profile(
}
return Ok(());
}
let current = dbus.proxies().platform().throttle_thermal_policy()?;
let proxy = PlatformProxyBlocking::new(conn)?;
let current = proxy.throttle_thermal_policy()?;
if cmd.next {
dbus.proxies()
.platform()
.set_throttle_thermal_policy(current.next())?;
proxy.set_throttle_thermal_policy(current.next())?;
} else if let Some(profile) = cmd.profile_set {
dbus.proxies()
.platform()
.set_throttle_thermal_policy(profile)?;
proxy.set_throttle_thermal_policy(profile)?;
}
if cmd.list {
@@ -810,7 +776,7 @@ fn handle_throttle_profile(
}
fn handle_fan_curve(
dbus: &RogDbusClientBlocking<'_>,
conn: &Connection,
supported: &[String],
cmd: &FanCurveCommand,
) -> Result<(), Box<dyn std::error::Error>> {
@@ -841,37 +807,35 @@ fn handle_fan_curve(
return Ok(());
}
let plat_proxy = PlatformProxyBlocking::new(conn)?;
let fan_proxy = FanCurvesProxyBlocking::new(conn)?;
if cmd.get_enabled {
let profile = dbus.proxies().platform().throttle_thermal_policy()?;
let curves = dbus.proxies().fan_curves().fan_curve_data(profile)?;
let profile = plat_proxy.throttle_thermal_policy()?;
let curves = fan_proxy.fan_curve_data(profile)?;
for curve in curves.iter() {
println!("{}", String::from(curve));
}
}
if cmd.default {
let active = dbus.proxies().platform().throttle_thermal_policy()?;
dbus.proxies().fan_curves().set_curves_to_defaults(active)?;
let active = plat_proxy.throttle_thermal_policy()?;
fan_proxy.set_curves_to_defaults(active)?;
}
if let Some(profile) = cmd.mod_profile {
if cmd.enable_fan_curves.is_none() && cmd.data.is_none() {
let data = dbus.proxies().fan_curves().fan_curve_data(profile)?;
let data = fan_proxy.fan_curve_data(profile)?;
let data = toml::to_string(&data)?;
println!("\nFan curves for {:?}\n\n{}", profile, data);
}
if let Some(enabled) = cmd.enable_fan_curves {
dbus.proxies()
.fan_curves()
.set_fan_curves_enabled(profile, enabled)?;
fan_proxy.set_fan_curves_enabled(profile, enabled)?;
}
if let Some(enabled) = cmd.enable_fan_curve {
if let Some(fan) = cmd.fan {
dbus.proxies()
.fan_curves()
.set_profile_fan_curve_enabled(profile, fan, enabled)?;
fan_proxy.set_profile_fan_curve_enabled(profile, fan, enabled)?;
} else {
println!(
"--enable-fan-curves, --enable-fan-curve, --fan, and --data options require \
@@ -883,7 +847,7 @@ fn handle_fan_curve(
if let Some(mut curve) = cmd.data.clone() {
let fan = cmd.fan.unwrap_or_default();
curve.set_fan(fan);
dbus.proxies().fan_curves().set_fan_curve(profile, curve)?;
fan_proxy.set_fan_curve(profile, curve)?;
}
}
@@ -891,7 +855,7 @@ fn handle_fan_curve(
}
fn handle_platform_properties(
dbus: &RogDbusClientBlocking<'_>,
conn: &Connection,
supported: &[Properties],
cmd: &BiosCommand,
) -> Result<(), Box<dyn std::error::Error>> {
@@ -917,34 +881,34 @@ fn handle_platform_properties(
}
}
let proxy = PlatformProxyBlocking::new(conn)?;
if let Some(opt) = cmd.post_sound_set {
dbus.proxies().platform().set_boot_sound(opt)?;
proxy.set_boot_sound(opt)?;
}
if cmd.post_sound_get {
let res = dbus.proxies().platform().boot_sound()?;
let res = proxy.boot_sound()?;
println!("Bios POST sound on: {}", res);
}
if let Some(opt) = cmd.gpu_mux_mode_set {
println!("Rebuilding initrd to include drivers");
dbus.proxies()
.platform()
.set_gpu_mux_mode(GpuMode::from_mux(opt))?;
proxy.set_gpu_mux_mode(GpuMode::from_mux(opt))?;
println!(
"The mode change is not active until you reboot, on boot the bios will make the \
required change"
);
}
if cmd.gpu_mux_mode_get {
let res = dbus.proxies().platform().gpu_mux_mode()?;
let res = proxy.gpu_mux_mode()?;
println!("Bios GPU MUX: {:?}", res);
}
if let Some(opt) = cmd.panel_overdrive_set {
dbus.proxies().platform().set_panel_od(opt)?;
proxy.set_panel_od(opt)?;
}
if cmd.panel_overdrive_get {
let res = dbus.proxies().platform().panel_od()?;
let res = proxy.panel_od()?;
println!("Panel overdrive on: {}", res);
}
}