batmon 0.0.1

Interactive batteries viewer
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use std::sync::Arc;

use starship_battery::units;

use super::{ChartData, ChartType, Units};
use crate::app::Config;
use crate::Result;

/// View is a content of one separate tab - information about one specific battery
#[derive(Debug)]
pub struct View {
    config: Arc<Config>,
    battery: starship_battery::Battery,
    voltage: ChartData,
    energy_rate: ChartData,
    temperature: ChartData,
}

impl View {
    pub fn new(config: Arc<Config>, battery: starship_battery::Battery) -> View {
        View {
            config: config.clone(),
            battery,
            voltage: ChartData::new(config.clone(), ChartType::Voltage),
            energy_rate: ChartData::new(config.clone(), ChartType::EnergyRate),
            temperature: ChartData::new(config, ChartType::Temperature),
        }
    }

    /// Update internal state, but do not re-draw it
    pub fn update(&mut self, manager: &mut starship_battery::Manager) -> Result<()> {
        manager.refresh(&mut self.battery)?;

        self.voltage.push(
            self.battery
                .voltage()
                .get::<units::electric_potential::volt>(),
        );
        *self.voltage.battery_state() = self.battery.state();

        self.energy_rate
            .push(self.battery.energy_rate().get::<units::power::watt>());
        *self.energy_rate.battery_state() = self.battery.state();

        if let Some(temp) = self.battery.temperature() {
            let value = match self.config.units() {
                Units::Human => temp.get::<units::thermodynamic_temperature::degree_celsius>(),
                Units::Si => temp.get::<units::thermodynamic_temperature::kelvin>(),
            };
            self.temperature.push(value);
            *self.temperature.battery_state() = self.battery.state();
            self.temperature.enabled(true);
        } else {
            self.temperature.enabled(false);
        }

        Ok(())
    }

    /// Return view title used in a tab header
    pub fn title(&self) -> String {
        if let Some(model) = self.battery.model() {
            trace!(
                "View is going to use battery model as a tab title: {}",
                model
            );
            return model.to_string();
        }

        if let Some(vendor) = self.battery.vendor() {
            trace!(
                "View is going to use battery vendor as a tab title: {}",
                vendor
            );
            return vendor.to_string();
        }

        if let Some(sn) = self.battery.serial_number() {
            trace!("View is going to use battery S/N as a tab title: {}", sn);
            return sn.to_string();
        }

        warn!("View is unable to determine proper tab title, falling back to unknown");
        "Unknown battery".to_string()
    }

    pub fn battery(&self) -> &starship_battery::Battery {
        &self.battery
    }

    pub fn voltage(&self) -> &ChartData {
        &self.voltage
    }

    pub fn energy_rate(&self) -> &ChartData {
        &self.energy_rate
    }

    pub fn temperature(&self) -> &ChartData {
        &self.temperature
    }

    pub fn config(&self) -> &Config {
        &self.config
    }
}