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

Anime: refactor power stuff

Browse Source
This commit is contained in:
Luke D. Jones
2023-11-15 14:22:45 +13:00
parent 71ee9e43ba
commit 8eb9b1d4eb
13 changed files with 280 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CHANGELOG.md
View File

@@ -9,8 +9,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
### Added ### Added
- Support for G513RW LED modes - Support for G513RW LED modes
- Support Rog Ally LED modes (basic) - Support Rog Ally LED modes (basic)
- Add on_lid_closed and on_external_power_changed events for running certain tasks
### Changed ### Changed
- asusd: remove set_image_brightness for anime
- asusd: refactor how certain things like display enable/builtins are toggled
- Refactor sleep/shutdown tasks
- rog-control-center: ensure brightness slider works correctly - rog-control-center: ensure brightness slider works correctly
- Update `smithay-client-toolkit` for fix to issue #407 - Update `smithay-client-toolkit` for fix to issue #407

2
asusctl/src/anime_cli.rs
View File

@@ -17,8 +17,6 @@ pub struct AnimeCommand {
help = "set global base brightness value <Off, Low, Med, High>" help = "set global base brightness value <Off, Low, Med, High>"
)] )]
pub brightness: Option<Brightness>, pub brightness: Option<Brightness>,
#[options(meta = "", help = "set global (image) brightness value")]
pub image_brightness: Option<f32>,
#[options(help = "clear the display")] #[options(help = "clear the display")]
pub clear: bool, pub clear: bool,
#[options(command)] #[options(command)]

6
asusctl/src/main.rs
View File

