mirror of
https://gitlab.com/asus-linux/asusctl.git
synced 2026-01-22 17:33:19 +01:00
427 lines
14 KiB
Rust
427 lines
14 KiB
Rust
use crate::laptops::{LaptopLedData, ASUS_KEYBOARD_DEVICES};
|
|
use log::{error, warn};
|
|
use rog_aura::usb::{AuraDev1866, AuraDev19b6, AuraDevTuf, AuraDevice, AuraPowerDev};
|
|
use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Direction, LedBrightness, Speed, GRADIENT};
|
|
use rog_platform::hid_raw::HidRaw;
|
|
use rog_platform::keyboard_led::KeyboardLed;
|
|
use serde_derive::{Deserialize, Serialize};
|
|
use std::collections::{BTreeMap, HashSet};
|
|
use std::fs::{File, OpenOptions};
|
|
use std::io::{Read, Write};
|
|
|
|
pub static AURA_CONFIG_PATH: &str = "/etc/asusd/aura.conf";
|
|
|
|
/// Enable/disable LED control in various states such as
|
|
/// when the device is awake, suspended, shutting down or
|
|
/// booting.
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
pub enum AuraPowerConfig {
|
|
AuraDevTuf(HashSet<AuraDevTuf>),
|
|
AuraDev1866(HashSet<AuraDev1866>),
|
|
AuraDev19b6(HashSet<AuraDev19b6>),
|
|
}
|
|
|
|
impl AuraPowerConfig {
|
|
/// Invalid for TUF laptops
|
|
pub fn to_bytes(control: &Self) -> [u8; 3] {
|
|
match control {
|
|
AuraPowerConfig::AuraDevTuf(_) => [0, 0, 0],
|
|
AuraPowerConfig::AuraDev1866(c) => {
|
|
let c: Vec<AuraDev1866> = c.iter().copied().collect();
|
|
AuraDev1866::to_bytes(&c)
|
|
}
|
|
AuraPowerConfig::AuraDev19b6(c) => {
|
|
let c: Vec<AuraDev19b6> = c.iter().copied().collect();
|
|
AuraDev19b6::to_bytes(&c)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn to_tuf_bool_array(control: &Self) -> Option<[bool; 5]> {
|
|
if let Self::AuraDevTuf(c) = control {
|
|
return Some([
|
|
true,
|
|
c.contains(&AuraDevTuf::Boot),
|
|
c.contains(&AuraDevTuf::Awake),
|
|
c.contains(&AuraDevTuf::Sleep),
|
|
c.contains(&AuraDevTuf::Keyboard),
|
|
]);
|
|
}
|
|
|
|
if let Self::AuraDev1866(c) = control {
|
|
return Some([
|
|
true,
|
|
c.contains(&AuraDev1866::Boot),
|
|
c.contains(&AuraDev1866::Awake),
|
|
c.contains(&AuraDev1866::Sleep),
|
|
c.contains(&AuraDev1866::Keyboard),
|
|
]);
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
pub fn set_tuf(&mut self, power: AuraDevTuf, on: bool) {
|
|
if let Self::AuraDevTuf(p) = self {
|
|
if on {
|
|
p.insert(power);
|
|
} else {
|
|
p.remove(&power);
|
|
}
|
|
}
|
|
}
|
|
pub fn set_0x1866(&mut self, power: AuraDev1866, on: bool) {
|
|
if let Self::AuraDev1866(p) = self {
|
|
if on {
|
|
p.insert(power);
|
|
} else {
|
|
p.remove(&power);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn set_0x19b6(&mut self, power: AuraDev19b6, on: bool) {
|
|
if let Self::AuraDev19b6(p) = self {
|
|
if on {
|
|
p.insert(power);
|
|
} else {
|
|
p.remove(&power);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<&AuraPowerConfig> for AuraPowerDev {
|
|
fn from(config: &AuraPowerConfig) -> Self {
|
|
match config {
|
|
AuraPowerConfig::AuraDevTuf(d) => AuraPowerDev {
|
|
tuf: d.iter().copied().collect(),
|
|
x1866: vec![],
|
|
x19b6: vec![],
|
|
},
|
|
AuraPowerConfig::AuraDev1866(d) => AuraPowerDev {
|
|
tuf: vec![],
|
|
x1866: d.iter().copied().collect(),
|
|
x19b6: vec![],
|
|
},
|
|
AuraPowerConfig::AuraDev19b6(d) => AuraPowerDev {
|
|
tuf: vec![],
|
|
x1866: vec![],
|
|
x19b6: d.iter().copied().collect(),
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Deserialize, Serialize)]
|
|
// #[serde(default)]
|
|
pub struct AuraConfig {
|
|
pub brightness: LedBrightness,
|
|
pub current_mode: AuraModeNum,
|
|
pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
|
|
pub multizone: Option<BTreeMap<AuraModeNum, Vec<AuraEffect>>>,
|
|
pub multizone_on: bool,
|
|
pub enabled: AuraPowerConfig,
|
|
}
|
|
|
|
impl Default for AuraConfig {
|
|
fn default() -> Self {
|
|
let mut prod_id = AuraDevice::Unknown;
|
|
for prod in ASUS_KEYBOARD_DEVICES.iter() {
|
|
if HidRaw::new(prod).is_ok() {
|
|
prod_id = AuraDevice::from(*prod);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if prod_id == AuraDevice::Unknown {
|
|
if let Ok(p) = KeyboardLed::new() {
|
|
if p.has_kbd_rgb_mode() {
|
|
prod_id = AuraDevice::Tuf;
|
|
}
|
|
}
|
|
}
|
|
|
|
let enabled = if prod_id == AuraDevice::X19B6 {
|
|
AuraPowerConfig::AuraDev19b6(HashSet::from([
|
|
AuraDev19b6::BootLogo,
|
|
AuraDev19b6::BootKeyb,
|
|
AuraDev19b6::SleepLogo,
|
|
AuraDev19b6::SleepKeyb,
|
|
AuraDev19b6::AwakeLogo,
|
|
AuraDev19b6::AwakeKeyb,
|
|
AuraDev19b6::ShutdownLogo,
|
|
AuraDev19b6::ShutdownKeyb,
|
|
AuraDev19b6::BootBar,
|
|
AuraDev19b6::AwakeBar,
|
|
AuraDev19b6::SleepBar,
|
|
AuraDev19b6::ShutdownBar,
|
|
]))
|
|
} else if prod_id == AuraDevice::Tuf {
|
|
AuraPowerConfig::AuraDevTuf(HashSet::from([
|
|
AuraDevTuf::Awake,
|
|
AuraDevTuf::Boot,
|
|
AuraDevTuf::Sleep,
|
|
AuraDevTuf::Keyboard,
|
|
]))
|
|
} else {
|
|
AuraPowerConfig::AuraDev1866(HashSet::from([
|
|
AuraDev1866::Awake,
|
|
AuraDev1866::Boot,
|
|
AuraDev1866::Sleep,
|
|
AuraDev1866::Keyboard,
|
|
AuraDev1866::Lightbar,
|
|
]))
|
|
};
|
|
|
|
AuraConfig {
|
|
brightness: LedBrightness::Med,
|
|
current_mode: AuraModeNum::Static,
|
|
builtins: BTreeMap::new(),
|
|
multizone: None,
|
|
multizone_on: false,
|
|
enabled,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl AuraConfig {
|
|
/// `load` will attempt to read the config, and panic if the dir is missing
|
|
pub fn load(supported_led_modes: &LaptopLedData) -> Self {
|
|
let mut file = OpenOptions::new()
|
|
.read(true)
|
|
.write(true)
|
|
.create(true)
|
|
.open(&AURA_CONFIG_PATH)
|
|
.unwrap_or_else(|_| {
|
|
panic!(
|
|
"The file {} or directory /etc/asusd/ is missing",
|
|
AURA_CONFIG_PATH
|
|
)
|
|
}); // okay to cause panic here
|
|
let mut buf = String::new();
|
|
if let Ok(read_len) = file.read_to_string(&mut buf) {
|
|
if read_len == 0 {
|
|
return AuraConfig::create_default(&mut file, supported_led_modes);
|
|
} else {
|
|
if let Ok(data) = serde_json::from_str(&buf) {
|
|
return data;
|
|
}
|
|
warn!(
|
|
"Could not deserialise {}.\nWill rename to {}-old and recreate config",
|
|
AURA_CONFIG_PATH, AURA_CONFIG_PATH
|
|
);
|
|
let cfg_old = AURA_CONFIG_PATH.to_string() + "-old";
|
|
std::fs::rename(AURA_CONFIG_PATH, cfg_old).unwrap_or_else(|err| {
|
|
panic!(
|
|
"Could not rename. Please remove {} then restart service: Error {}",
|
|
AURA_CONFIG_PATH, err
|
|
)
|
|
});
|
|
}
|
|
}
|
|
AuraConfig::create_default(&mut file, supported_led_modes)
|
|
}
|
|
|
|
fn create_default(file: &mut File, support_data: &LaptopLedData) -> Self {
|
|
// create a default config here
|
|
let mut config = AuraConfig::default();
|
|
|
|
for n in &support_data.standard {
|
|
config
|
|
.builtins
|
|
.insert(*n, AuraEffect::default_with_mode(*n));
|
|
|
|
if !support_data.multizone.is_empty() {
|
|
let mut default = vec![];
|
|
for (i, tmp) in support_data.multizone.iter().enumerate() {
|
|
default.push(AuraEffect {
|
|
mode: *n,
|
|
zone: *tmp,
|
|
colour1: *GRADIENT.get(i).unwrap_or(&GRADIENT[0]),
|
|
colour2: *GRADIENT.get(GRADIENT.len() - i).unwrap_or(&GRADIENT[6]),
|
|
speed: Speed::Med,
|
|
direction: Direction::Left,
|
|
})
|
|
}
|
|
if let Some(m) = config.multizone.as_mut() {
|
|
m.insert(*n, default);
|
|
} else {
|
|
let mut tmp = BTreeMap::new();
|
|
tmp.insert(*n, default);
|
|
config.multizone = Some(tmp);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Should be okay to unwrap this as is since it is a Default
|
|
let json = serde_json::to_string(&config).unwrap();
|
|
file.write_all(json.as_bytes())
|
|
.unwrap_or_else(|_| panic!("Could not write {}", AURA_CONFIG_PATH));
|
|
config
|
|
}
|
|
|
|
pub fn read(&mut self) {
|
|
let mut file = OpenOptions::new()
|
|
.read(true)
|
|
.open(&AURA_CONFIG_PATH)
|
|
.unwrap_or_else(|err| panic!("Error reading {}: {}", AURA_CONFIG_PATH, err));
|
|
let mut buf = String::new();
|
|
if let Ok(l) = file.read_to_string(&mut buf) {
|
|
if l == 0 {
|
|
warn!("File is empty {}", AURA_CONFIG_PATH);
|
|
} else {
|
|
let x = serde_json::from_str(&buf)
|
|
.unwrap_or_else(|_| panic!("Could not deserialise {}", AURA_CONFIG_PATH));
|
|
*self = x;
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn write(&self) {
|
|
let mut file = File::create(AURA_CONFIG_PATH).expect("Couldn't overwrite config");
|
|
let json = serde_json::to_string_pretty(self).expect("Parse config to JSON failed");
|
|
file.write_all(json.as_bytes())
|
|
.unwrap_or_else(|err| error!("Could not write config: {}", err));
|
|
}
|
|
|
|
/// Set the mode data, current mode, and if multizone enabled.
|
|
///
|
|
/// Multipurpose, will accept AuraEffect with zones and put in the correct store.
|
|
pub fn set_builtin(&mut self, effect: AuraEffect) {
|
|
self.current_mode = effect.mode;
|
|
match effect.zone() {
|
|
AuraZone::None => {
|
|
self.builtins.insert(*effect.mode(), effect);
|
|
self.multizone_on = false;
|
|
}
|
|
_ => {
|
|
if let Some(multi) = self.multizone.as_mut() {
|
|
if let Some(fx) = multi.get_mut(effect.mode()) {
|
|
for fx in fx.iter_mut() {
|
|
if fx.zone == effect.zone {
|
|
*fx = effect;
|
|
return;
|
|
}
|
|
}
|
|
fx.push(effect);
|
|
} else {
|
|
multi.insert(*effect.mode(), vec![effect]);
|
|
}
|
|
} else {
|
|
let mut tmp = BTreeMap::new();
|
|
tmp.insert(*effect.mode(), vec![effect]);
|
|
self.multizone = Some(tmp);
|
|
}
|
|
self.multizone_on = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn get_multizone(&self, aura_type: AuraModeNum) -> Option<&[AuraEffect]> {
|
|
if let Some(multi) = &self.multizone {
|
|
return multi.get(&aura_type).map(|v| v.as_slice());
|
|
}
|
|
None
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::AuraConfig;
|
|
use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour};
|
|
|
|
#[test]
|
|
fn set_multizone_4key_config() {
|
|
let mut config = AuraConfig::default();
|
|
|
|
let effect = AuraEffect {
|
|
colour1: Colour(0xff, 0x00, 0xff),
|
|
zone: AuraZone::Key1,
|
|
..Default::default()
|
|
};
|
|
config.set_builtin(effect);
|
|
|
|
assert!(config.multizone.is_some());
|
|
|
|
let effect = AuraEffect {
|
|
colour1: Colour(0x00, 0xff, 0xff),
|
|
zone: AuraZone::Key2,
|
|
..Default::default()
|
|
};
|
|
config.set_builtin(effect);
|
|
|
|
let effect = AuraEffect {
|
|
colour1: Colour(0xff, 0xff, 0x00),
|
|
zone: AuraZone::Key3,
|
|
..Default::default()
|
|
};
|
|
config.set_builtin(effect);
|
|
|
|
let effect = AuraEffect {
|
|
colour1: Colour(0x00, 0xff, 0x00),
|
|
zone: AuraZone::Key4,
|
|
..Default::default()
|
|
};
|
|
let effect_clone = effect.clone();
|
|
config.set_builtin(effect);
|
|
// This should replace existing
|
|
config.set_builtin(effect_clone);
|
|
|
|
let res = config.multizone.unwrap();
|
|
let sta = res.get(&AuraModeNum::Static).unwrap();
|
|
assert_eq!(sta.len(), 4);
|
|
assert_eq!(sta[0].colour1, Colour(0xff, 0x00, 0xff));
|
|
assert_eq!(sta[1].colour1, Colour(0x00, 0xff, 0xff));
|
|
assert_eq!(sta[2].colour1, Colour(0xff, 0xff, 0x00));
|
|
assert_eq!(sta[3].colour1, Colour(0x00, 0xff, 0x00));
|
|
}
|
|
|
|
#[test]
|
|
fn set_multizone_multimode_config() {
|
|
let mut config = AuraConfig::default();
|
|
|
|
let effect = AuraEffect {
|
|
zone: AuraZone::Key1,
|
|
..Default::default()
|
|
};
|
|
config.set_builtin(effect);
|
|
|
|
assert!(config.multizone.is_some());
|
|
|
|
let effect = AuraEffect {
|
|
zone: AuraZone::Key2,
|
|
mode: AuraModeNum::Breathe,
|
|
..Default::default()
|
|
};
|
|
config.set_builtin(effect);
|
|
|
|
let effect = AuraEffect {
|
|
zone: AuraZone::Key3,
|
|
mode: AuraModeNum::Comet,
|
|
..Default::default()
|
|
};
|
|
config.set_builtin(effect);
|
|
|
|
let effect = AuraEffect {
|
|
zone: AuraZone::Key4,
|
|
mode: AuraModeNum::Pulse,
|
|
..Default::default()
|
|
};
|
|
config.set_builtin(effect);
|
|
|
|
let res = config.multizone.unwrap();
|
|
let sta = res.get(&AuraModeNum::Static).unwrap();
|
|
assert_eq!(sta.len(), 1);
|
|
|
|
let sta = res.get(&AuraModeNum::Breathe).unwrap();
|
|
assert_eq!(sta.len(), 1);
|
|
|
|
let sta = res.get(&AuraModeNum::Comet).unwrap();
|
|
assert_eq!(sta.len(), 1);
|
|
|
|
let sta = res.get(&AuraModeNum::Pulse).unwrap();
|
|
assert_eq!(sta.len(), 1);
|
|
}
|
|
}
|