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

Finalise zbus3 conversion

Browse Source
This commit is contained in:
Luke D. Jones
2022-01-16 22:28:53 +13:00
parent bac2ba6f09
commit a85e2f6130
33 changed files with 1093 additions and 1077 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
daemon/src/ctrl_aura/controller.rs
View File

@@ -6,6 +6,7 @@ use crate::{
laptops::{LaptopLedData, ASUS_KEYBOARD_DEVICES},
CtrlTask,
};
use async_trait::async_trait;
use log::{info, warn};
use logind_zbus::ManagerProxy;
use rog_aura::{
@@ -16,12 +17,12 @@ use rog_aura::{
AuraEffect, LedBrightness, LED_MSG_LEN,
};
use rog_supported::LedSupportedFunctions;
use std::fs::OpenOptions;
use std::io::{Read, Write};
use std::path::Path;
use std::sync::Arc;
use std::sync::Mutex;
use std::{fs::OpenOptions, thread::spawn};
use zbus::Connection;
use zbus::blocking::Connection;
use crate::GetSupported;
@@ -57,46 +58,46 @@ pub struct CtrlKbdLed {
pub struct CtrlKbdLedTask<'a> {
inner: Arc<Mutex<CtrlKbdLed>>,
_c: Connection,
manager: ManagerProxy<'a>,
_manager: ManagerProxy<'a>,
}
impl<'a> CtrlKbdLedTask<'a> {
pub fn new(inner: Arc<Mutex<CtrlKbdLed>>) -> Self {
let connection =
Connection::new_system().expect("CtrlKbdLedTask could not create dbus connection");
Connection::system().expect("CtrlKbdLedTask could not create dbus connection");
let manager =
ManagerProxy::new(&connection).expect("CtrlKbdLedTask could not create ManagerProxy");
let c1 = inner.clone();
// Run this action when the system wakes up from sleep
manager
.connect_prepare_for_sleep(move |sleep| {
if !sleep {
let c1 = c1.clone();
spawn(move || {
// wait a fraction for things to wake up properly
//std::thread::sleep(Duration::from_millis(100));
loop {
if let Ok(ref mut lock) = c1.try_lock() {
lock.set_brightness(lock.config.brightness).ok();
break;
}
}
});
}
Ok(())
})
.map_err(|err| {
warn!("CtrlAnimeTask: new() {}", err);
err
})
.ok();
// let c1 = inner.clone();
// // Run this action when the system wakes up from sleep
// manager
// .connect_prepare_for_sleep(move |sleep| {
// if !sleep {
// let c1 = c1.clone();
// spawn(move || {
// // wait a fraction for things to wake up properly
// //std::thread::sleep(Duration::from_millis(100));
// loop {
// if let Ok(ref mut lock) = c1.try_lock() {
// lock.set_brightness(lock.config.brightness).ok();
// break;
// }
// }
// });
// }
// Ok(())
// })
// .map_err(|err| {
// warn!("CtrlAnimeTask: new() {}", err);
// err
// })
// .ok();
Self {
inner,
_c: connection,
manager,
_manager: manager,
}
}
@@ -125,9 +126,11 @@ impl<'a> CtrlKbdLedTask<'a> {
}
}
#[async_trait]
impl<'a> CtrlTask for CtrlKbdLedTask<'a> {
fn do_task(&self) -> Result<(), RogError> {
self.manager.next_signal()?;
async fn do_task(&self) -> Result<(), RogError> {
self._manager.receive_prepare_for_sleep()?.next();
if let Ok(ref mut lock) = self.inner.try_lock() {
return Self::update_config(lock);
}

122
daemon/src/ctrl_aura/zbus.rs
View File

@@ -1,14 +1,18 @@
use async_trait::async_trait;
use log::{error, warn};
use rog_aura::{AuraEffect, LedBrightness, LedPowerStates};
use zbus::dbus_interface;
use zbus::{dbus_interface, Connection, SignalContext};
use zvariant::ObjectPath;
use super::controller::CtrlKbdLedZbus;
#[async_trait]
impl crate::ZbusAdd for CtrlKbdLedZbus {
fn add_to_server(self, server: &mut zbus::ObjectServer) {
async fn add_to_server(self, server: &mut Connection) {
server
.object_server()
.at(&ObjectPath::from_str_unchecked("/org/asuslinux/Led"), self)
.await
.map_err(|err| {
error!("DbusKbdLed: add_to_server {}", err);
})
@@ -22,7 +26,7 @@ impl crate::ZbusAdd for CtrlKbdLedZbus {
#[dbus_interface(name = "org.asuslinux.Daemon")]
impl CtrlKbdLedZbus {
/// Set the keyboard brightness level (0-3)
fn set_brightness(&mut self, brightness: LedBrightness) {
async fn set_brightness(&mut self, brightness: LedBrightness) {
if let Ok(ctrl) = self.0.try_lock() {
ctrl.set_brightness(brightness)
.map_err(|err| warn!("{}", err))
@@ -31,7 +35,12 @@ impl CtrlKbdLedZbus {
}
/// Set the keyboard LED to enabled while the device is awake
fn set_awake_enabled(&mut self, enabled: bool) {
async fn set_awake_enabled(
&mut self,
#[zbus(signal_context)] ctxt: SignalContext<'_>,
enabled: bool,
) {
let mut states = None;
if let Ok(mut ctrl) = self.0.try_lock() {
ctrl.set_states_enabled(enabled, ctrl.config.sleep_anim_enabled)
.map_err(|err| warn!("{}", err))
@@ -39,52 +48,77 @@ impl CtrlKbdLedZbus {
ctrl.config.awake_enabled = enabled;
ctrl.config.write();
let states = LedPowerStates {
states = Some(LedPowerStates {
enabled: ctrl.config.awake_enabled,
sleep_anim_enabled: ctrl.config.sleep_anim_enabled,
};
self.notify_power_states(&states)
});
}
// Need to pull state out like this due to MutexGuard
if let Some(states) = states {
Self::notify_power_states(&ctxt, &states)
.await
.unwrap_or_else(|err| warn!("{}", err));
}
}
/// Set the keyboard LED suspend animation to enabled while the device is suspended
fn set_sleep_enabled(&mut self, enabled: bool) {
async fn set_sleep_enabled(
&mut self,
#[zbus(signal_context)] ctxt: SignalContext<'_>,
enabled: bool,
) {
let mut states = None;
if let Ok(mut ctrl) = self.0.try_lock() {
ctrl.set_states_enabled(ctrl.config.awake_enabled, enabled)
.map_err(|err| warn!("{}", err))
.ok();
ctrl.config.sleep_anim_enabled = enabled;
ctrl.config.write();
let states = LedPowerStates {
states = Some(LedPowerStates {
enabled: ctrl.config.awake_enabled,
sleep_anim_enabled: ctrl.config.sleep_anim_enabled,
};
self.notify_power_states(&states)
});
}
if let Some(states) = states {
Self::notify_power_states(&ctxt, &states)
.await
.unwrap_or_else(|err| warn!("{}", err));
}
}
/// Set the keyboard side LEDs to enabled
fn set_side_leds_enabled(&mut self, enabled: bool) {
async fn set_side_leds_enabled(
&mut self,
#[zbus(signal_context)] ctxt: SignalContext<'_>,
enabled: bool,
) {
let mut led = None;
if let Ok(mut ctrl) = self.0.try_lock() {
ctrl.set_side_leds_states(enabled)
.map_err(|err| warn!("{}", err))
.ok();
ctrl.config.side_leds_enabled = enabled;
ctrl.config.write();
self.notify_side_leds(ctrl.config.side_leds_enabled)
.unwrap_or_else(|err| warn!("{}", err))
led = Some(enabled);
}
if let Some(led) = led {
Self::notify_side_leds(&ctxt, led)
.await
.unwrap_or_else(|err| warn!("{}", err));
}
}
fn set_led_mode(&mut self, effect: AuraEffect) {
async fn set_led_mode(
&mut self,
#[zbus(signal_context)] ctxt: SignalContext<'_>,
effect: AuraEffect,
) {
let mut led = None;
if let Ok(mut ctrl) = self.0.try_lock() {
match ctrl.do_command(effect) {
Ok(_) => {
if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
self.notify_led(mode.clone())
.unwrap_or_else(|err| warn!("{}", err));
led = Some(mode.clone());
}
}
Err(err) => {
@@ -92,40 +126,55 @@ impl CtrlKbdLedZbus {
}
}
}
if let Some(led) = led {
Self::notify_led(&ctxt, led)
.await
.unwrap_or_else(|err| warn!("{}", err));
}
}
fn next_led_mode(&self) {
if let Ok(mut ctrl) = self.0.try_lock() {
async fn next_led_mode(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>) {
let mut led = None;
if let Ok(mut ctrl) = self.0.lock() {
ctrl.toggle_mode(false)
.unwrap_or_else(|err| warn!("{}", err));
if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
self.notify_led(mode.clone())
.unwrap_or_else(|err| warn!("{}", err));
led = Some(mode.clone());
}
}
if let Some(led) = led {
Self::notify_led(&ctxt, led)
.await
.unwrap_or_else(|err| warn!("{}", err));
}
}
fn prev_led_mode(&self) {
if let Ok(mut ctrl) = self.0.try_lock() {
async fn prev_led_mode(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>) {
let mut led = None;
if let Ok(mut ctrl) = self.0.lock() {
ctrl.toggle_mode(true)
.unwrap_or_else(|err| warn!("{}", err));
if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
self.notify_led(mode.clone())
.unwrap_or_else(|err| warn!("{}", err));
led = Some(mode.clone());
}
}
if let Some(led) = led {
Self::notify_led(&ctxt, led)
.await
.unwrap_or_else(|err| warn!("{}", err));
}
}
fn next_led_brightness(&self) {
async fn next_led_brightness(&self) {
if let Ok(mut ctrl) = self.0.try_lock() {
ctrl.next_brightness()
.unwrap_or_else(|err| warn!("{}", err));
}
}
fn prev_led_brightness(&self) {
async fn prev_led_brightness(&self) {
if let Ok(mut ctrl) = self.0.try_lock() {
ctrl.prev_brightness()
.unwrap_or_else(|err| warn!("{}", err));
@@ -133,7 +182,7 @@ impl CtrlKbdLedZbus {
}
#[dbus_interface(property)]
fn awake_enabled(&self) -> bool {
async fn awake_enabled(&self) -> bool {
if let Ok(ctrl) = self.0.try_lock() {
return ctrl.config.awake_enabled;
}
@@ -141,7 +190,7 @@ impl CtrlKbdLedZbus {
}
#[dbus_interface(property)]
fn sleep_enabled(&self) -> bool {
async fn sleep_enabled(&self) -> bool {
if let Ok(ctrl) = self.0.try_lock() {
return ctrl.config.sleep_anim_enabled;
}
@@ -158,7 +207,7 @@ impl CtrlKbdLedZbus {
/// Return the current mode data
#[dbus_interface(property)]
fn led_mode(&self) -> String {
async fn led_mode(&self) -> String {
if let Ok(ctrl) = self.0.try_lock() {
if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
if let Ok(json) = serde_json::to_string(&mode) {
@@ -172,7 +221,7 @@ impl CtrlKbdLedZbus {
/// Return a list of available modes
#[dbus_interface(property)]
fn led_modes(&self) -> String {
async fn led_modes(&self) -> String {
if let Ok(ctrl) = self.0.try_lock() {
if let Ok(json) = serde_json::to_string(&ctrl.config.builtins) {
return json;
@@ -184,7 +233,7 @@ impl CtrlKbdLedZbus {
/// Return the current LED brightness
#[dbus_interface(property)]
fn led_brightness(&self) -> i8 {
async fn led_brightness(&self) -> i8 {
if let Ok(ctrl) = self.0.try_lock() {
return ctrl.get_brightness().map(|n| n as i8).unwrap_or(-1);
}
@@ -193,11 +242,14 @@ impl CtrlKbdLedZbus {
}
#[dbus_interface(signal)]
fn notify_led(&self, data: AuraEffect) -> zbus::Result<()>;
async fn notify_led(signal_ctxt: &SignalContext<'_>, data: AuraEffect) -> zbus::Result<()>;
#[dbus_interface(signal)]
fn notify_side_leds(&self, data: bool) -> zbus::Result<()>;
async fn notify_side_leds(signal_ctxt: &SignalContext<'_>, data: bool) -> zbus::Result<()>;
#[dbus_interface(signal)]
fn notify_power_states(&self, data: &LedPowerStates) -> zbus::Result<()>;
async fn notify_power_states(
signal_ctxt: &SignalContext<'_>,
data: &LedPowerStates,
) -> zbus::Result<()>;
}