@@ -207,7 +207,6 @@ fn handle_anime(
&& cmd.enable_display.is_none() && cmd.enable_display.is_none()
&& cmd.enable_powersave_anim.is_none() && cmd.enable_powersave_anim.is_none()
&& cmd.brightness.is_none() && cmd.brightness.is_none()
&& cmd.image_brightness.is_none()
&& !cmd.clear) && !cmd.clear)
|| cmd.help || cmd.help
{ {
@@ -220,15 +219,12 @@ fn handle_anime(
dbus.proxies().anime().set_enable_display(enable)?; dbus.proxies().anime().set_enable_display(enable)?;
} }
if let Some(enable) = cmd.enable_powersave_anim { if let Some(enable) = cmd.enable_powersave_anim {
dbg!(enable);
dbus.proxies().anime().set_builtins_enabled(enable)?; dbus.proxies().anime().set_builtins_enabled(enable)?;
} }
if let Some(bright) = cmd.brightness { if let Some(bright) = cmd.brightness {
dbus.proxies().anime().set_brightness(bright)?; dbus.proxies().anime().set_brightness(bright)?;
} }
if let Some(bright) = cmd.image_brightness {
verify_brightness(bright);
dbus.proxies().anime().set_image_brightness(bright)?;
}
let mut anime_type = get_anime_type()?; let mut anime_type = get_anime_type()?;
if let AnimeType::Unknown = anime_type { if let AnimeType::Unknown = anime_type {

1
asusd/Cargo.toml
View File

@@ -21,6 +21,7 @@ rog_platform = { path = "../rog-platform" }
rog_profiles = { path = "../rog-profiles" } rog_profiles = { path = "../rog-profiles" }
rog_dbus = { path = "../rog-dbus" } rog_dbus = { path = "../rog-dbus" }
dmi_id = { path = "../dmi-id" } dmi_id = { path = "../dmi-id" }
futures-lite = "*"
async-trait.workspace = true async-trait.workspace = true
tokio.workspace = true tokio.workspace = true

31
asusd/src/ctrl_anime/config.rs
View File

@@ -32,25 +32,33 @@ impl From<AnimeConfigV460> for AnimeConfig {
} }
#[derive(Deserialize, Serialize, Debug)] #[derive(Deserialize, Serialize, Debug)]
pub struct AnimeConfigV5 { pub struct AnimeConfigV472 {
pub model_override: Option<AnimeType>,
pub system: Vec<ActionLoader>, pub system: Vec<ActionLoader>,
pub boot: Vec<ActionLoader>, pub boot: Vec<ActionLoader>,
pub wake: Vec<ActionLoader>, pub wake: Vec<ActionLoader>,
pub sleep: Vec<ActionLoader>, pub sleep: Vec<ActionLoader>,
pub shutdown: Vec<ActionLoader>, pub shutdown: Vec<ActionLoader>,
pub brightness: f32, pub brightness: f32,
pub awake_enabled: bool, pub display_enabled: bool,
pub boot_anim_enabled: bool, pub display_brightness: Brightness,
pub builtin_anims_enabled: bool,
pub builtin_anims: Animations,
} }
impl From<AnimeConfigV5> for AnimeConfig { impl From<AnimeConfigV472> for AnimeConfig {
fn from(c: AnimeConfigV5) -> AnimeConfig { fn from(c: AnimeConfigV472) -> AnimeConfig {
AnimeConfig { AnimeConfig {
system: c.system, system: c.system,
boot: c.boot, boot: c.boot,
wake: c.wake, wake: c.wake,
sleep: c.sleep, sleep: c.sleep,
shutdown: c.shutdown, shutdown: c.shutdown,
model_override: c.model_override,
display_enabled: c.display_enabled,
display_brightness: c.display_brightness,
builtin_anims_enabled: c.builtin_anims_enabled,
builtin_anims: c.builtin_anims,
..Default::default() ..Default::default()
} }
} }
@@ -113,10 +121,13 @@ pub struct AnimeConfig {
pub wake: Vec<ActionLoader>, pub wake: Vec<ActionLoader>,
pub sleep: Vec<ActionLoader>, pub sleep: Vec<ActionLoader>,
pub shutdown: Vec<ActionLoader>, pub shutdown: Vec<ActionLoader>,
pub brightness: f32, // pub brightness: f32,
pub display_enabled: bool, pub display_enabled: bool,
pub display_brightness: Brightness, pub display_brightness: Brightness,
pub builtin_anims_enabled: bool, pub builtin_anims_enabled: bool,
pub off_when_unplugged: bool,
pub off_when_suspended: bool,
pub off_when_lid_closed: bool,
pub builtin_anims: Animations, pub builtin_anims: Animations,
} }
@@ -129,10 +140,13 @@ impl Default for AnimeConfig {
wake: Vec::new(), wake: Vec::new(),
sleep: Vec::new(), sleep: Vec::new(),
shutdown: Vec::new(), shutdown: Vec::new(),
brightness: 1.0, // brightness: 1.0,
display_enabled: true, display_enabled: true,
display_brightness: Brightness::Med, display_brightness: Brightness::Med,
builtin_anims_enabled: true, builtin_anims_enabled: true,
off_when_unplugged: true,
off_when_suspended: true,
off_when_lid_closed: true,
builtin_anims: Animations::default(), builtin_anims: Animations::default(),
} }
} }
@@ -152,7 +166,7 @@ impl StdConfig for AnimeConfig {
} }
} }
impl StdConfigLoad2<AnimeConfigV460, AnimeConfigV5> for AnimeConfig {} impl StdConfigLoad2<AnimeConfigV460, AnimeConfigV472> for AnimeConfig {}
impl AnimeConfig { impl AnimeConfig {
// fn clamp_config_brightness(mut config: &mut AnimeConfig) { // fn clamp_config_brightness(mut config: &mut AnimeConfig) {
@@ -209,7 +223,6 @@ impl AnimeConfig {
brightness: 1.0, brightness: 1.0,
time: AnimTime::Infinite, time: AnimTime::Infinite,
}], }],
brightness: 1.0,
..Default::default() ..Default::default()
} }
} }

22
asusd/src/ctrl_anime/mod.rs
View File

