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

5
daemon/src/config.rs
View File

@@ -2,6 +2,7 @@ use log::{error, warn};
use serde_derive::{Deserialize, Serialize};
use std::fs::{File, OpenOptions};
use std::io::{Read, Write};
use std::path::PathBuf;
pub static CONFIG_PATH: &str = "/etc/asusd/asusd.conf";
@@ -24,8 +25,8 @@ impl Config {
.read(true)
.write(true)
.create(true)
.open(&CONFIG_PATH)
.unwrap_or_else(|_| panic!("The directory /etc/asusd/ is missing")); // okay to cause panic here
.open(&PathBuf::from(CONFIG_PATH))
.unwrap_or_else(|e| panic!("Error opening {}, {}", CONFIG_PATH, e)); // okay to cause panic here
let mut buf = String::new();
let config;
if let Ok(read_len) = file.read_to_string(&mut buf) {

73
daemon/src/ctrl_anime/mod.rs
View File

@@ -1,7 +1,8 @@
pub mod config;
pub mod zbus;
use ::zbus::Connection;
use ::zbus::blocking::Connection;
use async_trait::async_trait;
use log::{error, info, warn};
use logind_zbus::ManagerProxy;
use rog_anime::{
@@ -298,7 +299,7 @@ impl CtrlAnime {
}
pub struct CtrlAnimeTask<'a> {
inner: Arc<Mutex<CtrlAnime>>,
_inner: Arc<Mutex<CtrlAnime>>,
_c: Connection,
manager: ManagerProxy<'a>,
}
@@ -306,80 +307,24 @@ pub struct CtrlAnimeTask<'a> {
impl<'a> CtrlAnimeTask<'a> {
pub fn new(inner: Arc<Mutex<CtrlAnime>>) -> Self {
let connection =
Connection::new_system().expect("CtrlAnimeTask could not create dbus connection");
Connection::system().expect("CtrlAnimeTask could not create dbus connection");
let manager =
ManagerProxy::new(&connection).expect("CtrlAnimeTask could not create ManagerProxy");
let c1 = inner.clone();
// Run this action when the system starts shutting down
manager
.connect_prepare_for_shutdown(move |shutdown| {
if shutdown {
'outer: loop {
if let Ok(lock) = c1.try_lock() {
lock.thread_exit.store(true, Ordering::SeqCst);
CtrlAnime::run_thread(c1.clone(), lock.cache.shutdown.clone(), false);
break 'outer;
}
}
}
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 {
// wait a fraction for things to wake up properly
std::thread::sleep(Duration::from_millis(100));
'outer: loop {
if let Ok(lock) = c1.try_lock() {
lock.thread_exit.store(true, Ordering::SeqCst);
CtrlAnime::run_thread(c1.clone(), lock.cache.wake.clone(), true);
break 'outer;
}
}
}
Ok(())
})
.map_err(|err| {
warn!("CtrlAnimeTask: new() {}", err);
err
})
.ok();
Self {
inner,
_inner: inner,
_c: connection,
manager,
}
}
}
#[async_trait]
impl<'a> crate::CtrlTask for CtrlAnimeTask<'a> {
fn do_task(&self) -> Result<(), RogError> {
if let Ok(mut lock) = self.inner.try_lock() {
// Refresh the config and cache incase the user has edited it
let config = AnimeConfig::load();
lock.cache
.init_from_config(&config)
.map_err(|err| {
warn!("CtrlAnimeTask: do_task {}", err);
err
})
.ok();
}
// Check for signals on each task iteration, this will run the callbacks
// if any signal is recieved
self.manager.next_signal()?;
async fn do_task(&self) -> Result<(), RogError> {
self.manager.receive_prepare_for_shutdown()?.next();
self.manager.receive_prepare_for_sleep()?.next();
Ok(())
}
}

33
daemon/src/ctrl_anime/zbus.rs
View File

@@ -1,11 +1,12 @@
use std::sync::{Arc, Mutex};
use async_trait::async_trait;
use log::warn;
use rog_anime::{
usb::{pkt_for_apply, pkt_for_set_boot, pkt_for_set_on},
AnimeDataBuffer, AnimePowerStates,
};
use zbus::dbus_interface;
use zbus::{dbus_interface, Connection, SignalContext};
use zvariant::ObjectPath;
use std::sync::atomic::Ordering;
@@ -15,13 +16,16 @@ use super::CtrlAnime;
pub struct CtrlAnimeZbus(pub Arc<Mutex<CtrlAnime>>);
/// The struct with the main dbus methods requires this trait
#[async_trait]
impl crate::ZbusAdd for CtrlAnimeZbus {
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/Anime"),
self,
)
.await
.map_err(|err| {
warn!("CtrlAnimeDisplay: add_to_server {}", err);
err
@@ -71,12 +75,10 @@ impl CtrlAnimeZbus {
lock.config.awake_enabled = status;
lock.config.write();
let states = AnimePowerStates {
enabled: lock.config.awake_enabled,
boot_anim_enabled: lock.config.boot_anim_enabled,
};
self.notify_power_states(&states)
.unwrap_or_else(|err| warn!("{}", err));
// let states = AnimePowerStates {
// enabled: lock.config.awake_enabled,
// boot_anim_enabled: lock.config.boot_anim_enabled,
// };
break 'outer;
}
}
@@ -91,12 +93,10 @@ impl CtrlAnimeZbus {
lock.config.boot_anim_enabled = on;
lock.config.write();
let states = AnimePowerStates {
enabled: lock.config.awake_enabled,
boot_anim_enabled: lock.config.boot_anim_enabled,
};
self.notify_power_states(&states)
.unwrap_or_else(|err| warn!("{}", err));
// let states = AnimePowerStates {
// enabled: lock.config.awake_enabled,
// boot_anim_enabled: lock.config.boot_anim_enabled,
// };
break 'outer;
}
}
@@ -136,5 +136,8 @@ impl CtrlAnimeZbus {
/// Notify listeners of the status of AniMe LED power and factory system-status animations
#[dbus_interface(signal)]
fn notify_power_states(&self, data: &AnimePowerStates) -> zbus::Result<()>;
async fn notify_power_states(
ctxt: &SignalContext<'_>,
data: AnimePowerStates,
) -> zbus::Result<()>;
}

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<()>;
}

