diff --git a/README.md b/README.md index da82bbc..f617a91 100644 --- a/README.md +++ b/README.md @@ -15,95 +15,6 @@ You will need that installed for this plugin to work. - Display supplementary battery info - Keep settings between restarts (stored in `~/.config/powertools/.json`) -## Cool, but that's too much work - -Fair enough. -In case you still want some of the functionality, without the nice GUI, here's some equivalent commands. -These should all be run as superuser, i.e. run `sudo su` and then run these commands in that. - -### Enable & Disable CPU threads - -Enable: `echo 1 > /sys/devices/system/cpu/cpu{cpu_number}/online` where `{cpu_number}` is a number from 1 to 7 (inclusive). - -Disable: `echo 0 > /sys/devices/system/cpu/cpu{cpu_number}/online` where `{cpu_number}` is a number from 1 to 7 (inclusive). - -NOTE: You cannot enable or disable cpu0, hence why there are only 7 in the range for 8 cpu threads. - -### Enable & Disable CPU boost - -Enable: `echo 1 > /sys/devices/system/cpu/cpufreq/boost` enables boost across all threads. - -Disable: `echo 0 > /sys/devices/system/cpu/cpufreq/boost` disables boost across all threads. - -### Set CPU frequency - -Use `cpupower` (usage: `cpupower --help`). -This isn't strictly how PowerTools does it, but it's a multi-step process which can involve changing the CPU governor. -All that can be done automatically by `cpupower frequency-set --freq {frequency}` where `{frequency}` is `1.7G`, `2.4G` or `2.8G`. - -### Set GPU Power - -Set Slow Powerplay Table (PPT):`echo {microwatts} > /sys/class/hwmon/hwmon4/power1_cap` where `{microwatts}` is a wattage in millionths of a Watt. This doesn't seem to do a lot. - -Set Fast Powerplay Table (PPT): `echo {microwatts} > /sys/class/hwmon/hwmon4/power2_cap` where `{microwatts}` is a wattage in millionths of a Watt. - -Get the entry limits for those two commands with `cat /sys/class/hwmon/hwmon4/power{number}_cap_max` where `{number}` is `1` (slowPPT) or `2` (fastPPT). - -### Set Fan speed - -NOTE: PowerTools no longer supports this, since [Fantastic](https://github.com/NGnius/Fantastic) does it much better. - -Enable automatic control: `echo 0 > /sys/class/hwmon/hwmon5/recalculate` enables automatic fan control. - -Disable automatic control: `echo 1 > /sys/class/hwmon/hwmon5/recalculate` disables automatic (temperature-based) fan control and starts using the set fan target instead. - -Set the fan speed: `echo {rpm} > /sys/class/hwmon/hwmon5/fan1_target` where `{rpm}` is the RPM. - -Read the actual fan RPM: `cat /sys/class/hwmon/hwmon5/fan1_input` gives the fan speed. - -NOTE: There's a bug in the fan controller; if you enable automatic fan control it will forget any previously-set target despite it appearing to be set correctly (i.e. `cat /sys/class/hwmon/hwmon5/fan1_target` will display the correct value). -When you disable automatic fan control, you will need to set the fan RPM again. - -### Battery stats - -Get the battery charge right now: `cat /sys/class/hwmon/hwmon2/device/charge_now` gives charge in uAh (uAh * 7.7/1000000 = charge in Wh). - -Get the maximum battery capacity: `cat /sys/class/hwmon/hwmon2/device/charge_full` gives charge in uAh. - -Get the design battery capacity: `cat /sys/class/hwmon/hwmon2/device/charge_full_design` gives charge in uAh. - -Get whether the deck is plugged in: `cat /sys/class/hwmon/hwmon5/curr1_input` gives the charger current in mA. - -NOTE: 7.7 is the voltage of the battery -- it's not just a magic number. - -### Steam Deck kernel patches - -This is how I figured out how the fan stuff works. -I've only scratched the surface of what this code allows, I'm sure it has more useful information. -https://lkml.org/lkml/2022/2/5/391 - -### Game launch detection - -```typescript -//@ts-ignore -let lifetimeHook = SteamClient.GameSessions.RegisterForAppLifetimeNotifications((update) => { - if (update.bRunning) { - console.log("AppID " + update.unAppID.toString() + " is now running"); - } else { - console.log("AppID " + update.unAppID.toString() + " is no longer running"); - // game exit code here - // NOTE: custom games always have 0 as AppID, so AppID is bad to use as ID - } -}); -//@ts-ignore -let startHook = SteamClient.Apps.RegisterForGameActionStart((actionType, id) => { - //@ts-ignore - let gameInfo: any = appStore.GetAppOverviewByGameID(id); - // game start code here - // NOTE: GameID (variable: id) is always unique, even for custom games, so it's better to use than AppID -}); -``` - ## License This is licensed under GNU GPLv3. diff --git a/main.py b/main.py index e7435f5..3e7acb9 100644 --- a/main.py +++ b/main.py @@ -13,4 +13,4 @@ class Plugin: # startup self.backend_proc = subprocess.Popen([PARENT_DIR + "/bin/backend"]) while True: - asyncio.sleep(1) + await asyncio.sleep(1) diff --git a/package.json b/package.json index 78c94ca..91b250c 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "PowerTools", - "version": "0.7.0", + "version": "1.0.0-alpha", "description": "Power tweaks for power users", "scripts": { "build": "shx rm -rf dist && rollup -c", diff --git a/plugin.json b/plugin.json index 26579aa..d770877 100644 --- a/plugin.json +++ b/plugin.json @@ -1,7 +1,7 @@ { "name": "PowerTools", "author": "NGnius", - "flags": ["root", "_debug"], + "flags": ["root", "debug"], "publish": { "discord_id": "106537989684887552", "description": "Power tweaks for power users", diff --git a/powertools-rs/Cargo.lock b/powertools-rs/Cargo.lock index 2f30d12..850bf31 100644 --- a/powertools-rs/Cargo.lock +++ b/powertools-rs/Cargo.lock @@ -1054,8 +1054,6 @@ dependencies = [ [[package]] name = "usdpl-back" version = "0.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cbbc0781e83ba990f8239142e33173a2d2548701775f3db66702d1af4fd0319a" dependencies = [ "bytes", "hex", @@ -1068,8 +1066,6 @@ dependencies = [ [[package]] name = "usdpl-core" version = "0.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "862153581fac266458521f49e5906a71c1eee1665cb4c7d71e9586bd34b45394" dependencies = [ "aes-gcm-siv", "base64", diff --git a/powertools-rs/Cargo.toml b/powertools-rs/Cargo.toml index 8116352..d6565f0 100644 --- a/powertools-rs/Cargo.toml +++ b/powertools-rs/Cargo.toml @@ -6,7 +6,7 @@ edition = "2021" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -usdpl-back = { version = "0.6.0", features = ["blocking"]} +usdpl-back = { version = "0.6.0", features = ["blocking"], path = "../../usdpl-rs/usdpl-back"} serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" diff --git a/powertools-rs/build.sh b/powertools-rs/build.sh index 808e199..94cd216 100755 --- a/powertools-rs/build.sh +++ b/powertools-rs/build.sh @@ -1,5 +1,10 @@ #!/bin/bash -cargo build --release --target x86_64-unknown-linux-musl -mkdir ../bin &> /dev/null -cp ./target/release/powertools-rs ../bin/backend +#cargo build --release --target x86_64-unknown-linux-musl +cargo build --target x86_64-unknown-linux-musl +#cross build --release + +mkdir -p ../bin +#cp ./target/x86_64-unknown-linux-musl/release/powertools-rs ../bin/backend +cp ./target/x86_64-unknown-linux-musl/debug/powertools-rs ../bin/backend +#cp ./target/release/powertools-rs ../bin/backend diff --git a/powertools-rs/src/api/general.rs b/powertools-rs/src/api/general.rs index 0345620..67dcba4 100644 --- a/powertools-rs/src/api/general.rs +++ b/powertools-rs/src/api/general.rs @@ -18,10 +18,12 @@ pub fn set_persistent( unwrap_lock(saver.lock(), "save channel").send(()), "Failed to send on save channel", ); - super::utility::map_empty_result( + let result = super::utility::map_empty_result( settings_lock.on_set(), settings_lock.persistent, - ) + ); + log::debug!("Persistent is now {}", settings_lock.persistent); + result } else { vec!["set_persistent missing parameter".into()] } @@ -46,9 +48,14 @@ pub fn load_settings( move |params_in: super::ApiParameterType| { if let Some(Primitive::String(path)) = params_in.get(0) { if let Some(Primitive::String(name)) = params_in.get(1) { - super::utility::map_result( - settings.load_file(path.into(), name.to_owned()) - ) + match settings.load_file(path.into(), name.to_owned()) { + Err(e) => vec![e.msg.into()], + Ok(success) => + super::utility::map_empty_result( + settings.clone().on_set(), + success + ) + } } else { vec!["load_settings missing name parameter".into()] } @@ -59,6 +66,24 @@ pub fn load_settings( } } +/// Generate load default settings from file web method +pub fn load_default_settings( + settings: Settings, +) -> impl Fn(super::ApiParameterType) -> super::ApiParameterType { + move |_: super::ApiParameterType| { + match settings.load_file( + crate::consts::DEFAULT_SETTINGS_FILE.into(), + crate::consts::DEFAULT_SETTINGS_NAME.to_owned() + ) { + Err(e) => vec![e.msg.into()], + Ok(success) => super::utility::map_empty_result( + settings.clone().on_set(), + success + ) + } + } +} + /// Generate get current settings name pub fn get_name( settings: Arc>, @@ -71,3 +96,16 @@ pub fn get_name( .into()] } } + +/// Generate get current settings name +pub fn lock_unlock_all( + settings: Settings, +) -> impl Fn(super::ApiParameterType) -> super::ApiParameterType { + move |_: super::ApiParameterType| { + let _lock = unwrap_lock(settings.general.lock(), "general"); + let _lock = unwrap_lock(settings.cpus.lock(), "cpus"); + let _lock = unwrap_lock(settings.gpu.lock(), "gpu"); + let _lock = unwrap_lock(settings.battery.lock(), "battery"); + vec![true.into()] + } +} diff --git a/powertools-rs/src/api/utility.rs b/powertools-rs/src/api/utility.rs index a2fbfb1..c5b4bc0 100644 --- a/powertools-rs/src/api/utility.rs +++ b/powertools-rs/src/api/utility.rs @@ -3,19 +3,27 @@ use usdpl_back::core::serdes::Primitive; use crate::settings::SettingError; +#[inline] pub fn map_result>(result: Result) -> super::ApiParameterType { match result { Ok(val) => vec![val.into()], - Err(e) => vec![e.msg.into()], + Err(e) => { + log::debug!("Mapping error to primitive: {}", e); + vec![e.msg.into()] + }, } } +#[inline] pub fn map_empty_result>( result: Result<(), SettingError>, success: T, ) -> super::ApiParameterType { match result { Ok(_) => vec![success.into()], - Err(e) => vec![e.msg.into()], + Err(e) => { + log::debug!("Mapping error to primitive: {}", e); + vec![e.msg.into()] + }, } } diff --git a/powertools-rs/src/consts.rs b/powertools-rs/src/consts.rs index ef119ba..43e23b7 100644 --- a/powertools-rs/src/consts.rs +++ b/powertools-rs/src/consts.rs @@ -4,3 +4,4 @@ pub const PACKAGE_NAME: &'static str = env!("CARGO_PKG_NAME"); pub const PACKAGE_VERSION: &'static str = env!("CARGO_PKG_VERSION"); pub const DEFAULT_SETTINGS_FILE: &str = "default_settings.json"; +pub const DEFAULT_SETTINGS_NAME: &str = "Default"; diff --git a/powertools-rs/src/main.rs b/powertools-rs/src/main.rs index c22ef6f..d612013 100644 --- a/powertools-rs/src/main.rs +++ b/powertools-rs/src/main.rs @@ -9,6 +9,8 @@ mod resume_worker; mod save_worker; mod utility; +use settings::OnSet; + use simplelog::{LevelFilter, WriteLogger}; use usdpl_back::core::serdes::Primitive; @@ -32,118 +34,124 @@ fn main() -> Result<(), ()> { log::info!("Starting back-end ({} v{})", PACKAGE_NAME, PACKAGE_VERSION); println!("Starting back-end ({} v{})", PACKAGE_NAME, PACKAGE_VERSION); - let default_settings = persist::SettingsJson::open(settings_dir().join(DEFAULT_SETTINGS_FILE)) + let mut loaded_settings = persist::SettingsJson::open(utility::settings_dir().join(DEFAULT_SETTINGS_FILE)) .map(|settings| settings::Settings::from_json(settings, DEFAULT_SETTINGS_FILE.into())) .unwrap_or_else(|_| settings::Settings::system_default(DEFAULT_SETTINGS_FILE.into())); - log::debug!("Settings: {:?}", default_settings); + log::debug!("Settings: {:?}", loaded_settings); - let (_save_handle, save_sender) = save_worker::spawn(default_settings.clone()); - let _resume_handle = resume_worker::spawn(default_settings.clone()); + let (_save_handle, save_sender) = save_worker::spawn(loaded_settings.clone()); + let _resume_handle = resume_worker::spawn(loaded_settings.clone()); + + if let Err(e) = loaded_settings.on_set() { + log::error!("Startup Settings.on_set() error: {}", e); + } Instance::new(PORT) - .register("hello", |_: Vec| { - vec![format!("Hello {}", PACKAGE_NAME).into()] + .register("V_INFO", |_: Vec| { + vec![format!("{} v{}", PACKAGE_NAME, PACKAGE_VERSION).into()] }) // battery API functions .register("BATTERY_current_now", api::battery::current_now) .register( "BATTERY_set_charge_rate", - api::battery::set_charge_rate(default_settings.battery.clone(), save_sender.clone()), + api::battery::set_charge_rate(loaded_settings.battery.clone(), save_sender.clone()), ) .register( "BATTERY_get_charge_rate", - api::battery::get_charge_rate(default_settings.battery.clone()), + api::battery::get_charge_rate(loaded_settings.battery.clone()), ) .register( "BATTERY_unset_charge_rate", - api::battery::unset_charge_rate(default_settings.battery.clone(), save_sender.clone()), + api::battery::unset_charge_rate(loaded_settings.battery.clone(), save_sender.clone()), ) // cpu API functions .register("CPU_count", api::cpu::max_cpus) .register( "CPU_set_online", - api::cpu::set_cpu_online(default_settings.cpus.clone(), save_sender.clone()) + api::cpu::set_cpu_online(loaded_settings.cpus.clone(), save_sender.clone()) ) .register( "CPU_get_onlines", - api::cpu::get_cpus_online(default_settings.cpus.clone()) + api::cpu::get_cpus_online(loaded_settings.cpus.clone()) ) .register( "CPU_set_clock_limits", - api::cpu::set_clock_limits(default_settings.cpus.clone(), save_sender.clone()) + api::cpu::set_clock_limits(loaded_settings.cpus.clone(), save_sender.clone()) ) .register( "CPU_get_clock_limits", - api::cpu::get_clock_limits(default_settings.cpus.clone()) + api::cpu::get_clock_limits(loaded_settings.cpus.clone()) ) .register( "CPU_unset_clock_limits", - api::cpu::unset_clock_limits(default_settings.cpus.clone(), save_sender.clone()) + api::cpu::unset_clock_limits(loaded_settings.cpus.clone(), save_sender.clone()) ) .register( "CPU_set_governor", - api::cpu::set_cpu_governor(default_settings.cpus.clone(), save_sender.clone()) + api::cpu::set_cpu_governor(loaded_settings.cpus.clone(), save_sender.clone()) ) .register( "CPU_get_governors", - api::cpu::get_cpu_governors(default_settings.cpus.clone()) + api::cpu::get_cpu_governors(loaded_settings.cpus.clone()) ) // gpu API functions .register( "GPU_set_ppt", - api::gpu::set_ppt(default_settings.gpu.clone(), save_sender.clone()) + api::gpu::set_ppt(loaded_settings.gpu.clone(), save_sender.clone()) ) .register( "GPU_get_ppt", - api::gpu::get_ppt(default_settings.gpu.clone()) + api::gpu::get_ppt(loaded_settings.gpu.clone()) ) .register( "GPU_unset_ppt", - api::gpu::unset_ppt(default_settings.gpu.clone(), save_sender.clone()) + api::gpu::unset_ppt(loaded_settings.gpu.clone(), save_sender.clone()) ) .register( "GPU_set_clock_limits", - api::gpu::set_clock_limits(default_settings.gpu.clone(), save_sender.clone()) + api::gpu::set_clock_limits(loaded_settings.gpu.clone(), save_sender.clone()) ) .register( "GPU_get_clock_limits", - api::gpu::get_clock_limits(default_settings.gpu.clone()) + api::gpu::get_clock_limits(loaded_settings.gpu.clone()) ) .register( "GPU_unset_clock_limits", - api::gpu::unset_clock_limits(default_settings.gpu.clone(), save_sender.clone()) + api::gpu::unset_clock_limits(loaded_settings.gpu.clone(), save_sender.clone()) ) .register( "GPU_set_slow_memory", - api::gpu::set_slow_memory(default_settings.gpu.clone(), save_sender.clone()) + api::gpu::set_slow_memory(loaded_settings.gpu.clone(), save_sender.clone()) ) .register( "GPU_get_slow_memory", - api::gpu::get_slow_memory(default_settings.gpu.clone()) + api::gpu::get_slow_memory(loaded_settings.gpu.clone()) ) // general API functions .register( "GENERAL_set_persistent", - api::general::set_persistent(default_settings.general.clone(), save_sender.clone()) + api::general::set_persistent(loaded_settings.general.clone(), save_sender.clone()) ) .register( "GENERAL_get_persistent", - api::general::get_persistent(default_settings.general.clone()) + api::general::get_persistent(loaded_settings.general.clone()) ) .register( "GENERAL_load_settings", - api::general::load_settings(default_settings.clone()) + api::general::load_settings(loaded_settings.clone()) + ) + .register( + "GENERAL_load_default_settings", + api::general::load_default_settings(loaded_settings.clone()) ) .register( "GENERAL_get_name", - api::general::get_name(default_settings.general.clone()) + api::general::get_name(loaded_settings.general.clone()) + ) + .register( + "GENERAL_wait_for_unlocks", + api::general::lock_unlock_all(loaded_settings.clone()) ) .run_blocking() } - -fn settings_dir() -> std::path::PathBuf { - usdpl_back::api::dirs::home() - .unwrap_or_else(|| "/home/deck".into()) - .join(".config/powertools/") -} diff --git a/powertools-rs/src/persist/general.rs b/powertools-rs/src/persist/general.rs index 800ec86..da8e48c 100644 --- a/powertools-rs/src/persist/general.rs +++ b/powertools-rs/src/persist/general.rs @@ -19,7 +19,7 @@ impl Default for SettingsJson { fn default() -> Self { Self { version: 0, - name: "default".to_owned(), + name: crate::consts::DEFAULT_SETTINGS_NAME.to_owned(), persistent: false, cpus: Vec::with_capacity(8), gpu: GpuJson::default(), diff --git a/powertools-rs/src/resume_worker.rs b/powertools-rs/src/resume_worker.rs index 9bded8f..b0eca6f 100644 --- a/powertools-rs/src/resume_worker.rs +++ b/powertools-rs/src/resume_worker.rs @@ -8,6 +8,7 @@ const ALLOWED_ERROR: f64 = 0.001; pub fn spawn(settings: Settings) -> JoinHandle<()> { thread::spawn(move || { + log::info!("resume_worker starting..."); let duration = Duration::from_millis(5000); let mut start = Instant::now(); loop { @@ -17,11 +18,12 @@ pub fn spawn(settings: Settings) -> JoinHandle<()> { if old_start.as_secs_f64() > duration.as_secs_f64() * (1.0 + ALLOWED_ERROR) { // has just resumed from sleep unwrap_maybe_fatal(settings.on_resume(), "On resume failure"); - log::info!( + log::debug!( "OnResume completed after sleeping for {}s", old_start.as_secs_f32() ); } } + //log::warn!("resume_worker completed!"); }) } diff --git a/powertools-rs/src/save_worker.rs b/powertools-rs/src/save_worker.rs index 221f91f..bad505a 100644 --- a/powertools-rs/src/save_worker.rs +++ b/powertools-rs/src/save_worker.rs @@ -8,12 +8,17 @@ use crate::utility::{unwrap_lock, unwrap_maybe_fatal}; pub fn spawn(settings: Settings) -> (JoinHandle<()>, Sender<()>) { let (sender, receiver): (Sender<()>, Receiver<()>) = mpsc::channel(); let worker = thread::spawn(move || { + log::info!("save_worker starting..."); for _ in receiver.iter() { - let save_path = unwrap_lock(settings.general.lock(), "general").path.clone(); - let save_json: SettingsJson = settings.clone().into(); + log::debug!("save_worker is saving..."); + let save_path = crate::utility::settings_dir() + .join(unwrap_lock(settings.general.lock(), "general").path.clone()); + let settings_clone = settings.clone(); + let save_json: SettingsJson = settings_clone.into(); unwrap_maybe_fatal(save_json.save(&save_path), "Failed to save settings"); log::debug!("Saved settings to {}", save_path.display()); } + log::warn!("save_worker completed!"); }); (worker, sender) } diff --git a/powertools-rs/src/settings/cpu.rs b/powertools-rs/src/settings/cpu.rs index aca68e8..5b0ad78 100644 --- a/powertools-rs/src/settings/cpu.rs +++ b/powertools-rs/src/settings/cpu.rs @@ -101,16 +101,18 @@ impl Cpu { })?; } // set governor - let governor_path = cpu_governor_path(self.index); - usdpl_back::api::files::write_single(&governor_path, &self.governor).map_err(|e| { - SettingError { - msg: format!( - "Failed to write `{}` to `{}`: {}", - &self.governor, &governor_path, e - ), - setting: super::SettingVariant::Cpu, - } - })?; + if self.index == 0 || self.online { + let governor_path = cpu_governor_path(self.index); + usdpl_back::api::files::write_single(&governor_path, &self.governor).map_err(|e| { + SettingError { + msg: format!( + "Failed to write `{}` to `{}`: {}", + &self.governor, &governor_path, e + ), + setting: super::SettingVariant::Cpu, + } + })?; + } Ok(()) } @@ -141,7 +143,7 @@ impl Cpu { if let Some(dash_index) = data.find('-') { let data = data.split_off(dash_index + 1); if let Ok(max_cpu) = data.parse::() { - return Some(max_cpu); + return Some(max_cpu + 1); } } log::warn!("Failed to parse CPU info from kernel, is Tux evil?"); diff --git a/powertools-rs/src/settings/general.rs b/powertools-rs/src/settings/general.rs index df994fc..7956b4b 100644 --- a/powertools-rs/src/settings/general.rs +++ b/powertools-rs/src/settings/general.rs @@ -40,7 +40,7 @@ impl OnSet for General { // remove settings file when persistence is turned off, to prevent it from be loaded next time. if !self.persistent && self.path.exists() { std::fs::remove_file(&self.path).map_err(|e| SettingError { - msg: e.to_string(), + msg: format!("Failed to delete `{}`: {}", self.path.display(), e), setting: SettingVariant::General, })?; } @@ -67,16 +67,7 @@ impl OnSet for Settings { } } unwrap_lock(self.gpu.lock(), "gpu").on_set()?; - { - // general lock scope - let gen_lock = unwrap_lock(self.general.lock(), "general"); - if !gen_lock.persistent && gen_lock.path.exists() { - std::fs::remove_file(&gen_lock.path).map_err(|e| SettingError { - msg: format!("Failed to delete `{}`: {}", gen_lock.path.display(), e), - setting: SettingVariant::General, - })?; - } - } + unwrap_lock(self.general.lock(), "general").on_set()?; Ok(()) } } @@ -121,7 +112,7 @@ impl Settings { general: Arc::new(Mutex::new(General { persistent: false, path: json_path, - name: "".to_owned(), + name: crate::consts::DEFAULT_SETTINGS_NAME.to_owned(), })), cpus: Arc::new(Mutex::new(Cpu::system_default())), gpu: Arc::new(Mutex::new(Gpu::system_default())), @@ -179,17 +170,26 @@ impl OnResume for Settings { impl Into for Settings { #[inline] fn into(self) -> SettingsJson { + log::debug!("Locking settings to convert into json"); + let gen_lock = unwrap_lock(self.general.lock(), "general"); + log::debug!("Got general lock"); + let cpu_lock = unwrap_lock(self.cpus.lock(), "cpu"); + log::debug!("Got cpus lock"); + let gpu_lock = unwrap_lock(self.gpu.lock(), "gpu"); + log::debug!("Got gpu lock"); + let batt_lock = unwrap_lock(self.battery.lock(), "battery"); + log::debug!("Got battery lock"); SettingsJson { version: LATEST_VERSION, - name: unwrap_lock(self.general.lock(), "general").name.clone(), - persistent: unwrap_lock(self.general.lock(), "general").persistent, - cpus: unwrap_lock(self.cpus.lock(), "cpu") + name: gen_lock.name.clone(), + persistent: gen_lock.persistent, + cpus: cpu_lock .clone() .drain(..) .map(|cpu| cpu.into()) .collect(), - gpu: unwrap_lock(self.gpu.lock(), "gpu").clone().into(), - battery: unwrap_lock(self.battery.lock(), "battery").clone().into(), + gpu: gpu_lock.clone().into(), + battery: batt_lock.clone().into(), } } } diff --git a/powertools-rs/src/utility.rs b/powertools-rs/src/utility.rs index f14b992..1369816 100644 --- a/powertools-rs/src/utility.rs +++ b/powertools-rs/src/utility.rs @@ -23,3 +23,9 @@ pub fn unwrap_lock<'a, T: Sized>( } } } + +pub fn settings_dir() -> std::path::PathBuf { + usdpl_back::api::dirs::home() + .unwrap_or_else(|| "/home/deck".into()) + .join(".config/powertools/") +} diff --git a/src/backend.ts b/src/backend.ts index d78bfb1..4da3178 100644 --- a/src/backend.ts +++ b/src/backend.ts @@ -1,4 +1,4 @@ -import {init_usdpl, target, init_embedded, call_backend} from "usdpl-front"; +import {init_usdpl, target_usdpl, init_embedded, call_backend} from "usdpl-front"; const USDPL_PORT: number = 44443; @@ -20,12 +20,16 @@ export async function initBackend() { // init usdpl await init_embedded(); init_usdpl(USDPL_PORT); - console.log("USDPL started for framework: " + target()); + console.log("USDPL started for framework: " + target_usdpl()); //setReady(true); } // API +export async function getInfo(): Promise { + return (await call_backend("V_INFO", []))[0]; +} + // Battery export async function getBatteryCurrent(): Promise { @@ -126,6 +130,14 @@ export async function loadGeneralSettings(path: string, name: string): Promise { +export async function loadGeneralDefaultSettings(): Promise { + return (await call_backend("GENERAL_load_default_settings", []))[0]; +} + +export async function getGeneralSettingsName(): Promise { return (await call_backend("GENERAL_get_name", []))[0]; } + +export async function waitForComplete(): Promise { + return (await call_backend("GENERAL_wait_for_unlocks", []))[0]; +} diff --git a/src/index.tsx b/src/index.tsx index dd70005..4e06f8f 100755 --- a/src/index.tsx +++ b/src/index.tsx @@ -1,7 +1,7 @@ import { - //ButtonItem, + ButtonItem, definePlugin, - DialogButton, + //DialogButton, //Menu, //MenuItem, PanelSection, @@ -19,161 +19,131 @@ import { import { VFC, useState } from "react"; import { GiDrill } from "react-icons/gi"; -import * as python from "./python"; +//import * as python from "./python"; +import * as backend from "./backend"; +import {set_value, get_value, target_usdpl, version_usdpl} from "usdpl-front"; -//import logo from "../assets/logo.png"; - -// interface AddMethodArgs { -// left: number; -// right: number; -// } - -var firstTime: boolean = true; -var versionGlobalHolder: string = "0.0.0-jank"; var periodicHook: NodeJS.Timer | null = null; -var lastGame: string = ""; var lifetimeHook: any = null; var startHook: any = null; +var usdplReady = false; -var smt_backup: boolean = true; -var cpus_backup: number = 8; -var boost_backup: boolean = true; -var freq_backup: number = 8; -var slowPPT_backup: number = 1; -var fastPPT_backup: number = 1; -var chargeNow_backup: number = 5200000; -var chargeFull_backup: number = 5200000; -var chargeDesign_backup: number = 5200000; -var persistent_backup: boolean = false; -var perGameProfile_backup: boolean = false; +var smtAllowed = true; +var smtGlobal = smtAllowed; -var reload = function(){}; +// usdpl persistent store keys -const Content: VFC<{ serverAPI: ServerAPI }> = ({serverAPI}) => { - // const [result, setResult] = useState(); +const BACKEND_INFO = "VINFO"; - // const onClick = async () => { - // const result = await serverAPI.callPluginMethod( - // "add", - // { - // left: 2, - // right: 2, - // } - // ); - // if (result.success) { - // setResult(result.result); - // } - // }; +const CURRENT_BATT = "BATTERY_current_now"; +const CHARGE_RATE_BATT = "BATTERY_charge_rate"; - python.setServer(serverAPI); +const TOTAL_CPUS = "CPUs_total"; +const ONLINE_CPUS = "CPUs_online"; +const CLOCK_MIN_CPU = "CPUs_min_clock"; +const CLOCK_MAX_CPU = "CPUs_max_clock"; +const GOVERNOR_CPU = "CPUs_governor"; - const [smtGlobal, setSMT_internal] = useState(smt_backup); - const setSMT = (value: boolean) => { - smt_backup = value; - setSMT_internal(value); - }; +const FAST_PPT_GPU = "GPU_fastPPT"; +const SLOW_PPT_GPU = "GPU_slowPPT"; +const CLOCK_MIN_GPU = "GPU_min_clock"; +const CLOCK_MAX_GPU = "GPU_max_clock"; +const SLOW_MEMORY_GPU = "GPU_slow_memory"; - const [cpusGlobal, setCPUs_internal] = useState(cpus_backup); - const setCPUs = (value: number) => { - cpus_backup = value; - setCPUs_internal(value); - }; +const PERSISTENT_GEN = "GENERAL_persistent"; +const NAME_GEN = "GENERAL_name"; - const [boostGlobal, setBoost_internal] = useState(boost_backup); - const setBoost = (value: boolean) => { - boost_backup = value; - setBoost_internal(value); - }; +const reload = function() { + if (!usdplReady) {return;} - const [freqGlobal, setFreq_internal] = useState(freq_backup); - const setFreq = (value: number) => { - freq_backup = value; - setFreq_internal(value); - }; + backend.resolve(backend.getBatteryCurrent(), (rate: number) => { set_value(CURRENT_BATT, rate) }); + backend.resolve(backend.getBatteryChargeRate(), (rate: number) => { set_value(CHARGE_RATE_BATT, rate) }); - const [slowPPTGlobal, setSlowPPT_internal] = useState(slowPPT_backup); - const setSlowPPT = (value: number) => { - slowPPT_backup = value; - setSlowPPT_internal(value); - }; + backend.resolve(backend.getCpuCount(), (count: number) => { set_value(TOTAL_CPUS, count)}); + backend.resolve(backend.getCpusOnline(), (statii: boolean[]) => { + // TODO: allow for per-core control of online status + let count = 0; + for (let i = 0; i < statii.length; i++) { + if (statii[i]) { + count += 1; + } + } + set_value(ONLINE_CPUS, count); + smtGlobal = statii.length > 3 && statii[0] == statii[1] && statii[2] == statii[3] && smtAllowed; + }); + // TODO: allow for per-core control of clock limits + backend.resolve(backend.getCpuClockLimits(0), (limits: number[]) => { + set_value(CLOCK_MIN_CPU, limits[0]); + set_value(CLOCK_MAX_CPU, limits[1]); + }); + // TODO: allow for control of governor + backend.resolve(backend.getCpusGovernor(), (governors: string[]) => { set_value(GOVERNOR_CPU, governors[0]) }); - const [fastPPTGlobal, setFastPPT_internal] = useState(fastPPT_backup); - const setFastPPT = (value: number) => { - fastPPT_backup = value; - setFastPPT_internal(value); - }; + backend.resolve(backend.getGpuPpt(), (ppts: number[]) => { + set_value(FAST_PPT_GPU, ppts[0]); + set_value(SLOW_PPT_GPU, ppts[1]); + }); + backend.resolve(backend.getGpuClockLimits(), (limits: number[]) => { + set_value(CLOCK_MIN_GPU, limits[0]); + set_value(CLOCK_MAX_GPU, limits[1]); + }); + backend.resolve(backend.getGpuSlowMemory(), (status: boolean) => { set_value(SLOW_MEMORY_GPU, status) }); - const [chargeNowGlobal, setChargeNow_internal] = useState(chargeNow_backup); - const setChargeNow = (value: number) => { - chargeNow_backup = value; - setChargeNow_internal(value); - }; + backend.resolve(backend.getGeneralPersistent(), (value: boolean) => { set_value(PERSISTENT_GEN, value) }); + backend.resolve(backend.getGeneralSettingsName(), (name: string) => { set_value(NAME_GEN, name) }); - const [chargeFullGlobal, setChargeFull_internal] = useState(chargeFull_backup); - const setChargeFull = (value: number) => { - chargeFull_backup = value; - setChargeFull_internal(value); - }; + backend.resolve(backend.getInfo(), (info: string) => { set_value(BACKEND_INFO, info) }); +}; - const [chargeDesignGlobal, setChargeDesign_internal] = useState(chargeDesign_backup); - const setChargeDesign = (value: number) => { - chargeDesign_backup = value; - setChargeDesign_internal(value); - }; +// init USDPL WASM and connection to back-end +(async function(){ + await backend.initBackend(); + usdplReady = true; + set_value(NAME_GEN, "Default"); + reload(); // technically this is only a load - const [persistGlobal, setPersist_internal] = useState(persistent_backup); - const setPersist = (value: boolean) => { - persistent_backup = value; - setPersist_internal(value); - }; + // register Steam callbacks + //@ts-ignore + lifetimeHook = SteamClient.GameSessions.RegisterForAppLifetimeNotifications((update) => { + if (update.bRunning) { + //console.debug("AppID " + update.unAppID.toString() + " is now running"); + } else { + //console.debug("AppID " + update.unAppID.toString() + " is no longer running"); + backend.resolve( + backend.loadGeneralDefaultSettings(), + (ok: boolean) => {console.debug("Loading default settings ok? " + ok)} + ); + } + }); + //@ts-ignore + startHook = SteamClient.Apps.RegisterForGameActionStart((actionType, id) => { + //@ts-ignore + let gameInfo: any = appStore.GetAppOverviewByGameID(id); + backend.resolve( + backend.loadGeneralSettings(gameInfo.appid.toString() + ".json", gameInfo.display_name), + (ok: boolean) => {console.debug("Loading settings ok? " + ok)} + ); + }); - const [perGameProfileGlobal, setPerGameProfile_internal] = useState(perGameProfile_backup); - const setPerGameProfile = (value: boolean) => { - perGameProfile_backup = value; - setPerGameProfile_internal(value); - }; + console.debug("Registered PowerTools callbacks, hello!"); +})(); - const [gameGlobal, setGame_internal] = useState(lastGame); - const setGame = (value: string) => { - lastGame = value; - setGame_internal(value); - }; +const periodicals = function() { + backend.resolve(backend.getBatteryCurrent(), (rate: number) => { set_value(CURRENT_BATT, rate) }); - const [versionGlobal, setVersion_internal] = useState(versionGlobalHolder); - const setVersion = (value: string) => { - versionGlobalHolder = value; - setVersion_internal(value); - }; + backend.resolve(backend.getGeneralPersistent(), (value: boolean) => { set_value(PERSISTENT_GEN, value) }); + backend.resolve(backend.getGeneralSettingsName(), (name: string) => { + const oldValue = get_value(NAME_GEN); + set_value(NAME_GEN, name); + if (name != oldValue) { + reload(); + } + }); +}; - reload = function () { - python.execute(python.onViewReady()); +const Content: VFC<{ serverAPI: ServerAPI }> = ({}) => { - python.resolve(python.getSMT(), setSMT); - python.resolve(python.getCPUs(), setCPUs); - python.resolve(python.getCPUBoost(), setBoost); - python.resolve(python.getMaxBoost(), setFreq); - - python.resolve(python.getGPUPowerI(1), setSlowPPT); - python.resolve(python.getGPUPowerI(2), setFastPPT); - - python.resolve(python.getPersistent(), setPersist); - python.resolve(python.getPerGameProfile(), setPerGameProfile); - }; - - - if (firstTime) { - firstTime = false; - - reload(); // technically it's just load, not reload ;) - - python.resolve(python.getChargeNow(), setChargeNow); - python.resolve(python.getChargeFull(), setChargeFull); - python.resolve(python.getChargeDesign(), setChargeDesign); - - python.resolve(python.getCurrentGame(), setGame); - - python.resolve(python.getVersion(), setVersion); - } + const [_idc, reloadGUI] = useState("/shrug"); if (periodicHook != null) { clearInterval(periodicHook); @@ -181,189 +151,387 @@ const Content: VFC<{ serverAPI: ServerAPI }> = ({serverAPI}) => { } periodicHook = setInterval(function() { - python.resolve(python.getChargeFull(), setChargeFull); - python.resolve(python.getChargeNow(), setChargeNow); - python.resolve(python.getCurrentGame(), (game: string) => { - if (lastGame != game) { - setGame(game); - lastGame = game; - reload(); - } - }); + periodicals(); + reloadGUI("periodic" + (new Date()).getTime().toString()); }, 1000); const FieldWithSeparator = joinClassNames(gamepadDialogClasses.Field, gamepadDialogClasses.WithBottomSeparatorStandard); + const total_cpus = get_value(TOTAL_CPUS); + return ( - {/* CPU */} + {/* CPU */ /* TODO: set per-core stuff*/}
CPU
- + {smtAllowed && { - console.log("SMT is now " + smt.toString()); - python.execute(python.setCPUs(cpusGlobal, smt)); - python.resolve(python.getCPUs(), setCPUs); - python.resolve(python.getSMT(), setSMT); + console.debug("SMT is now " + smt.toString()); + const cpus = get_value(ONLINE_CPUS); + set_value(ONLINE_CPUS, 0); + smtGlobal = smt && smtAllowed; + for (let i = 0; i < total_cpus; i++) { + const online = (smtGlobal? i < cpus : (i % 2 == 0) && (i < cpus * 2)) + || (!smtGlobal && cpus == 4); + backend.resolve(backend.setCpuOnline(i, online), (value: boolean) => { + if (value) {set_value(ONLINE_CPUS, get_value(ONLINE_CPUS) + 1)} + }) + } + backend.resolve(backend.waitForComplete(), (_: boolean[]) => { + reloadGUI("SMT"); + }); }} /> - + } { - console.log("CPU slider is now " + cpus.toString()); - if (cpus != cpusGlobal) { - python.execute(python.setCPUs(cpus, smtGlobal)); - python.resolve(python.getCPUs(), setCPUs); + console.debug("CPU slider is now " + cpus.toString()); + const onlines = get_value(ONLINE_CPUS); + if (cpus != onlines) { + set_value(ONLINE_CPUS, 0); + for (let i = 0; i < total_cpus; i++) { + const online = smtGlobal? i < cpus : (i % 2 == 0) && (i < cpus * 2); + backend.resolve(backend.setCpuOnline(i, online), (value: boolean) => { + if (value) {set_value(ONLINE_CPUS, get_value(ONLINE_CPUS) + 1)} + }) + } + backend.resolve(backend.waitForComplete(), (_: boolean[]) => { + reloadGUI("CPUs"); + }); } }} /> { - console.log("Boost is now " + boost.toString()); - python.execute(python.setCPUBoost(boost)); - python.resolve(python.getCPUBoost(), setBoost); - }} - /> - - - { - console.log("CPU slider is now " + freq.toString()); - if (freq != freqGlobal) { - python.execute(python.setMaxBoost(freq)); - python.resolve(python.getMaxBoost(), setFreq); + checked={get_value(CLOCK_MIN_CPU) != null && get_value(CLOCK_MAX_CPU) != null} + label="Frequency Limits" + onChange={(value: boolean) => { + if (value) { + set_value(CLOCK_MIN_CPU, 1400); + set_value(CLOCK_MAX_CPU, 3500); + reloadGUI("CPUFreqToggle"); + } else { + set_value(CLOCK_MIN_CPU, null); + set_value(CLOCK_MAX_CPU, null); + for (let i = 0; i < total_cpus; i++) { + backend.resolve(backend.unsetCpuClockLimits(i), (_idc: any[]) => {}); + } + backend.resolve(backend.waitForComplete(), (_: boolean[]) => { + reloadGUI("CPUUnsetFreq"); + }); } }} /> + + {get_value(CLOCK_MIN_CPU) != null && { + console.debug("Min freq slider is now " + freq.toString()); + const freqNow = get_value(CLOCK_MIN_CPU); + if (freq != freqNow) { + for (let i = 0; i < total_cpus; i++) { + backend.resolve(backend.setCpuClockLimits(i, freq, get_value(CLOCK_MAX_CPU)), + (limits: number[]) => { + set_value(CLOCK_MIN_CPU, limits[0]); + set_value(CLOCK_MAX_CPU, limits[1]); + }); + } + backend.resolve(backend.waitForComplete(), (_: boolean[]) => { + reloadGUI("CPUMinFreq"); + }); + } + }} + />} + + + {get_value(CLOCK_MAX_CPU) != null && { + console.debug("Max freq slider is now " + freq.toString()); + const freqNow = get_value(CLOCK_MAX_CPU); + if (freq != freqNow) { + for (let i = 0; i < total_cpus; i++) { + backend.resolve(backend.setCpuClockLimits(i, get_value(CLOCK_MIN_CPU), freq), + (limits: number[]) => { + set_value(CLOCK_MIN_CPU, limits[0]); + set_value(CLOCK_MAX_CPU, limits[1]); + }); + } + backend.resolve(backend.waitForComplete(), (_: boolean[]) => { + reloadGUI("CPUMaxFreq"); + }); + } + }} + />} + + {/* TODO: CPU governor */} {/* GPU */}
GPU
- {/* index: 1 */} - { - console.log("SlowPPT is now " + ppt.toString()); - if (ppt != slowPPTGlobal) { - python.execute(python.setGPUPowerI(ppt, 1)); - python.resolve(python.getGPUPowerI(1), setSlowPPT); + { + if (value) { + set_value(SLOW_PPT_GPU, 15000000); + set_value(FAST_PPT_GPU, 15000000); + reloadGUI("GPUPPTToggle"); + } else { + set_value(SLOW_PPT_GPU, null); + set_value(FAST_PPT_GPU, null); + backend.resolve(backend.unsetGpuPpt(), (_: any[]) => { + reloadGUI("GPUUnsetPPT"); + }); } }} /> - {/* index: 2 */} - { - console.log("FastPPT is now " + ppt.toString()); - if (ppt != fastPPTGlobal) { - python.execute(python.setGPUPowerI(ppt, 2)); - python.resolve(python.getGPUPowerI(2), setFastPPT); + console.debug("SlowPPT is now " + ppt.toString()); + const pptNow = get_value(SLOW_PPT_GPU); + if (ppt != pptNow) { + backend.resolve(backend.setGpuPpt(get_value(FAST_PPT_GPU), ppt), + (limits: number[]) => { + set_value(FAST_PPT_GPU, limits[0]); + set_value(SLOW_PPT_GPU, limits[1]); + reloadGUI("GPUSlowPPT"); + }); } }} + />} + + + {get_value(FAST_PPT_GPU) != null && { + console.debug("FastPPT is now " + ppt.toString()); + const pptNow = get_value(FAST_PPT_GPU); + if (ppt != pptNow) { + backend.resolve(backend.setGpuPpt(get_value(SLOW_PPT_GPU), ppt), + (limits: number[]) => { + set_value(FAST_PPT_GPU, limits[0]); + set_value(SLOW_PPT_GPU, limits[1]); + reloadGUI("GPUFastPPT"); + }); + } + }} + />} + + + { + if (value) { + set_value(CLOCK_MIN_GPU, 200); + set_value(CLOCK_MAX_GPU, 1600); + reloadGUI("GPUFreqToggle"); + } else { + set_value(CLOCK_MIN_GPU, null); + set_value(CLOCK_MIN_GPU, null); + backend.resolve(backend.unsetGpuClockLimits(), (_: any[]) => { + reloadGUI("GPUUnsetFreq"); + }); + } + }} + /> + + + { get_value(CLOCK_MIN_GPU) != null && { + console.debug("GPU Clock Min is now " + val.toString()); + const valNow = get_value(CLOCK_MIN_GPU); + if (val != valNow) { + backend.resolve(backend.setGpuClockLimits(val, get_value(CLOCK_MAX_GPU)), + (limits: number[]) => { + set_value(CLOCK_MIN_GPU, limits[0]); + set_value(CLOCK_MAX_GPU, limits[1]); + reloadGUI("GPUMinClock"); + }); + } + }} + />} + + + {get_value(CLOCK_MAX_GPU) != null && { + console.debug("GPU Clock Max is now " + val.toString()); + const valNow = get_value(CLOCK_MAX_GPU); + if (val != valNow) { + backend.resolve(backend.setGpuClockLimits(get_value(CLOCK_MIN_GPU), val), + (limits: number[]) => { + set_value(CLOCK_MIN_GPU, limits[0]); + set_value(CLOCK_MAX_GPU, limits[1]); + reloadGUI("GPUMaxClock"); + }); + } + }} + />} + + + { + backend.resolve(backend.setGpuSlowMemory(value), (val: boolean) => { + set_value(SLOW_MEMORY_GPU, val); + reloadGUI("GPUSlowMemory"); + }) + }} /> {/* Battery */}
Battery
- + { false &&
Now (Charge)
- {(7.7 * chargeNowGlobal / 1000000).toFixed(1).toString() + " Wh (" + (100 * chargeNowGlobal / chargeFullGlobal).toFixed(1).toString() + "%)"} + {/* TODO: (7.7 * chargeNowGlobal / 1000000).toFixed(1).toString() + " Wh (" + (100 * chargeNowGlobal / chargeFullGlobal).toFixed(1).toString() + "%)"*/}
- - + } + { false &&
Max (Design)
- {(7.7 * chargeFullGlobal / 1000000).toFixed(1).toString() + " Wh (" + (100 * chargeFullGlobal / chargeDesignGlobal).toFixed(1).toString() + "%)"} + {/* TODO: (7.7 * chargeFullGlobal / 1000000).toFixed(1).toString() + " Wh (" + (100 * chargeFullGlobal / chargeDesignGlobal).toFixed(1).toString() + "%)"*/} +
+
+
+ } + + { + if (value) { + set_value(CHARGE_RATE_BATT, 2500); + reloadGUI("BATTChargeRateToggle"); + } else { + set_value(CHARGE_RATE_BATT, null); + backend.resolve(backend.unsetBatteryChargeRate(), (_: any[]) => { + reloadGUI("BATTUnsetChargeRate"); + }); + } + }} + /> + { get_value(CHARGE_RATE_BATT) != null && { + console.debug("Charge rate is now " + val.toString()); + const rateNow = get_value(CHARGE_RATE_BATT); + if (val != rateNow) { + backend.resolve(backend.setBatteryChargeRate(val), + (rate: number) => { + set_value(CHARGE_RATE_BATT, rate); + reloadGUI("BATTChargeRate"); + }); + } + }} + />} + + +
+
+
+ Current +
+
+ {get_value(CURRENT_BATT)} mA
{/* Persistence */} +
+ Miscellaneous +
{ - console.log("Persist is now " + persist.toString()); - python.execute(python.setPersistent(persist)); - python.resolve(python.getPersistent(), setPersist); - }} - /> - - - { - console.log("Per game profile is now " + p.toString()); - python.execute(python.setPerGameProfile(p)); - python.resolve(python.getPerGameProfile(), setPerGameProfile); - reload(); + console.debug("Persist is now " + persist.toString()); + backend.resolve( + backend.setGeneralPersistent(persist), + (val: boolean) => {set_value(PERSISTENT_GEN, val)} + ); }} /> @@ -374,12 +542,12 @@ const Content: VFC<{ serverAPI: ServerAPI }> = ({serverAPI}) => { Now Playing
- {gameGlobal} + {get_value(NAME_GEN)}
- {/* Version */} + {/* Version Info */}
Debug
@@ -387,68 +555,75 @@ const Content: VFC<{ serverAPI: ServerAPI }> = ({serverAPI}) => {
- PowerTools + Native
- v{versionGlobal} + {get_value(BACKEND_INFO)}
+ +
+
+
+ Framework +
+
+ {target_usdpl()} +
+
+
+ + +
+
+
+ USDPL +
+
+ v{version_usdpl()} +
+
+
+ + + { + console.debug("Loading default PowerTools settings"); + backend.resolve( + backend.setGeneralPersistent(false), + (val: boolean) => { + set_value(PERSISTENT_GEN, val); + backend.resolve(backend.loadGeneralDefaultSettings(), (_: any[]) => { + reload(); + backend.resolve(backend.waitForComplete(), (_: any[]) => {reloadGUI("LoadDefaults")}); + }); + } + ); + }} + > + Defaults + + ); }; -const DeckyPluginRouterTest: VFC = () => { - return ( -
- Hello World! - {}}> - Go to Store - -
- ); -}; - export default definePlugin((serverApi: ServerAPI) => { - serverApi.routerHook.addRoute("/decky-plugin-test", DeckyPluginRouterTest, { - exact: true, - }); - - python.setServer(serverApi); - - //@ts-ignore - lifetimeHook = SteamClient.GameSessions.RegisterForAppLifetimeNotifications((update) => { - if (update.bRunning) { - console.log("AppID " + update.unAppID.toString() + " is now running"); - } else { - console.log("AppID " + update.unAppID.toString() + " is no longer running"); - python.execute(python.onGameStop(null)); - } - }); - //@ts-ignore - startHook = SteamClient.Apps.RegisterForGameActionStart((actionType, id) => { - //@ts-ignore - let gameInfo: any = appStore.GetAppOverviewByGameID(id); - python.execute(python.onGameStart(id, gameInfo)); - }); - - console.log("Registered PowerTools callbacks, hello!"); - return { title:
PowerTools
, content: , icon: , onDismount() { - console.log("PowerTools shutting down"); + console.debug("PowerTools shutting down"); clearInterval(periodicHook!); periodicHook = null; lifetimeHook!.unregister(); startHook!.unregister(); serverApi.routerHook.removeRoute("/decky-plugin-test"); - firstTime = true; - lastGame = ""; - console.log("Unregistered PowerTools callbacks, goodbye."); + console.debug("Unregistered PowerTools callbacks, goodbye."); }, }; }); diff --git a/src/usdpl_front/README.md b/src/usdpl_front/README.md new file mode 100644 index 0000000..fd771f8 --- /dev/null +++ b/src/usdpl_front/README.md @@ -0,0 +1,9 @@ +[![Crates.io](https://img.shields.io/crates/v/usdpl-front?style=flat-square)](https://crates.io/crates/usdpl-front) + +# usdpl-front-front + +Front-end library to be called from Javascript. +Targets WASM. + +In true Javascript tradition, this part of the library does not support error handling. + diff --git a/src/usdpl_front/package.json b/src/usdpl_front/package.json index bd572fc..fd8c535 100644 --- a/src/usdpl_front/package.json +++ b/src/usdpl_front/package.json @@ -4,7 +4,7 @@ "NGnius (Graham) " ], "description": "Universal Steam Deck Plugin Library front-end designed for WASM", - "version": "0.6.0", + "version": "0.6.2", "license": "GPL-3.0-only", "repository": { "type": "git", diff --git a/src/usdpl_front/usdpl_front.d.ts b/src/usdpl_front/usdpl_front.d.ts index 5ca612b..b986bed 100644 --- a/src/usdpl_front/usdpl_front.d.ts +++ b/src/usdpl_front/usdpl_front.d.ts @@ -9,7 +9,25 @@ export function init_usdpl(port: number): void; * Get the targeted plugin framework, or "any" if unknown * @returns {string} */ -export function target(): string; +export function target_usdpl(): string; +/** +* Get the UDSPL front-end version +* @returns {string} +*/ +export function version_usdpl(): string; +/** +* Get the targeted plugin framework, or "any" if unknown +* @param {string} key +* @param {any} value +* @returns {any} +*/ +export function set_value(key: string, value: any): any; +/** +* Get the targeted plugin framework, or "any" if unknown +* @param {string} key +* @returns {any} +*/ +export function get_value(key: string): any; /** * Call a function on the back-end. * Returns null (None) if this fails for any reason. @@ -24,7 +42,10 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl export interface InitOutput { readonly memory: WebAssembly.Memory; readonly init_usdpl: (a: number) => void; - readonly target: (a: number) => void; + readonly target_usdpl: (a: number) => void; + readonly version_usdpl: (a: number) => void; + readonly set_value: (a: number, b: number, c: number) => number; + readonly get_value: (a: number, b: number) => number; readonly call_backend: (a: number, b: number, c: number, d: number) => number; readonly __wbindgen_export_0: (a: number) => number; readonly __wbindgen_export_1: (a: number, b: number, c: number) => number; diff --git a/src/usdpl_front/usdpl_front.js b/src/usdpl_front/usdpl_front.js index 0610e88..98ebff0 100644 --- a/src/usdpl_front/usdpl_front.js +++ b/src/usdpl_front/usdpl_front.js @@ -21,6 +21,15 @@ function takeObject(idx) { return ret; } +function addHeapObject(obj) { + if (heap_next === heap.length) heap.push(heap.length + 1); + const idx = heap_next; + heap_next = heap[idx]; + + heap[idx] = obj; + return idx; +} + let WASM_VECTOR_LEN = 0; let cachedUint8Memory0; @@ -104,15 +113,6 @@ function getStringFromWasm0(ptr, len) { return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len)); } -function addHeapObject(obj) { - if (heap_next === heap.length) heap.push(heap.length + 1); - const idx = heap_next; - heap_next = heap[idx]; - - heap[idx] = obj; - return idx; -} - let cachedFloat64Memory0; function getFloat64Memory0() { if (cachedFloat64Memory0.byteLength === 0) { @@ -161,10 +161,10 @@ export function init_usdpl(port) { * Get the targeted plugin framework, or "any" if unknown * @returns {string} */ -export function target() { +export function target_usdpl() { try { const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); - wasm.target(retptr); + wasm.target_usdpl(retptr); var r0 = getInt32Memory0()[retptr / 4 + 0]; var r1 = getInt32Memory0()[retptr / 4 + 1]; return getStringFromWasm0(r0, r1); @@ -174,6 +174,48 @@ export function target() { } } +/** +* Get the UDSPL front-end version +* @returns {string} +*/ +export function version_usdpl() { + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.version_usdpl(retptr); + var r0 = getInt32Memory0()[retptr / 4 + 0]; + var r1 = getInt32Memory0()[retptr / 4 + 1]; + return getStringFromWasm0(r0, r1); + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + wasm.__wbindgen_export_4(r0, r1); + } +} + +/** +* Get the targeted plugin framework, or "any" if unknown +* @param {string} key +* @param {any} value +* @returns {any} +*/ +export function set_value(key, value) { + const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.set_value(ptr0, len0, addHeapObject(value)); + return takeObject(ret); +} + +/** +* Get the targeted plugin framework, or "any" if unknown +* @param {string} key +* @returns {any} +*/ +export function get_value(key) { + const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.get_value(ptr0, len0); + return takeObject(ret); +} + let cachedUint32Memory0; function getUint32Memory0() { if (cachedUint32Memory0.byteLength === 0) { @@ -214,7 +256,7 @@ function handleError(f, args) { wasm.__wbindgen_export_5(addHeapObject(e)); } } -function __wbg_adapter_54(arg0, arg1, arg2, arg3) { +function __wbg_adapter_57(arg0, arg1, arg2, arg3) { wasm.__wbindgen_export_6(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3)); } @@ -255,6 +297,10 @@ function getImports() { imports.wbg.__wbindgen_object_drop_ref = function(arg0) { takeObject(arg0); }; + imports.wbg.__wbindgen_object_clone_ref = function(arg0) { + const ret = getObject(arg0); + return addHeapObject(ret); + }; imports.wbg.__wbindgen_string_get = function(arg0, arg1) { const obj = getObject(arg1); const ret = typeof(obj) === 'string' ? obj : undefined; @@ -317,10 +363,6 @@ function getImports() { const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2)); return addHeapObject(ret); }, arguments) }; - imports.wbg.__wbindgen_object_clone_ref = function(arg0) { - const ret = getObject(arg0); - return addHeapObject(ret); - }; imports.wbg.__wbindgen_cb_drop = function(arg0) { const obj = takeObject(arg0).original; if (obj.cnt-- == 1) { @@ -380,7 +422,7 @@ function getImports() { const a = state0.a; state0.a = 0; try { - return __wbg_adapter_54(a, state0.b, arg0, arg1); + return __wbg_adapter_57(a, state0.b, arg0, arg1); } finally { state0.a = a; } @@ -418,8 +460,8 @@ function getImports() { imports.wbg.__wbindgen_throw = function(arg0, arg1) { throw new Error(getStringFromWasm0(arg0, arg1)); }; - imports.wbg.__wbindgen_closure_wrapper631 = function(arg0, arg1, arg2) { - const ret = makeMutClosure(arg0, arg1, 71, __wbg_adapter_26); + imports.wbg.__wbindgen_closure_wrapper336 = function(arg0, arg1, arg2) { + const ret = makeMutClosure(arg0, arg1, 66, __wbg_adapter_26); return addHeapObject(ret); }; @@ -475,7 +517,7 @@ export default init; // USDPL customization -const encoded = "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"; +const encoded = "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"; function asciiToBinary(str) { if (typeof atob === 'function') { diff --git a/src/usdpl_front/usdpl_front_bg.wasm b/src/usdpl_front/usdpl_front_bg.wasm index 8c70a8b..d63284b 100644 Binary files a/src/usdpl_front/usdpl_front_bg.wasm and b/src/usdpl_front/usdpl_front_bg.wasm differ diff --git a/src/usdpl_front/usdpl_front_bg.wasm.d.ts b/src/usdpl_front/usdpl_front_bg.wasm.d.ts index 357dc02..1e96bc2 100644 --- a/src/usdpl_front/usdpl_front_bg.wasm.d.ts +++ b/src/usdpl_front/usdpl_front_bg.wasm.d.ts @@ -2,7 +2,10 @@ /* eslint-disable */ export const memory: WebAssembly.Memory; export function init_usdpl(a: number): void; -export function target(a: number): void; +export function target_usdpl(a: number): void; +export function version_usdpl(a: number): void; +export function set_value(a: number, b: number, c: number): number; +export function get_value(a: number, b: number): number; export function call_backend(a: number, b: number, c: number, d: number): number; export function __wbindgen_export_0(a: number): number; export function __wbindgen_export_1(a: number, b: number, c: number): number;