use crate::error::IronError;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum PowerProfile {
Performance,
Balanced,
PowerSaver,
UltraPowerSaver,
Custom(String),
Unknown,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum CpuGovernor {
Performance,
Powersave,
Ondemand,
Conservative,
Schedutil,
Userspace,
Other(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum ChargePolicy {
Full,
Threshold(u8),
Adaptive,
NoBattery,
Unknown,
}
const POWER_CONFIDENCE_BASE: f32 = 0.5;
const POWER_CONFIDENCE_STEP_PERFORMANCE_GOVERNOR: f32 = 0.15;
const POWER_CONFIDENCE_STEP_POWERSAVE_GOVERNOR: f32 = 0.15;
const POWER_CONFIDENCE_STEP_SCHEDUTIL_GOVERNOR: f32 = 0.1;
const POWER_CONFIDENCE_STEP_ONDEMAND_GOVERNOR: f32 = 0.1;
const POWER_CONFIDENCE_STEP_CHARGE_THRESHOLD: f32 = 0.05;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InferredPowerBehavior {
pub classification: PowerProfile,
pub confidence: Option<f32>,
pub estimated_idle_watts: Option<f32>,
pub estimated_max_watts: Option<f32>,
pub efficiency_score: Option<u8>,
pub recommendations: Vec<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PowerPlanInfo {
pub guid: String,
pub name: String,
pub active: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CpuFreqConfig {
pub governor: Option<CpuGovernor>,
pub current_freq_mhz: Option<u32>,
pub min_freq_mhz: Option<u32>,
pub max_freq_mhz: Option<u32>,
pub base_freq_mhz: Option<u32>,
pub boost_enabled: Option<bool>,
pub energy_perf_preference: Option<String>,
}
pub struct PowerProfileMonitor {
active_profile: PowerProfile,
power_plans: Vec<PowerPlanInfo>,
cpu_freq: Option<CpuFreqConfig>,
charge_policy: ChargePolicy,
inferred: Option<InferredPowerBehavior>,
pub on_ac_power: Option<bool>,
pub display_brightness: Option<u8>,
pub sleep_timeout_secs: Option<u32>,
pub disk_standby_secs: Option<u32>,
}
impl PowerProfileMonitor {
pub fn new() -> Result<Self, IronError> {
let mut monitor = Self {
active_profile: PowerProfile::Unknown,
power_plans: Vec::new(),
cpu_freq: None,
charge_policy: ChargePolicy::Unknown,
inferred: None,
on_ac_power: None,
display_brightness: None,
sleep_timeout_secs: None,
disk_standby_secs: None,
};
monitor.refresh()?;
Ok(monitor)
}
pub fn refresh(&mut self) -> Result<(), IronError> {
self.power_plans.clear();
#[cfg(target_os = "linux")]
self.refresh_linux()?;
#[cfg(target_os = "windows")]
self.refresh_windows()?;
#[cfg(target_os = "macos")]
self.refresh_macos()?;
self.inferred = Some(self.infer_behavior());
Ok(())
}
pub fn active_profile(&self) -> &PowerProfile {
&self.active_profile
}
pub fn power_plans(&self) -> &[PowerPlanInfo] {
&self.power_plans
}
pub fn cpu_freq_config(&self) -> Option<&CpuFreqConfig> {
self.cpu_freq.as_ref()
}
pub fn charge_policy(&self) -> &ChargePolicy {
&self.charge_policy
}
pub fn inferred_behavior(&self) -> Option<&InferredPowerBehavior> {
self.inferred.as_ref()
}
fn infer_behavior(&self) -> InferredPowerBehavior {
let any_input_read = self.cpu_freq.is_some()
|| self.active_profile != PowerProfile::Unknown
|| self.on_ac_power.is_some()
|| self.charge_policy != ChargePolicy::Unknown
|| self.display_brightness.is_some();
if !any_input_read {
return InferredPowerBehavior {
classification: PowerProfile::Unknown,
confidence: None,
estimated_idle_watts: None,
estimated_max_watts: None,
efficiency_score: None,
recommendations: Vec::new(),
};
}
let mut score = 50u8; let mut confidence = POWER_CONFIDENCE_BASE;
let mut recommendations = Vec::new();
if let Some(ref freq) = self.cpu_freq {
match freq.governor.as_ref() {
Some(CpuGovernor::Performance) => {
score = score.saturating_sub(20); confidence += POWER_CONFIDENCE_STEP_PERFORMANCE_GOVERNOR;
}
Some(CpuGovernor::Powersave) => {
score = score.saturating_add(20);
confidence += POWER_CONFIDENCE_STEP_POWERSAVE_GOVERNOR;
}
Some(CpuGovernor::Schedutil) => {
score = score.saturating_add(10); confidence += POWER_CONFIDENCE_STEP_SCHEDUTIL_GOVERNOR;
}
Some(CpuGovernor::Ondemand) => {
score = score.saturating_add(5);
confidence += POWER_CONFIDENCE_STEP_ONDEMAND_GOVERNOR;
}
_ => {}
}
if freq.boost_enabled == Some(true) {
score = score.saturating_sub(5);
if self.on_ac_power == Some(false) {
recommendations.push(
"Consider disabling CPU boost on battery for better battery life".into(),
);
}
}
if let (Some(min), Some(max)) = (freq.min_freq_mhz, freq.max_freq_mhz) {
let ratio = if max > 0 {
min as f32 / max as f32
} else {
0.0
};
if ratio > 0.8 {
score = score.saturating_sub(10);
recommendations.push(
"CPU minimum frequency is high — consider lowering for power savings"
.into(),
);
}
}
match freq.energy_perf_preference.as_deref() {
Some("performance") => score = score.saturating_sub(10),
Some("power") | Some("power_save") => score = score.saturating_add(10),
Some("balance_performance") => {}
Some("balance_power") => score = score.saturating_add(5),
_ => {}
}
}
if self.on_ac_power == Some(false) {
match &self.active_profile {
PowerProfile::Performance => {
recommendations.push(
"Running performance profile on battery — battery life will be reduced"
.into(),
);
score = score.saturating_sub(15);
}
PowerProfile::PowerSaver | PowerProfile::UltraPowerSaver => {
score = score.saturating_add(10);
}
_ => {}
}
}
match &self.charge_policy {
ChargePolicy::Threshold(t) if *t <= 80 => {
score = score.saturating_add(5);
confidence += POWER_CONFIDENCE_STEP_CHARGE_THRESHOLD;
}
ChargePolicy::Full => {
recommendations.push(
"Consider setting a charge threshold (e.g., 80%) to extend battery lifespan"
.into(),
);
}
_ => {}
}
if let Some(brightness) = self.display_brightness {
if brightness > 80 && self.on_ac_power == Some(false) {
recommendations.push(
"Display brightness is high on battery — consider reducing for power savings"
.into(),
);
score = score.saturating_sub(5);
}
}
let classification = if score >= 70 {
PowerProfile::PowerSaver
} else if score >= 40 {
PowerProfile::Balanced
} else {
PowerProfile::Performance
};
let (idle_watts, max_watts) = match &classification {
PowerProfile::Performance => (25.0, 250.0),
PowerProfile::Balanced => (15.0, 200.0),
PowerProfile::PowerSaver => (8.0, 150.0),
PowerProfile::UltraPowerSaver => (5.0, 100.0),
_ => (15.0, 200.0),
};
InferredPowerBehavior {
classification,
confidence: Some(confidence.min(1.0)),
estimated_idle_watts: Some(idle_watts),
estimated_max_watts: Some(max_watts),
efficiency_score: Some(score.min(100)),
recommendations,
}
}
#[cfg(target_os = "linux")]
fn refresh_linux(&mut self) -> Result<(), IronError> {
let governor =
std::fs::read_to_string("/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor")
.ok()
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.map(|gov| match gov.as_str() {
"performance" => CpuGovernor::Performance,
"powersave" => CpuGovernor::Powersave,
"ondemand" => CpuGovernor::Ondemand,
"conservative" => CpuGovernor::Conservative,
"schedutil" => CpuGovernor::Schedutil,
"userspace" => CpuGovernor::Userspace,
other => CpuGovernor::Other(other.to_string()),
});
let cur_freq =
std::fs::read_to_string("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq")
.ok()
.and_then(|s| s.trim().parse::<u32>().ok())
.map(|khz| khz / 1000);
let min_freq =
std::fs::read_to_string("/sys/devices/system/cpu/cpu0/cpufreq/scaling_min_freq")
.ok()
.and_then(|s| s.trim().parse::<u32>().ok())
.map(|khz| khz / 1000);
let max_freq =
std::fs::read_to_string("/sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq")
.ok()
.and_then(|s| s.trim().parse::<u32>().ok())
.map(|khz| khz / 1000);
let base_freq =
std::fs::read_to_string("/sys/devices/system/cpu/cpu0/cpufreq/base_frequency")
.ok()
.and_then(|s| s.trim().parse::<u32>().ok())
.map(|f| f / 1000);
let boost_enabled = std::fs::read_to_string("/sys/devices/system/cpu/cpufreq/boost")
.ok()
.and_then(|s| match s.trim() {
"1" => Some(true),
"0" => Some(false),
_ => None,
})
.or_else(|| {
std::fs::read_to_string("/sys/devices/system/cpu/intel_pstate/no_turbo")
.ok()
.and_then(|s| match s.trim() {
"0" => Some(true),
"1" => Some(false),
_ => None,
})
});
let epp = std::fs::read_to_string(
"/sys/devices/system/cpu/cpu0/cpufreq/energy_performance_preference",
)
.ok()
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty());
let any_cpufreq_read = governor.is_some()
|| cur_freq.is_some()
|| min_freq.is_some()
|| max_freq.is_some()
|| base_freq.is_some()
|| boost_enabled.is_some()
|| epp.is_some();
self.cpu_freq = if any_cpufreq_read {
Some(CpuFreqConfig {
governor,
current_freq_mhz: cur_freq,
min_freq_mhz: min_freq,
max_freq_mhz: max_freq,
base_freq_mhz: base_freq,
boost_enabled,
energy_perf_preference: epp,
})
} else {
None
};
let from_ppd = std::process::Command::new("powerprofilesctl")
.arg("get")
.output()
.ok()
.and_then(|o| String::from_utf8(o.stdout).ok())
.and_then(|s| match s.trim() {
"performance" => Some(PowerProfile::Performance),
"balanced" => Some(PowerProfile::Balanced),
"power-saver" => Some(PowerProfile::PowerSaver),
_ => None,
});
let from_platform = std::fs::read_to_string("/sys/firmware/acpi/platform_profile")
.ok()
.and_then(|s| match s.trim() {
"performance" => Some(PowerProfile::Performance),
"balanced" => Some(PowerProfile::Balanced),
"low-power" => Some(PowerProfile::PowerSaver),
_ => None,
});
self.active_profile = from_ppd.or(from_platform).unwrap_or(PowerProfile::Unknown);
if let Ok(entries) = std::fs::read_dir("/sys/class/power_supply") {
let mut mains_online = Vec::new();
for e in entries.flatten() {
let path = e.path();
if let Ok(ptype) = std::fs::read_to_string(path.join("type")) {
if ptype.trim() == "Mains" {
if let Ok(online) = std::fs::read_to_string(path.join("online")) {
mains_online.push(match online.trim() {
"1" => Some(true),
"0" => Some(false),
_ => None,
});
}
}
}
}
self.on_ac_power = combine_mains_online(&mains_online);
}
let threshold_paths = [
"/sys/class/power_supply/BAT0/charge_control_end_threshold",
"/sys/class/power_supply/BAT1/charge_control_end_threshold",
];
for path in &threshold_paths {
if let Ok(val) = std::fs::read_to_string(path) {
if let Ok(t) = val.trim().parse::<u8>() {
self.charge_policy = if t >= 100 {
ChargePolicy::Full
} else {
ChargePolicy::Threshold(t)
};
break;
}
}
}
if let Some(entry) = std::fs::read_dir("/sys/class/backlight")
.ok()
.and_then(|mut entries| entries.next())
.and_then(|e| e.ok())
{
let path = entry.path();
let cur = std::fs::read_to_string(path.join("brightness"))
.ok()
.and_then(|s| s.trim().parse::<u32>().ok());
let max = std::fs::read_to_string(path.join("max_brightness"))
.ok()
.and_then(|s| s.trim().parse::<u32>().ok());
if let (Some(c), Some(m)) = (cur, max) {
if m > 0 {
self.display_brightness = Some(((c as f32 / m as f32) * 100.0) as u8);
}
}
}
Ok(())
}
#[cfg(target_os = "windows")]
fn refresh_windows(&mut self) -> Result<(), IronError> {
{
let text = crate::core::command::capture("powercfg", &["/list"])?;
for line in text.lines() {
if line.contains("GUID:") {
let active = line.ends_with('*');
if let Some(guid_start) = line.find("GUID:") {
let after = &line[guid_start + 6..];
let guid = after.split_whitespace().next().unwrap_or("").to_string();
if guid.is_empty() {
continue;
}
let name = after
.split('(')
.nth(1)
.and_then(|s| s.split(')').next())
.unwrap_or("")
.to_string();
if active {
self.active_profile =
if name.to_lowercase().contains("high performance")
|| name.to_lowercase().contains("ultimate")
{
PowerProfile::Performance
} else if name.to_lowercase().contains("power saver") {
PowerProfile::PowerSaver
} else if name.to_lowercase().contains("balanced") {
PowerProfile::Balanced
} else if name.is_empty() {
PowerProfile::Unknown
} else {
PowerProfile::Custom(name.clone())
};
}
self.power_plans.push(PowerPlanInfo { guid, name, active });
}
}
}
}
{
use windows::Win32::System::Power::{GetSystemPowerStatus, SYSTEM_POWER_STATUS};
let mut status = SYSTEM_POWER_STATUS::default();
if unsafe { GetSystemPowerStatus(&mut status) }.is_ok() {
self.on_ac_power = match status.ACLineStatus {
0 => Some(false),
1 => Some(true),
_ => None,
};
}
}
if let Ok(output) = std::process::Command::new("powershell")
.args(["-NoProfile", "-Command",
"(Get-CimInstance -Namespace root/WMI -ClassName WmiMonitorBrightness).CurrentBrightness"])
.output()
{
if let Ok(b) = String::from_utf8(output.stdout).unwrap_or_default().trim().parse::<u8>()
{
self.display_brightness = Some(b);
}
}
Ok(())
}
#[cfg(target_os = "macos")]
fn refresh_macos(&mut self) -> Result<(), IronError> {
{
let text = crate::core::command::capture("pmset", &["-g", "custom"])?;
let (sleep, disk_sleep) = parse_pmset_custom(&text);
self.sleep_timeout_secs = sleep;
self.disk_standby_secs = disk_sleep;
}
if let Ok(output) = std::process::Command::new("pmset").args(["-g"]).output() {
let text = String::from_utf8(output.stdout).unwrap_or_default();
let modes: Vec<&str> = text
.lines()
.filter_map(|l| {
let mut parts = l.split_whitespace();
if parts.next() == Some("lowpowermode") {
parts.next()
} else {
None
}
})
.collect();
self.active_profile = profile_from_pmset_modes(&modes);
}
self.on_ac_power = std::process::Command::new("pmset")
.args(["-g", "ps"])
.output()
.ok()
.and_then(|o| String::from_utf8(o.stdout).ok())
.and_then(|text| parse_pmset_power_source(&text));
Ok(())
}
}
#[cfg(any(target_os = "macos", test))]
fn parse_pmset_custom(text: &str) -> (Option<u32>, Option<u32>) {
let mut sleep = None;
let mut disk_sleep = None;
let mut in_ac_section = false;
for line in text.lines() {
let line = line.trim();
if line.starts_with("Battery Power:") {
in_ac_section = false;
} else if line.starts_with("AC Power:") {
in_ac_section = true;
}
if !in_ac_section {
continue;
}
let minutes = line
.split_whitespace()
.nth(1)
.and_then(|v| v.parse::<u32>().ok())
.map(|v| v.saturating_mul(60));
if line.starts_with("disksleep") {
disk_sleep = minutes.or(disk_sleep);
} else if line.starts_with("sleep") {
sleep = minutes.or(sleep);
}
}
(sleep, disk_sleep)
}
#[cfg(any(target_os = "macos", test))]
fn profile_from_pmset_modes(modes: &[&str]) -> PowerProfile {
if modes.contains(&"1") {
PowerProfile::PowerSaver
} else {
PowerProfile::Unknown
}
}
#[cfg_attr(not(target_os = "macos"), allow(dead_code))]
pub(crate) fn parse_pmset_power_source(text: &str) -> Option<bool> {
let line = text.lines().find(|l| l.contains("drawing from"))?;
if line.contains("'AC Power'") {
Some(true)
} else if line.contains("'Battery Power'") {
Some(false)
} else {
None
}
}
impl Default for PowerProfileMonitor {
fn default() -> Self {
Self::new().unwrap_or(Self {
active_profile: PowerProfile::Unknown,
power_plans: Vec::new(),
cpu_freq: None,
charge_policy: ChargePolicy::Unknown,
inferred: None,
on_ac_power: None,
display_brightness: None,
sleep_timeout_secs: None,
disk_standby_secs: None,
})
}
}
#[cfg(any(target_os = "linux", test))]
fn combine_mains_online(readings: &[Option<bool>]) -> Option<bool> {
if readings.contains(&Some(true)) {
Some(true)
} else if !readings.is_empty() && readings.iter().all(|r| *r == Some(false)) {
Some(false)
} else {
None
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn any_online_mains_supply_means_ac() {
assert_eq!(combine_mains_online(&[Some(true), Some(false)]), Some(true));
assert_eq!(combine_mains_online(&[Some(false), Some(true)]), Some(true));
assert_eq!(
combine_mains_online(&[Some(false), Some(false)]),
Some(false)
);
assert_eq!(combine_mains_online(&[Some(false), None]), None);
assert_eq!(combine_mains_online(&[]), None);
}
#[test]
fn test_power_profile_creation() {
match PowerProfileMonitor::new() {
Ok(_monitor) => {}
Err(e) => {
let why = e.to_string();
assert!(
why.len() > 10,
"enumeration failed without saying why: {why:?}"
);
}
}
}
#[test]
fn test_power_profile_default() {
let monitor = PowerProfileMonitor::default();
let _ = monitor.active_profile();
let _ = monitor.inferred_behavior();
let _ = monitor.charge_policy();
}
#[test]
fn test_inference_performance() {
let monitor = PowerProfileMonitor {
active_profile: PowerProfile::Performance,
power_plans: Vec::new(),
cpu_freq: Some(CpuFreqConfig {
governor: Some(CpuGovernor::Performance),
current_freq_mhz: Some(4500),
min_freq_mhz: Some(4000),
max_freq_mhz: Some(5000),
base_freq_mhz: Some(3700),
boost_enabled: Some(true),
energy_perf_preference: Some("performance".into()),
}),
charge_policy: ChargePolicy::Full,
inferred: None,
on_ac_power: Some(false), display_brightness: Some(100),
sleep_timeout_secs: None,
disk_standby_secs: None,
};
let behavior = monitor.infer_behavior();
assert!(behavior.efficiency_score.is_some_and(|s| s < 30)); assert!(!behavior.recommendations.is_empty());
}
#[test]
fn test_inference_powersaver() {
let monitor = PowerProfileMonitor {
active_profile: PowerProfile::PowerSaver,
power_plans: Vec::new(),
cpu_freq: Some(CpuFreqConfig {
governor: Some(CpuGovernor::Powersave),
current_freq_mhz: Some(800),
min_freq_mhz: Some(400),
max_freq_mhz: Some(3600),
base_freq_mhz: Some(2400),
boost_enabled: Some(false),
energy_perf_preference: Some("power".into()),
}),
charge_policy: ChargePolicy::Threshold(80),
inferred: None,
on_ac_power: Some(false),
display_brightness: Some(40),
sleep_timeout_secs: Some(300),
disk_standby_secs: Some(600),
};
let behavior = monitor.infer_behavior();
assert!(behavior.efficiency_score.is_some_and(|s| s > 60)); }
#[test]
fn test_inference_without_inputs_reports_no_figures() {
let monitor = PowerProfileMonitor {
active_profile: PowerProfile::Unknown,
power_plans: Vec::new(),
cpu_freq: None,
charge_policy: ChargePolicy::Unknown,
inferred: None,
on_ac_power: None,
display_brightness: None,
sleep_timeout_secs: None,
disk_standby_secs: None,
};
let behavior = monitor.infer_behavior();
assert_eq!(behavior.classification, PowerProfile::Unknown);
assert_eq!(behavior.confidence, None);
assert_eq!(behavior.estimated_idle_watts, None);
assert_eq!(behavior.estimated_max_watts, None);
assert_eq!(behavior.efficiency_score, None);
assert!(behavior.recommendations.is_empty());
}
#[test]
fn test_pmset_custom_reads_ac_section_only() {
let text = concat!(
"System-wide power settings:\n",
"AC Power:\n",
"sleep 30\n",
"disksleep 10\n",
"Battery Power:\n",
"sleep 2\n",
"disksleep 5\n",
);
assert_eq!(parse_pmset_custom(text), (Some(1800), Some(600)));
}
#[test]
fn test_pmset_custom_without_ac_section_is_unknown() {
let text = "Battery Power:\nsleep 2\ndisksleep 5\n";
assert_eq!(parse_pmset_custom(text), (None, None));
}
#[test]
fn test_pmset_lowpowermode_zero_is_not_balanced() {
assert_eq!(profile_from_pmset_modes(&["1"]), PowerProfile::PowerSaver);
assert_eq!(profile_from_pmset_modes(&["0"]), PowerProfile::Unknown);
assert_eq!(profile_from_pmset_modes(&[]), PowerProfile::Unknown);
}
#[test]
fn test_parse_pmset_power_source() {
let ac = "Now drawing from 'AC Power'\n -InternalBattery-0 (id=1234)\t100%; charged\n";
let battery =
"Now drawing from 'Battery Power'\n -InternalBattery-0 (id=1234)\t72%; discharging\n";
assert_eq!(parse_pmset_power_source(ac), Some(true));
assert_eq!(parse_pmset_power_source(battery), Some(false));
assert_eq!(parse_pmset_power_source(""), None);
assert_eq!(
parse_pmset_power_source("Some unrelated text 'AC Power'"),
None
);
assert_eq!(
parse_pmset_power_source("Now drawing from 'UPS Power'\n"),
None
);
}
#[test]
fn test_serialization() {
let plan = PowerPlanInfo {
guid: "381b4222-f694-41f0-9685-ff5bb260df2e".into(),
name: "Balanced".into(),
active: true,
};
let json = serde_json::to_string(&plan).unwrap();
let _: PowerPlanInfo = serde_json::from_str(&json).unwrap();
}
}