2020-08-11 16:04:25 +00:00
|
|
|
use std::cmp::PartialOrd;
|
|
|
|
|
2020-08-10 17:28:53 +00:00
|
|
|
use notify_rust::{Hint, Notification, Urgency};
|
2020-08-10 16:26:41 +00:00
|
|
|
|
2020-08-11 16:04:25 +00:00
|
|
|
#[derive(PartialEq, PartialOrd, Eq, Debug)]
|
2020-08-10 17:57:40 +00:00
|
|
|
pub enum VerbosityLevel {
|
|
|
|
None = 0,
|
|
|
|
Some = 1,
|
|
|
|
Lots = 2,
|
|
|
|
}
|
|
|
|
|
2020-08-11 16:04:25 +00:00
|
|
|
#[derive(Debug)]
|
2020-08-10 16:26:41 +00:00
|
|
|
pub struct BatteryState {
|
2020-08-10 17:28:53 +00:00
|
|
|
manager: battery::Manager,
|
|
|
|
battery: battery::Battery,
|
2020-08-10 17:57:40 +00:00
|
|
|
refresh_rate: u64,
|
|
|
|
|
2020-08-11 16:04:25 +00:00
|
|
|
low_level: u8,
|
|
|
|
very_low_level: u8,
|
|
|
|
critical_level: u8,
|
2020-08-10 17:57:40 +00:00
|
|
|
|
|
|
|
is_triggered_low: bool,
|
|
|
|
is_triggered_very_low: bool,
|
|
|
|
|
|
|
|
verbosity: VerbosityLevel,
|
2020-08-10 16:26:41 +00:00
|
|
|
}
|
|
|
|
|
2020-08-11 16:04:25 +00:00
|
|
|
pub const DEFAULT_LOW: u8 = 25_u8;
|
|
|
|
pub const DEFAULT_VERY_LOW: u8 = 15_u8;
|
|
|
|
pub const DEFAULT_CRITICAL: u8 = 10_u8;
|
2020-08-10 17:57:40 +00:00
|
|
|
pub const DEFAULT_REFRESH: u64 = 5;
|
2020-08-10 17:28:53 +00:00
|
|
|
|
2020-08-11 16:04:25 +00:00
|
|
|
macro_rules! trigger_warning {
|
|
|
|
($message:literal, $urgency:ident, $trigger:expr, $battery:expr, $verbosity:expr, $self:expr) => {
|
|
|
|
if $trigger {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
$trigger = true;
|
|
|
|
let level = ($battery.state_of_charge().value * 100_f32) as u8;
|
2020-08-12 21:19:37 +00:00
|
|
|
let message = format!(
|
|
|
|
$message,
|
|
|
|
$self.remaining_time($self.battery.time_to_full()),
|
|
|
|
level
|
|
|
|
);
|
|
|
|
if $verbosity >= VerbosityLevel::Some {
|
|
|
|
println!("{}", message);
|
2020-08-11 16:04:25 +00:00
|
|
|
}
|
|
|
|
Notification::new()
|
|
|
|
.summary("Low battery")
|
|
|
|
.body(message.as_str())
|
|
|
|
.hint(Hint::Category("battery".to_owned()))
|
|
|
|
.urgency($urgency)
|
|
|
|
.show()
|
|
|
|
.unwrap();
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2020-08-10 16:26:41 +00:00
|
|
|
impl BatteryState {
|
2020-08-11 16:04:25 +00:00
|
|
|
/// Create and initialize new `BatteryState` object
|
2020-08-10 17:28:53 +00:00
|
|
|
pub fn new(
|
2020-08-11 16:04:25 +00:00
|
|
|
low_level: u8,
|
|
|
|
mut very_low_level: u8,
|
|
|
|
mut critical_level: u8,
|
2020-08-10 17:57:40 +00:00
|
|
|
refresh_rate: u64,
|
|
|
|
verbosity: VerbosityLevel,
|
2020-08-10 17:28:53 +00:00
|
|
|
) -> battery::Result<Self> {
|
2020-08-12 21:19:37 +00:00
|
|
|
let manager = battery::Manager::new()?;
|
|
|
|
let battery = match manager.batteries()?.next() {
|
2020-08-10 16:26:41 +00:00
|
|
|
Some(Ok(battery)) => battery,
|
|
|
|
Some(Err(e)) => {
|
2020-08-10 17:28:53 +00:00
|
|
|
eprintln!("An error occured: {}", e);
|
2020-08-10 16:26:41 +00:00
|
|
|
return Err(e);
|
|
|
|
}
|
|
|
|
None => {
|
|
|
|
eprintln!("Unable to find any battery");
|
|
|
|
use std::io;
|
|
|
|
return Err(io::Error::from(io::ErrorKind::NotFound).into());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2020-08-11 16:04:25 +00:00
|
|
|
// Keep values safe
|
|
|
|
let low_level = low_level.min(95_u8).max(5_u8);
|
2020-08-10 18:16:25 +00:00
|
|
|
if very_low_level > low_level {
|
2020-08-11 16:04:25 +00:00
|
|
|
very_low_level = u8::max(low_level - 1_u8, 5_u8)
|
2020-08-10 18:16:25 +00:00
|
|
|
};
|
|
|
|
if critical_level > very_low_level {
|
2020-08-11 16:04:25 +00:00
|
|
|
critical_level = u8::max(very_low_level - 1_u8, 5_u8)
|
2020-08-10 18:16:25 +00:00
|
|
|
};
|
|
|
|
|
2020-08-12 21:19:37 +00:00
|
|
|
if verbosity == VerbosityLevel::Some {
|
|
|
|
println!("Some verbose info");
|
|
|
|
}
|
|
|
|
if verbosity >= VerbosityLevel::Some {
|
|
|
|
println!("Low battery: {}%", low_level);
|
|
|
|
println!("Very low battery: {}%", very_low_level);
|
|
|
|
println!("Critical battery: {}%", critical_level);
|
|
|
|
println!("Refresh rate: {}s", refresh_rate);
|
|
|
|
}
|
|
|
|
if verbosity >= VerbosityLevel::Lots {
|
|
|
|
println!("Lots of verbose info")
|
2020-08-11 16:04:25 +00:00
|
|
|
}
|
|
|
|
|
2020-08-10 16:26:41 +00:00
|
|
|
Ok(Self {
|
|
|
|
manager,
|
|
|
|
battery,
|
2020-08-10 17:57:40 +00:00
|
|
|
refresh_rate,
|
|
|
|
|
2020-08-10 16:26:41 +00:00
|
|
|
low_level,
|
|
|
|
very_low_level,
|
2020-08-10 17:28:53 +00:00
|
|
|
critical_level,
|
2020-08-10 17:57:40 +00:00
|
|
|
|
2020-08-10 17:28:53 +00:00
|
|
|
is_triggered_low: false,
|
2020-08-10 16:26:41 +00:00
|
|
|
is_triggered_very_low: false,
|
2020-08-10 17:57:40 +00:00
|
|
|
|
|
|
|
verbosity,
|
2020-08-10 16:26:41 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2020-08-11 16:04:25 +00:00
|
|
|
/// Reset current progress toward an empty battery
|
2020-08-10 16:26:41 +00:00
|
|
|
fn reset_levels(&mut self) {
|
2020-08-10 17:28:53 +00:00
|
|
|
self.is_triggered_low = false;
|
2020-08-10 16:26:41 +00:00
|
|
|
self.is_triggered_very_low = false;
|
|
|
|
}
|
|
|
|
|
2020-08-11 16:04:25 +00:00
|
|
|
/// Get level of charge of the battery
|
|
|
|
fn get_charge(&self) -> u8 {
|
|
|
|
(self.battery.state_of_charge().value * 100_f32) as u8
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn remaining_time(&self, time: Option<battery::units::Time>) -> String {
|
2020-08-12 21:19:37 +00:00
|
|
|
if let Some(e) = time {
|
|
|
|
let time = e.value as u64;
|
|
|
|
let hours = time / 3600;
|
|
|
|
let minutes = (time % 3600) / 60;
|
|
|
|
let seconds = time % 60;
|
|
|
|
format!("{:01}:{:02}:{:02}", hours, minutes, seconds)
|
|
|
|
} else {
|
|
|
|
"unknown remaining time".to_owned()
|
2020-08-10 16:26:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-11 16:04:25 +00:00
|
|
|
/// Warn the user once about low battery
|
|
|
|
fn trigger_low(&mut self) {
|
|
|
|
use Urgency::Normal;
|
|
|
|
trigger_warning!(
|
|
|
|
"Battery level is low! {} left ({}%)",
|
|
|
|
Normal,
|
|
|
|
self.is_triggered_low,
|
|
|
|
self.battery,
|
|
|
|
self.verbosity,
|
|
|
|
&self
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Warn the user once about very low battery
|
2020-08-10 16:26:41 +00:00
|
|
|
fn trigger_very_low(&mut self) {
|
2020-08-11 16:04:25 +00:00
|
|
|
use Urgency::Critical;
|
|
|
|
trigger_warning!(
|
|
|
|
"Battery level is low! {} left ({}%)",
|
|
|
|
Critical,
|
|
|
|
self.is_triggered_very_low,
|
|
|
|
self.battery,
|
|
|
|
self.verbosity,
|
|
|
|
&self
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
fn trigger_critical(&mut self) {
|
|
|
|
use std::process::Command;
|
|
|
|
let out = Command::new("systemctl")
|
|
|
|
.arg("suspend")
|
|
|
|
.output()
|
|
|
|
.expect("process failed to execute");
|
|
|
|
eprintln!("{}", out.status);
|
|
|
|
eprintln!(
|
|
|
|
"{}",
|
|
|
|
String::from_utf8(out.stderr)
|
|
|
|
.unwrap_or(String::from("Could not read stderr"))
|
|
|
|
);
|
|
|
|
eprintln!(
|
|
|
|
"{:?}",
|
|
|
|
String::from_utf8(out.stdout)
|
|
|
|
.unwrap_or(String::from("Could not read stdin"))
|
|
|
|
);
|
|
|
|
loop {
|
|
|
|
self.manager.refresh(&mut self.battery).unwrap();
|
|
|
|
use std::{thread, time::Duration};
|
|
|
|
thread::sleep(Duration::from_secs(self.refresh_rate));
|
|
|
|
if self.battery.state() == battery::State::Charging {
|
|
|
|
break;
|
|
|
|
}
|
2020-08-10 16:26:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn update(&mut self) {
|
|
|
|
self.manager.refresh(&mut self.battery).unwrap();
|
2020-08-11 16:04:25 +00:00
|
|
|
|
|
|
|
let charge = self.get_charge();
|
|
|
|
|
|
|
|
if self.verbosity >= VerbosityLevel::Some {
|
|
|
|
match self.battery.state() {
|
|
|
|
battery::State::Charging => println!(
|
|
|
|
"Charging: {}%, time left: {}",
|
|
|
|
charge,
|
|
|
|
self.remaining_time(self.battery.time_to_full())
|
|
|
|
),
|
|
|
|
battery::State::Discharging => println!(
|
|
|
|
"Discharging: {}%, time left: {}",
|
|
|
|
charge,
|
|
|
|
self.remaining_time(self.battery.time_to_empty())
|
|
|
|
),
|
|
|
|
battery::State::Full => println!("Full"),
|
|
|
|
battery::State::Empty => println!("Empty"),
|
|
|
|
_ => eprintln!("Error: unknown battery state"),
|
|
|
|
}
|
|
|
|
}
|
2020-08-12 21:19:37 +00:00
|
|
|
if self.verbosity >= VerbosityLevel::Lots {
|
2020-08-11 16:04:25 +00:00
|
|
|
eprintln!("====\nDebug self:\n{:?}\n====", self);
|
|
|
|
}
|
|
|
|
|
2020-08-10 16:26:41 +00:00
|
|
|
match self.battery.state() {
|
2020-08-11 16:04:25 +00:00
|
|
|
battery::State::Discharging | battery::State::Empty => {
|
|
|
|
if !self.is_triggered_low && charge <= self.low_level {
|
|
|
|
self.trigger_low();
|
|
|
|
} else if !self.is_triggered_very_low
|
|
|
|
&& charge <= self.very_low_level
|
|
|
|
{
|
|
|
|
self.trigger_very_low();
|
|
|
|
} else if charge <= self.critical_level {
|
|
|
|
self.trigger_critical();
|
|
|
|
}
|
|
|
|
}
|
2020-08-10 16:26:41 +00:00
|
|
|
_ => self.reset_levels(),
|
|
|
|
}
|
2020-08-10 17:57:40 +00:00
|
|
|
|
|
|
|
use std::{thread, time::Duration};
|
|
|
|
thread::sleep(Duration::from_secs(self.refresh_rate));
|
2020-08-10 16:26:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Default for BatteryState {
|
|
|
|
fn default() -> Self {
|
2020-08-10 17:28:53 +00:00
|
|
|
Self::new(
|
|
|
|
DEFAULT_LOW,
|
|
|
|
DEFAULT_VERY_LOW,
|
|
|
|
DEFAULT_CRITICAL,
|
|
|
|
DEFAULT_REFRESH,
|
2020-08-10 17:57:40 +00:00
|
|
|
VerbosityLevel::None,
|
2020-08-10 17:28:53 +00:00
|
|
|
)
|
|
|
|
.unwrap()
|
2020-08-10 16:26:41 +00:00
|
|
|
}
|
|
|
|
}
|