use core::time::Duration;
use std::sync::OnceLock;
use crate::{Percent, Result};
#[derive(Clone, Copy, Debug, PartialEq)]
#[non_exhaustive]
pub struct Battery {
pub charge: Percent,
pub state: BatteryState,
pub time_to_empty: Option<Duration>,
pub time_to_full: Option<Duration>,
pub health: Option<Percent>,
pub cycles: Option<u32>,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[non_exhaustive]
pub enum BatteryState {
Charging,
Discharging,
Full,
NotCharging,
Unknown,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub(crate) struct RawBattery {
pub(crate) battery: Battery,
pub(crate) energy: Option<(u64, u64)>,
}
#[must_use]
pub fn has_battery() -> bool {
static FACT: OnceLock<bool> = OnceLock::new();
*FACT.get_or_init(crate::sys::has_battery)
}
pub fn battery() -> Result<Option<Battery>> {
Ok(combine(&crate::sys::batteries()?))
}
pub fn batteries() -> Result<Vec<Battery>> {
Ok(crate::sys::batteries()?.iter().map(|b| b.battery).collect())
}
pub fn on_ac() -> Result<Option<bool>> {
crate::sys::on_ac()
}
pub(crate) fn combine(all: &[RawBattery]) -> Option<Battery> {
let (first, rest) = all.split_first()?;
if rest.is_empty() {
return Some(first.battery);
}
let energies: Option<Vec<(u64, u64)>> = all.iter().map(|b| b.energy).collect();
let charge = match energies {
Some(e) => {
let now: u128 = e.iter().map(|&(n, _)| u128::from(n)).sum();
let full: u128 = e.iter().map(|&(_, f)| u128::from(f)).sum();
if full == 0 {
first.battery.charge
} else {
Percent::from_ratio_u128(now, full)
}
}
None => {
let sum: f32 = all.iter().map(|b| b.battery.charge.value()).sum();
Percent::from_value(sum / all.len() as f32)
}
};
let state = combined_state(all);
let total = |pick: fn(&Battery) -> Option<Duration>| {
all.iter()
.map(|b| pick(&b.battery))
.try_fold(Duration::ZERO, |sum, t| Some(sum.saturating_add(t?)))
};
Some(Battery {
charge,
state,
time_to_empty: total(|b| b.time_to_empty),
time_to_full: all.iter().filter_map(|b| b.battery.time_to_full).max(),
health: None,
cycles: None,
})
}
fn combined_state(all: &[RawBattery]) -> BatteryState {
let any = |s: BatteryState| all.iter().any(|b| b.battery.state == s);
if any(BatteryState::Charging) {
BatteryState::Charging
} else if any(BatteryState::Discharging) {
BatteryState::Discharging
} else if all.iter().all(|b| b.battery.state == BatteryState::Full) {
BatteryState::Full
} else if any(BatteryState::NotCharging) {
BatteryState::NotCharging
} else {
BatteryState::Unknown
}
}
#[cfg(test)]
mod tests {
use super::*;
fn raw(charge: f32, state: BatteryState, energy: Option<(u64, u64)>) -> RawBattery {
RawBattery {
battery: Battery {
charge: Percent::from_value(charge),
state,
time_to_empty: Some(Duration::from_secs(600)),
time_to_full: None,
health: Some(Percent::from_value(90.0)),
cycles: Some(10),
},
energy,
}
}
#[test]
fn test_power_combine_by_energy_not_percentage() {
let c = combine(&[
raw(99.0, BatteryState::Discharging, Some((99, 100))),
raw(10.0, BatteryState::Discharging, Some((1, 10))),
])
.unwrap();
assert_eq!(c.charge.to_string(), "90.9%");
assert_eq!(c.state, BatteryState::Discharging);
assert_eq!(c.time_to_empty, Some(Duration::from_secs(1200)));
assert_eq!((c.health, c.cycles), (None, None));
}
#[test]
fn test_power_combine_edge_cases() {
assert_eq!(combine(&[]), None);
let one = raw(40.0, BatteryState::Charging, None);
assert_eq!(combine(&[one]), Some(one.battery));
let c = combine(&[
raw(40.0, BatteryState::Full, None),
raw(60.0, BatteryState::Full, None),
])
.unwrap();
assert_eq!(c.charge.to_string(), "50.0%");
assert_eq!(c.state, BatteryState::Full);
let c = combine(&[
raw(0.0, BatteryState::Unknown, Some((0, 0))),
raw(0.0, BatteryState::NotCharging, Some((0, 0))),
])
.unwrap();
assert_eq!(c.state, BatteryState::NotCharging);
}
#[test]
fn test_power_live_never_fails_oddly() {
let _ = has_battery();
if let Ok(Some(b)) = battery() {
assert!(b.charge <= Percent::FULL);
}
let _ = on_ac();
}
}