@@ -10,7 +10,10 @@ use std::thread::sleep;
use ::zbus::export::futures_util::lock::Mutex; use ::zbus::export::futures_util::lock::Mutex;
use log::{error, info, warn}; use log::{error, info, warn};
use rog_anime::error::AnimeError; use rog_anime::error::AnimeError;
use rog_anime::usb::{get_anime_type, pkt_flush, pkt_set_enable_powersave_anim, pkts_for_init}; use rog_anime::usb::{
get_anime_type, pkt_flush, pkt_set_brightness, pkt_set_enable_display,
pkt_set_enable_powersave_anim, pkts_for_init, Brightness,
};
use rog_anime::{ActionData, AnimeDataBuffer, AnimePacketType, AnimeType}; use rog_anime::{ActionData, AnimeDataBuffer, AnimePacketType, AnimeType};
use rog_platform::hid_raw::HidRaw; use rog_platform::hid_raw::HidRaw;
use rog_platform::supported::AnimeSupportedFunctions; use rog_platform::supported::AnimeSupportedFunctions;
@@ -50,6 +53,13 @@ impl Node {
} }
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 { pub struct CtrlAnime {
@@ -234,6 +244,14 @@ impl CtrlAnime {
}) })
.ok(); .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 // Loop ended, set the atmonics
thread_running.store(false, Ordering::SeqCst); thread_running.store(false, Ordering::SeqCst);
@@ -247,7 +265,7 @@ impl CtrlAnime {
/// global brightness set in config. /// global brightness set in config.
fn write_data_buffer(&self, mut buffer: AnimeDataBuffer) -> Result<(), RogError> { fn write_data_buffer(&self, mut buffer: AnimeDataBuffer) -> Result<(), RogError> {
for led in buffer.data_mut().iter_mut() { 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 { if bright > 254.0 {
bright = 254.0; bright = 254.0;
} }

182
asusd/src/ctrl_anime/trait_impls.rs
View File

@@ -39,25 +39,12 @@ impl CtrlAnimeZbus {
let lock = self.0.lock().await; let lock = self.0.lock().await;
lock.thread_exit.store(true, Ordering::SeqCst); lock.thread_exit.store(true, Ordering::SeqCst);
lock.write_data_buffer(input).map_err(|err| { lock.write_data_buffer(input).map_err(|err| {
warn!("rog_anime::run_animation:callback {}", err); warn!("ctrl_anime::run_animation:callback {}", err);
err err
})?; })?;
Ok(()) Ok(())
} }
/// Set the global AniMe brightness
async fn set_image_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 base brightness level /// Set base brightness level
// TODO: enum for brightness // TODO: enum for brightness
async fn set_brightness( async fn set_brightness(
@@ -69,9 +56,17 @@ impl CtrlAnimeZbus {
lock.node lock.node
.write_bytes(&pkt_set_brightness(brightness)) .write_bytes(&pkt_set_brightness(brightness))
.map_err(|err| { .map_err(|err| {
warn!("rog_anime::run_animation:callback {}", err); warn!("ctrl_anime::set_brightness {}", err);
}) })
.ok(); .ok();
lock.node
.write_bytes(&pkt_set_enable_display(brightness != Brightness::Off))
.map_err(|err| {
warn!("ctrl_anime::set_brightness {}", err);
})
.ok();
lock.config.display_enabled = brightness != Brightness::Off;
lock.config.display_brightness = brightness; lock.config.display_brightness = brightness;
lock.config.write(); lock.config.write();
@@ -82,6 +77,8 @@ impl CtrlAnimeZbus {
display_brightness: lock.config.display_brightness, display_brightness: lock.config.display_brightness,
builtin_anims_enabled: lock.config.builtin_anims_enabled, builtin_anims_enabled: lock.config.builtin_anims_enabled,
builtin_anims: lock.config.builtin_anims, builtin_anims: lock.config.builtin_anims,
off_when_unplugged: lock.config.off_when_unplugged,
off_when_suspended: lock.config.off_when_suspended,
}, },
) )
.await .await
@@ -97,11 +94,27 @@ impl CtrlAnimeZbus {
) { ) {
let mut lock = self.0.lock().await; let mut lock = self.0.lock().await;
lock.node lock.node
.write_bytes(&pkt_set_enable_powersave_anim(enabled)) .set_builtins_enabled(enabled, lock.config.display_brightness)
.map_err(|err| { .map_err(|err| {
warn!("rog_anime::run_animation:callback {}", err); warn!("ctrl_anime::set_builtins_enabled {}", err);
}) })
.ok(); .ok();
if !enabled {
let data = vec![255u8; lock.anime_type.data_length()];
if let Ok(tmp) = AnimeDataBuffer::from_vec(lock.anime_type, data).map_err(|err| {
warn!("ctrl_anime::set_builtins_enabled {}", err);
}) {
lock.node
.write_bytes(tmp.data())
.map_err(|err| {
warn!("ctrl_anime::set_builtins_enabled {}", err);
})
.ok();
}
}
lock.config.display_enabled = enabled;
lock.config.builtin_anims_enabled = enabled; lock.config.builtin_anims_enabled = enabled;
lock.config.write(); lock.config.write();
if enabled { if enabled {
@@ -115,6 +128,8 @@ impl CtrlAnimeZbus {
display_brightness: lock.config.display_brightness, display_brightness: lock.config.display_brightness,
builtin_anims_enabled: lock.config.builtin_anims_enabled, builtin_anims_enabled: lock.config.builtin_anims_enabled,
builtin_anims: lock.config.builtin_anims, builtin_anims: lock.config.builtin_anims,
off_when_unplugged: lock.config.off_when_unplugged,
off_when_suspended: lock.config.off_when_suspended,
}, },
) )
.await .await
@@ -132,17 +147,18 @@ impl CtrlAnimeZbus {
) { ) {
let mut lock = self.0.lock().await; let mut lock = self.0.lock().await;
lock.node lock.node
.write_bytes(&pkt_set_enable_powersave_anim(true)) .write_bytes(&pkt_set_builtin_animations(boot, awake, sleep, shutdown))
.map_err(|err| { .map_err(|err| {
warn!("rog_anime::run_animation:callback {}", err); warn!("ctrl_anime::run_animation:callback {}", err);
}) })
.ok(); .ok();
lock.node lock.node
.write_bytes(&pkt_set_builtin_animations(boot, awake, sleep, shutdown)) .write_bytes(&pkt_set_enable_powersave_anim(true))
.map_err(|err| { .map_err(|err| {
warn!("rog_anime::run_animation:callback {}", err); warn!("ctrl_anime::run_animation:callback {}", err);
}) })
.ok(); .ok();
lock.config.display_enabled = true;
lock.config.builtin_anims.boot = boot; lock.config.builtin_anims.boot = boot;
lock.config.builtin_anims.sleep = sleep; lock.config.builtin_anims.sleep = sleep;
lock.config.builtin_anims.awake = awake; lock.config.builtin_anims.awake = awake;
@@ -156,6 +172,8 @@ impl CtrlAnimeZbus {
display_brightness: lock.config.display_brightness, display_brightness: lock.config.display_brightness,
builtin_anims_enabled: lock.config.builtin_anims_enabled, builtin_anims_enabled: lock.config.builtin_anims_enabled,
builtin_anims: lock.config.builtin_anims, builtin_anims: lock.config.builtin_anims,
off_when_unplugged: lock.config.off_when_unplugged,
off_when_suspended: lock.config.off_when_suspended,
}, },
) )
.await .await
@@ -172,7 +190,7 @@ impl CtrlAnimeZbus {
lock.node lock.node
.write_bytes(&pkt_set_enable_display(enabled)) .write_bytes(&pkt_set_enable_display(enabled))
.map_err(|err| { .map_err(|err| {
warn!("rog_anime::run_animation:callback {}", err); warn!("ctrl_anime::run_animation:callback {}", err);
}) })
.ok(); .ok();
lock.config.display_enabled = enabled; lock.config.display_enabled = enabled;
@@ -185,6 +203,8 @@ impl CtrlAnimeZbus {
display_brightness: lock.config.display_brightness, display_brightness: lock.config.display_brightness,
builtin_anims_enabled: lock.config.builtin_anims_enabled, builtin_anims_enabled: lock.config.builtin_anims_enabled,
builtin_anims: lock.config.builtin_anims, builtin_anims: lock.config.builtin_anims,
off_when_unplugged: lock.config.off_when_unplugged,
off_when_suspended: lock.config.off_when_suspended,
}, },
) )
.await .await
@@ -210,6 +230,8 @@ impl CtrlAnimeZbus {
display_brightness: lock.config.display_brightness, display_brightness: lock.config.display_brightness,
builtin_anims_enabled: lock.config.builtin_anims_enabled, builtin_anims_enabled: lock.config.builtin_anims_enabled,
builtin_anims: lock.config.builtin_anims, builtin_anims: lock.config.builtin_anims,
off_when_unplugged: lock.config.off_when_unplugged,
off_when_suspended: lock.config.off_when_suspended,
} }
} }
@@ -231,36 +253,80 @@ impl crate::CtrlTask for CtrlAnimeZbus {
let inner3 = self.0.clone(); let inner3 = self.0.clone();
let inner4 = self.0.clone(); let inner4 = self.0.clone();
self.create_sys_event_tasks( self.create_sys_event_tasks(
move || { move |sleeping| {
// on_sleep // on_sleep
let inner1 = inner1.clone(); let inner = inner1.clone();
async move { async move {
let lock = inner1.lock().await; let lock = inner.lock().await;
CtrlAnime::run_thread(inner1.clone(), lock.cache.sleep.clone(), true).await; if lock.config.display_enabled {
if lock.config.off_when_suspended {
lock.node
.write_bytes(&pkt_set_enable_display(!sleeping))
.map_err(|err| {
warn!("create_sys_event_tasks::off_when_suspended {}", err);
})
.ok();
}
if !lock.config.builtin_anims_enabled {
if sleeping {
CtrlAnime::run_thread(
inner.clone(),
lock.cache.sleep.clone(),
true,
)
.await;
} else {
CtrlAnime::run_thread(inner.clone(), lock.cache.wake.clone(), true)
.await;
}
}
}
} }
}, },
move || { move |shutting_down| {
// on_wake
let inner2 = inner2.clone();
async move {
let lock = inner2.lock().await;
CtrlAnime::run_thread(inner2.clone(), lock.cache.wake.clone(), true).await;
}
},
move || {
// on_shutdown // on_shutdown
let inner3 = inner3.clone(); let inner = inner2.clone();
async move { async move {
let lock = inner3.lock().await; let lock = inner.lock().await;
CtrlAnime::run_thread(inner3.clone(), lock.cache.shutdown.clone(), true).await; if lock.config.display_enabled && !lock.config.builtin_anims_enabled {
if shutting_down {
CtrlAnime::run_thread(inner.clone(), lock.cache.shutdown.clone(), true)
.await;
} else {
CtrlAnime::run_thread(inner.clone(), lock.cache.boot.clone(), true)
.await;
}
}
} }
}, },
move || { move |lid_closed| {
// on_boot let inner = inner3.clone();
let inner4 = inner4.clone(); // on lid change
async move { async move {
let lock = inner4.lock().await; let lock = inner.lock().await;
CtrlAnime::run_thread(inner4.clone(), lock.cache.boot.clone(), true).await; if lock.config.off_when_lid_closed {
lock.node
.write_bytes(&pkt_set_enable_display(lid_closed))
.map_err(|err| {
warn!("create_sys_event_tasks::off_when_lid_closed {}", err);
})
.ok();
}
}
},
move |power_plugged| {
let inner = inner4.clone();
// on power change
async move {
let lock = inner.lock().await;
if lock.config.off_when_unplugged {
lock.node
.write_bytes(&pkt_set_enable_display(power_plugged))
.map_err(|err| {
warn!("create_sys_event_tasks::off_when_unplugged {}", err);
})
.ok();
}
} }
}, },
) )
@@ -275,25 +341,29 @@ impl crate::Reloadable for CtrlAnimeZbus {
async fn reload(&mut self) -> Result<(), RogError> { async fn reload(&mut self) -> Result<(), RogError> {
if let Some(lock) = self.0.try_lock() { if let Some(lock) = self.0.try_lock() {
let anim = &lock.config.builtin_anims; let anim = &lock.config.builtin_anims;
lock.node // Set builtins
.write_bytes(&pkt_set_enable_display(lock.config.display_enabled))?; if lock.config.builtin_anims_enabled {
lock.node.write_bytes(&pkt_set_enable_powersave_anim( 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.builtin_anims_enabled,
))?; lock.config.display_brightness,
lock.node.write_bytes(&pkt_set_builtin_animations( )?;
anim.boot,
anim.awake,
anim.sleep,
anim.shutdown,
))?;
if lock.config.builtin_anims_enabled && !lock.cache.boot.is_empty() { if !lock.config.builtin_anims_enabled && !lock.cache.boot.is_empty() {
lock.node lock.node
.write_bytes(&pkt_set_enable_powersave_anim(false)) .write_bytes(&pkt_set_enable_powersave_anim(false))
.ok(); .ok();
let action = lock.cache.boot.clone();
CtrlAnime::run_thread(self.0.clone(), action, true).await;
} }
let action = lock.cache.boot.clone();
CtrlAnime::run_thread(self.0.clone(), action, true).await;
} }
Ok(()) Ok(())
} }

30
asusd/src/ctrl_aura/trait_impls.rs
View File

@@ -241,39 +241,29 @@ impl CtrlTask for CtrlKbdLedZbus {
}; };
let inner1 = self.0.clone(); let inner1 = self.0.clone();
let inner2 = self.0.clone();
let inner3 = self.0.clone(); let inner3 = self.0.clone();
let inner4 = self.0.clone();
self.create_sys_event_tasks( self.create_sys_event_tasks(
// Loop so that we do aquire the lock but also don't block other move |sleeping| {
// threads (prevents potential deadlocks)
move || {
let inner1 = inner1.clone(); let inner1 = inner1.clone();
async move { async move {
let lock = inner1.lock().await; let lock = inner1.lock().await;
load_save(true, lock); load_save(sleeping, lock);
} }
}, },
move || { move |_shutting_down| {
let inner2 = inner2.clone();
async move {
let lock = inner2.lock().await;
load_save(false, lock);
}
},
move || {
let inner3 = inner3.clone(); let inner3 = inner3.clone();
async move { async move {
let lock = inner3.lock().await; let lock = inner3.lock().await;
load_save(false, lock); load_save(false, lock);
} }
}, },
move || { move |_lid_closed| {
let inner4 = inner4.clone(); // on lid change
async move { async move {}
let lock = inner4.lock().await; },
load_save(false, lock); move |_power_plugged| {
} // power change
async move {}
}, },
) )
.await; .await;