28
daemon/src/ctrl_charge.rs
View File

@@ -1,5 +1,5 @@
use crate::{config::Config, error::RogError, GetSupported};
//use crate::dbus::DbusEvents;
use async_trait::async_trait;
use log::{info, warn};
use rog_supported::ChargeSupportedFunctions;
use std::fs::OpenOptions;
@@ -8,6 +8,8 @@ use std::path::Path;
use std::sync::Arc;
use std::sync::Mutex;
use zbus::dbus_interface;
use zbus::Connection;
use zbus::SignalContext;
use zvariant::ObjectPath;
static BAT_CHARGE_PATH0: &str = "/sys/class/power_supply/BAT0/charge_control_end_threshold";
@@ -30,9 +32,13 @@ pub struct CtrlCharge {
#[dbus_interface(name = "org.asuslinux.Daemon")]
impl CtrlCharge {
pub fn set_limit(&mut self, limit: u8) -> Result<(), RogError> {
async fn set_limit(
&mut self,
#[zbus(signal_context)] ctxt: SignalContext<'_>,
limit: u8,
) -> zbus::fdo::Result<()> {
if !(20..=100).contains(&limit) {
return Err(RogError::ChargeLimit(limit));
return Err(RogError::ChargeLimit(limit))?;
}
if let Ok(mut config) = self.config.try_lock() {
self.set(limit, &mut config)
@@ -41,17 +47,12 @@ impl CtrlCharge {
err
})
.ok();
self.notify_charge(limit)
.map_err(|err| {
warn!("CtrlCharge: set_limit {}", err);
err
})
.ok();
}
Self::notify_charge(&ctxt, limit).await?;
Ok(())
}
pub fn limit(&self) -> i8 {
fn limit(&self) -> i8 {
if let Ok(config) = self.config.try_lock() {
return config.bat_charge_limit as i8;
}
@@ -59,16 +60,19 @@ impl CtrlCharge {
}
#[dbus_interface(signal)]
pub fn notify_charge(&self, limit: u8) -> zbus::Result<()> {}
async fn notify_charge(ctxt: &SignalContext<'_>, limit: u8) -> zbus::Result<()>;
}
#[async_trait]
impl crate::ZbusAdd for CtrlCharge {
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/Charge"),
self,
)
.await
.map_err(|err| {
warn!("CtrlCharge: add_to_server {}", err);
err

4
daemon/src/ctrl_profiles/controller.rs
View File

@@ -2,6 +2,7 @@ use std::sync::{Arc, Mutex};
use crate::error::RogError;
use crate::{CtrlTask, GetSupported};
use async_trait::async_trait;
use log::{info, warn};
use rog_profiles::error::ProfileError;
use rog_profiles::{FanCurveProfiles, Profile};
@@ -135,8 +136,9 @@ impl CtrlProfileTask {
}
}
#[async_trait]
impl CtrlTask for CtrlProfileTask {
fn do_task(&self) -> Result<(), RogError> {
async fn do_task(&self) -> Result<(), RogError> {
if let Ok(ref mut lock) = self.ctrl.try_lock() {
let new_profile = Profile::get_active_profile().unwrap();
if new_profile != lock.config.active_profile {

38
daemon/src/ctrl_profiles/zbus.rs
View File

@@ -1,13 +1,19 @@
use async_trait::async_trait;
use log::warn;
use rog_profiles::fan_curve_set::CurveData;
use rog_profiles::fan_curve_set::FanCurveSet;
use rog_profiles::Profile;
use zbus::Connection;
use zbus::SignalContext;
use std::sync::Arc;
use std::sync::Mutex;
use zbus::{dbus_interface, fdo::Error};
use zvariant::ObjectPath;
use crate::error::RogError;
use crate::CtrlTask;
use super::controller::CtrlPlatformProfile;
static UNSUPPORTED_MSG: &str =
@@ -161,25 +167,32 @@ impl ProfileZbus {
}
#[dbus_interface(signal)]
fn notify_profile(&self, profile: &Profile) -> zbus::Result<()> {}
async fn notify_profile(
signal_ctxt: &SignalContext<'_>,
profile: &Profile,
) -> zbus::Result<()> {
}
}
impl ProfileZbus {
fn do_notification(&self) {
if let Ok(ctrl) = self.inner.try_lock() {
self.notify_profile(&ctrl.config.active_profile)
.unwrap_or_else(|err| warn!("{}", err));
if let Ok(_ctrl) = self.inner.try_lock() {
// self.notify_profile(&ctrl.config.active_profile)
// .unwrap_or_else(|err| warn!("{}", err));
}
}
}
#[async_trait]
impl crate::ZbusAdd for ProfileZbus {
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/Profile"),
self,
)
.await
.map_err(|err| {
warn!("DbusFanAndCpu: add_to_server {}", err);
err
@@ -187,3 +200,18 @@ impl crate::ZbusAdd for ProfileZbus {
.ok();
}
}
#[async_trait]
impl CtrlTask for ProfileZbus {
async fn do_task(&self) -> Result<(), RogError> {
if let Ok(ref mut lock) = self.inner.try_lock() {
let new_profile = Profile::get_active_profile().unwrap();
if new_profile != lock.config.active_profile {
lock.config.active_profile = new_profile;
lock.write_profile_curve_to_platform()?;
lock.save_config();
}
}
Ok(())
}
}

47
daemon/src/ctrl_rog_bios.rs
View File

@@ -1,4 +1,5 @@
use crate::{config::Config, error::RogError, GetSupported};
use async_trait::async_trait;
use log::{error, info, warn};
use rog_supported::RogBiosSupportedFunctions;
use std::fs::OpenOptions;
@@ -8,7 +9,8 @@ use std::path::Path;
use std::process::Command;
use std::sync::Arc;
use std::sync::Mutex;
use zbus::dbus_interface;
use zbus::Connection;
use zbus::{dbus_interface, SignalContext};
use zvariant::ObjectPath;
const INITRAMFS_PATH: &str = "/usr/sbin/update-initramfs";
@@ -36,22 +38,23 @@ impl GetSupported for CtrlRogBios {
#[dbus_interface(name = "org.asuslinux.Daemon")]
impl CtrlRogBios {
pub fn set_dedicated_graphic_mode(&mut self, dedicated: bool) {
async fn set_dedicated_graphic_mode(
&mut self,
#[zbus(signal_context)] ctxt: SignalContext<'_>,
dedicated: bool,
) {
self.set_gfx_mode(dedicated)
.map_err(|err| {
warn!("CtrlRogBios: set_asus_switch_graphic_mode {}", err);
err
})
.ok();
self.notify_dedicated_graphic_mode(dedicated)
.map_err(|err| {
warn!("CtrlRogBios: notify_asus_switch_graphic_mode {}", err);
err
})
Self::notify_dedicated_graphic_mode(&ctxt, dedicated)
.await
.ok();
}
pub fn dedicated_graphic_mode(&self) -> i8 {
fn dedicated_graphic_mode(&self) -> i8 {
Self::get_gfx_mode()
.map_err(|err| {
warn!("CtrlRogBios: get_gfx_mode {}", err);
@@ -61,24 +64,27 @@ impl CtrlRogBios {
}
#[dbus_interface(signal)]
pub fn notify_dedicated_graphic_mode(&self, dedicated: bool) -> zbus::Result<()> {}
async fn notify_dedicated_graphic_mode(
signal_ctxt: &SignalContext<'_>,
dedicated: bool,
) -> zbus::Result<()> {
}
pub fn set_post_boot_sound(&mut self, on: bool) {
async fn set_post_boot_sound(
&mut self,
#[zbus(signal_context)] ctxt: SignalContext<'_>,
on: bool,
) {
Self::set_boot_sound(on)
.map_err(|err| {
warn!("CtrlRogBios: set_post_boot_sound {}", err);
err
})
.ok();
self.notify_post_boot_sound(on)
.map_err(|err| {
warn!("CtrlRogBios: notify_post_boot_sound {}", err);
err
})
.ok();
Self::notify_post_boot_sound(&ctxt, on).await.ok();
}
pub fn post_boot_sound(&self) -> i8 {
fn post_boot_sound(&self) -> i8 {
Self::get_boot_sound()
.map_err(|err| {
warn!("CtrlRogBios: get_boot_sound {}", err);
@@ -88,16 +94,19 @@ impl CtrlRogBios {
}
#[dbus_interface(signal)]
pub fn notify_post_boot_sound(&self, dedicated: bool) -> zbus::Result<()> {}
async fn notify_post_boot_sound(ctxt: &SignalContext<'_>, on: bool) -> zbus::Result<()> {}
}
#[async_trait]
impl crate::ZbusAdd for CtrlRogBios {
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/RogBios"),
self,
)
.await
.map_err(|err| {
warn!("CtrlRogBios: add_to_server {}", err);
err

9
daemon/src/ctrl_supported.rs
View File

@@ -1,8 +1,10 @@
use async_trait::async_trait;
use log::warn;
use serde_derive::{Deserialize, Serialize};
use zbus::dbus_interface;
use zbus::Connection;
use zvariant::ObjectPath;
use zvariant_derive::Type;
use zvariant::Type;
use crate::{
ctrl_anime::CtrlAnime, ctrl_aura::controller::CtrlKbdLed, ctrl_charge::CtrlCharge,
@@ -30,13 +32,16 @@ impl SupportedFunctions {
}
}
#[async_trait]
impl crate::ZbusAdd for SupportedFunctions {
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/Supported"),
self,
)
.await
.map_err(|err| {
warn!("SupportedFunctions: add_to_server {}", err);
err

74
daemon/src/daemon.rs
View File

@@ -1,12 +1,11 @@
use std::env;
use std::error::Error;
use std::io::Write;
use std::sync::Arc;
use std::sync::Mutex;
use std::thread::sleep;
use std::sync::{Arc, Mutex};
use std::time::Duration;
use std::{env, thread};
use ::zbus::{fdo, Connection, ObjectServer};
use ::zbus::Connection;
use futures::executor::ThreadPool;
use log::LevelFilter;
use log::{error, info, warn};
@@ -19,9 +18,7 @@ use daemon::ctrl_aura::controller::{
};
use daemon::ctrl_charge::CtrlCharge;
use daemon::ctrl_profiles::config::ProfileConfig;
use daemon::ctrl_profiles::controller::CtrlProfileTask;
use daemon::ctrl_rog_bios::CtrlRogBios;
use daemon::error::RogError;
use daemon::{
config::Config, ctrl_supported::SupportedFunctions, laptops::print_board_info, GetSupported,
};
@@ -64,25 +61,25 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
info!(" rog-profiles v{}", rog_profiles::VERSION);
info!("rog-supported v{}", rog_supported::VERSION);
start_daemon()?;
let mut pool = ThreadPool::new()?;
futures::executor::block_on(start_daemon(&mut pool))?;
Ok(())
}
/// The actual main loop for the daemon
fn start_daemon() -> Result<(), Box<dyn Error>> {
async fn start_daemon(thread_pool: &mut ThreadPool) -> Result<(), Box<dyn Error>> {
let supported = SupportedFunctions::get_supported();
print_board_info();
println!("{}", serde_json::to_string_pretty(&supported)?);
// Start zbus server
let connection = Connection::new_system()?;
let fdo_connection = fdo::DBusProxy::new(&connection)?;
let mut object_server = ObjectServer::new(&connection);
let mut connection = Connection::system().await?;
let config = Config::load();
let config = Arc::new(Mutex::new(config));
supported.add_to_server(&mut object_server);
supported.add_to_server(&mut connection).await;
match CtrlRogBios::new(config.clone()) {
Ok(mut ctrl) => {
@@ -90,7 +87,7 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
ctrl.reload()
.unwrap_or_else(|err| warn!("Battery charge limit: {}", err));
// Then register to dbus server
ctrl.add_to_server(&mut object_server);
ctrl.add_to_server(&mut connection).await;
}
Err(err) => {
error!("rog_bios_control: {}", err);
@@ -103,7 +100,7 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
ctrl.reload()
.unwrap_or_else(|err| warn!("Battery charge limit: {}", err));
// Then register to dbus server
ctrl.add_to_server(&mut object_server);
ctrl.add_to_server(&mut connection).await;
}
Err(err) => {
error!("charge_control: {}", err);
@@ -118,17 +115,9 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
.unwrap_or_else(|err| warn!("Profile control: {}", err));
let tmp = Arc::new(Mutex::new(ctrl));
ProfileZbus::new(tmp.clone()).add_to_server(&mut object_server);
let task = CtrlProfileTask::new(tmp);
thread::Builder::new().name("profile tasks".into()).spawn(
move || -> Result<(), RogError> {
loop {
task.do_task()?;
sleep(Duration::from_millis(100));
}
},
)?;
ProfileZbus::new(tmp.clone())
.add_to_server(&mut connection)
.await;
}
Err(err) => {
error!("Profile control: {}", err);
@@ -148,16 +137,12 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
.unwrap_or_else(|err| warn!("AniMe: {}", err));
let zbus = CtrlAnimeZbus(inner.clone());
zbus.add_to_server(&mut object_server);
zbus.add_to_server(&mut connection).await;
let task = CtrlAnimeTask::new(inner);
thread::Builder::new().name("anime tasks".into()).spawn(
move || -> Result<(), RogError> {
loop {
task.do_task()?;
}
},
)?;
thread_pool.spawn_ok(async move {
task.do_task().await.ok();
});
}
Err(err) => {
error!("AniMe control: {}", err);
@@ -175,16 +160,14 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
.reload()
.unwrap_or_else(|err| warn!("Keyboard LED control: {}", err));
CtrlKbdLedZbus::new(inner.clone()).add_to_server(&mut object_server);
CtrlKbdLedZbus::new(inner.clone())
.add_to_server(&mut connection)
.await;
let task = CtrlKbdLedTask::new(inner);
thread::Builder::new().name("keyboard tasks".into()).spawn(
move || -> Result<(), RogError> {
loop {
task.do_task()?;
}
},
)?;
thread_pool.spawn_ok(async move {
task.do_task().await.ok();
});
}
Err(err) => {
error!("Keyboard control: {}", err);
@@ -192,12 +175,11 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
}
// Request dbus name after finishing initalizing all functions
fdo_connection.request_name(DBUS_NAME, fdo::RequestNameFlags::ReplaceExisting.into())?;
connection.request_name(DBUS_NAME).await?;
// Loop to check errors and iterate zbus server
loop {
if let Err(err) = object_server.try_handle_next() {
error!("{}", err);
}
// Nothing to do here really
std::thread::sleep(Duration::from_millis(1));
}
}

9
daemon/src/lib.rs
View File

@@ -30,8 +30,9 @@ pub mod ctrl_supported;
pub mod error;
use crate::error::RogError;
use async_trait::async_trait;
use config::Config;
use zbus::ObjectServer;
use zbus::Connection;
pub static VERSION: &str = env!("CARGO_PKG_VERSION");
@@ -39,12 +40,14 @@ pub trait Reloadable {
fn reload(&mut self) -> Result<(), RogError>;
}
#[async_trait]
pub trait ZbusAdd {
fn add_to_server(self, server: &mut ObjectServer);
async fn add_to_server(self, server: &mut Connection);
}
#[async_trait]
pub trait CtrlTask {
fn do_task(&self) -> Result<(), RogError>;
async fn do_task(&self) -> Result<(), RogError>;
}
pub trait CtrlTaskComplex {