18
asusd/src/ctrl_platform.rs
View File

@@ -360,13 +360,12 @@ impl CtrlTask for CtrlPlatform {
let platform1 = self.clone(); let platform1 = self.clone();
let platform2 = self.clone(); let platform2 = self.clone();
self.create_sys_event_tasks( self.create_sys_event_tasks(
move || async { {} }, move |sleeping| {
move || {
let platform1 = platform1.clone(); let platform1 = platform1.clone();
async move { async move {
info!("CtrlRogBios reloading panel_od"); info!("CtrlRogBios reloading panel_od");
let lock = platform1.config.lock().await; let lock = platform1.config.lock().await;
if platform1.platform.has_panel_od() { if !sleeping && platform1.platform.has_panel_od() {
platform1 platform1
.set_panel_overdrive(lock.panel_od) .set_panel_overdrive(lock.panel_od)
.map_err(|err| { .map_err(|err| {
@@ -377,13 +376,12 @@ impl CtrlTask for CtrlPlatform {
} }
} }
}, },
move || async { {} }, move |shutting_down| {
move || {
let platform2 = platform2.clone(); let platform2 = platform2.clone();
async move { async move {
info!("CtrlRogBios reloading panel_od"); info!("CtrlRogBios reloading panel_od");
let lock = platform2.config.lock().await; let lock = platform2.config.lock().await;
if platform2.platform.has_panel_od() { if !shutting_down && platform2.platform.has_panel_od() {
platform2 platform2
.set_panel_overdrive(lock.panel_od) .set_panel_overdrive(lock.panel_od)
.map_err(|err| { .map_err(|err| {
@@ -394,6 +392,14 @@ impl CtrlTask for CtrlPlatform {
} }
} }
}, },
move |_lid_closed| {
// on lid change
async move {}
},
move |_power_plugged| {
// power change
async move {}
},
) )
.await; .await;

66
asusd/src/ctrl_power.rs
View File

@@ -163,50 +163,60 @@ impl CtrlTask for CtrlPower {
let power1 = self.clone(); let power1 = self.clone();
let power2 = self.clone(); let power2 = self.clone();
self.create_sys_event_tasks( self.create_sys_event_tasks(
move || async {}, move |sleeping| {
move || {
let power = power1.clone(); let power = power1.clone();
let sysd = sysd1.clone(); let sysd = sysd1.clone();
async move { async move {
info!("CtrlCharge reloading charge limit"); if !sleeping {
let lock = power.config.lock().await; info!("CtrlCharge reloading charge limit");
power let lock = power.config.lock().await;
.set(lock.bat_charge_limit) power
.map_err(|err| { .set(lock.bat_charge_limit)
warn!("CtrlCharge: set_limit {}", err); .map_err(|err| {
err warn!("CtrlCharge: set_limit {}", err);
}) err
.ok(); })
.ok();
if lock.disable_nvidia_powerd_on_battery { if lock.disable_nvidia_powerd_on_battery {
if let Ok(value) = power.power.get_online() { if let Ok(value) = power.power.get_online() {
do_nvidia_powerd_action(&sysd, value == 1).await; do_nvidia_powerd_action(&sysd, value == 1).await;
}
} }
} }
} }
}, },
move || async {}, move |shutting_down| {
move || {
let power = power2.clone(); let power = power2.clone();
let sysd = sysd2.clone(); let sysd = sysd2.clone();
async move { async move {
info!("CtrlCharge reloading charge limit"); if !shutting_down {
let lock = power.config.lock().await; info!("CtrlCharge reloading charge limit");
power let lock = power.config.lock().await;
.set(lock.bat_charge_limit) power
.map_err(|err| { .set(lock.bat_charge_limit)
warn!("CtrlCharge: set_limit {}", err); .map_err(|err| {
err warn!("CtrlCharge: set_limit {}", err);
}) err
.ok(); })
.ok();
if lock.disable_nvidia_powerd_on_battery { if lock.disable_nvidia_powerd_on_battery {
if let Ok(value) = power.power.get_online() { if let Ok(value) = power.power.get_online() {
do_nvidia_powerd_action(&sysd, value == 1).await; do_nvidia_powerd_action(&sysd, value == 1).await;
}
} }
} }
} }
}, },
move |_lid_closed| {
// on lid change
async move {}
},
move |_power_plugged| {
// power change
async move {}
},
) )
.await; .await;

73
asusd/src/lib.rs
View File

@@ -18,14 +18,16 @@ pub mod ctrl_supported;
pub mod error; pub mod error;
use std::future::Future; use std::future::Future;
use std::time::Duration;
use async_trait::async_trait; use async_trait::async_trait;
use dmi_id::DMIID; use dmi_id::DMIID;
use futures_lite::stream::StreamExt;
use log::{debug, info, warn}; use log::{debug, info, warn};
use logind_zbus::manager::ManagerProxy; use logind_zbus::manager::ManagerProxy;
use zbus::export::futures_util::StreamExt; use tokio::time::sleep;
use zbus::zvariant::ObjectPath; use zbus::zvariant::ObjectPath;
use zbus::{Connection, SignalContext}; use zbus::{CacheProperties, Connection, SignalContext};
use crate::error::RogError; use crate::error::RogError;
@@ -161,15 +163,15 @@ pub trait CtrlTask {
F4: Send + 'static, F4: Send + 'static,
>( >(
&self, &self,
mut on_sleep: F1, mut on_prepare_for_sleep: F1,
mut on_wake: F2, mut on_prepare_for_shutdown: F2,
mut on_shutdown: F3, mut on_lid_change: F3,
mut on_boot: F4, mut on_external_power_change: F4,
) where ) where
F1: FnMut() -> Fut1, F1: FnMut(bool) -> Fut1,
F2: FnMut() -> Fut2, F2: FnMut(bool) -> Fut2,
F3: FnMut() -> Fut3, F3: FnMut(bool) -> Fut3,
F4: FnMut() -> Fut4, F4: FnMut(bool) -> Fut4,
Fut1: Future<Output = ()> + Send, Fut1: Future<Output = ()> + Send,
Fut2: Future<Output = ()> + Send, Fut2: Future<Output = ()> + Send,
Fut3: Future<Output = ()> + Send, Fut3: Future<Output = ()> + Send,
@@ -179,7 +181,9 @@ pub trait CtrlTask {
.await .await
.expect("Controller could not create dbus connection"); .expect("Controller could not create dbus connection");
let manager = ManagerProxy::new(&connection) let manager = ManagerProxy::builder(&connection)
.cache_properties(CacheProperties::No)
.build()
.await .await
.expect("Controller could not create ManagerProxy"); .expect("Controller could not create ManagerProxy");
@@ -187,35 +191,46 @@ pub trait CtrlTask {
if let Ok(mut notif) = manager.receive_prepare_for_sleep().await { if let Ok(mut notif) = manager.receive_prepare_for_sleep().await {
while let Some(event) = notif.next().await { while let Some(event) = notif.next().await {
if let Ok(args) = event.args() { if let Ok(args) = event.args() {
if args.start { debug!("Doing on_prepare_for_sleep({})", args.start);
debug!("Doing on_sleep()"); on_prepare_for_sleep(args.start).await;
on_sleep().await; }
} else if !args.start() { }
debug!("Doing on_wake()"); }
on_wake().await;
} if let Ok(mut notif) = manager.receive_prepare_for_shutdown().await {
while let Some(event) = notif.next().await {
if let Ok(args) = event.args() {
debug!("Doing on_prepare_for_shutdown({})", args.start);
on_prepare_for_shutdown(args.start).await;
} }
} }
} }
}); });
let manager = ManagerProxy::new(&connection) let manager = ManagerProxy::builder(&connection)
.cache_properties(CacheProperties::No)
.build()
.await .await
.expect("Controller could not create ManagerProxy"); .expect("Controller could not create ManagerProxy");
tokio::spawn(async move { tokio::spawn(async move {
if let Ok(mut notif) = manager.receive_prepare_for_shutdown().await { let mut last_power = manager.on_external_power().await.unwrap_or_default();
while let Some(event) = notif.next().await { let mut last_lid = manager.lid_closed().await.unwrap_or_default();
if let Ok(args) = event.args() { // need to loop on these as they don't emit signals
if args.start { loop {
debug!("Doing on_shutdown()"); if let Ok(next) = manager.on_external_power().await {
on_shutdown().await; if next != last_power {
} else if !args.start() { last_power = next;
debug!("Doing on_boot()"); on_external_power_change(next).await;
on_boot().await;
}
} }
} }
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;
} }
}); });
} }

2
rog-anime/src/data.rs
View File

@@ -48,6 +48,8 @@ pub struct DeviceState {
pub display_brightness: Brightness, pub display_brightness: Brightness,
pub builtin_anims_enabled: bool, pub builtin_anims_enabled: bool,
pub builtin_anims: Animations, pub builtin_anims: Animations,
pub off_when_unplugged: bool,
pub off_when_suspended: bool,
} }
#[typeshare] #[typeshare]

3
rog-dbus/src/zbus_anime.rs
View File

@@ -7,9 +7,6 @@ use zbus::dbus_proxy;
default_path = "/org/asuslinux/Anime" default_path = "/org/asuslinux/Anime"
)] )]
trait Anime { trait Anime {
/// Set the global (image) brightness
fn set_image_brightness(&self, bright: f32) -> zbus::Result<()>;
/// Set the global base brightness /// Set the global base brightness
fn set_brightness(&self, bright: Brightness) -> zbus::Result<()>; fn set_brightness(&self, bright: Brightness) -> zbus::Result<()>;