From 72ecdc932e08ebee743b0f035b0c6b2a6c37e939 Mon Sep 17 00:00:00 2001
From: Avii <git@avii.nl>
Date: Sun, 16 Aug 2026 17:17:34 +0200
Subject: [PATCH] 1786893454

---
 dashboard/src/battery.rs  | 42 ++++++++++++++++++++++++++++++++++++---
 dashboard/src/messages.rs |  5 ++---
 dashboard/src/ui.rs       |  9 ++++++---
 3 files changed, 47 insertions(+), 9 deletions(-)

diff --git a/dashboard/src/battery.rs b/dashboard/src/battery.rs
index 9efeef4..5c7892f 100644
--- a/dashboard/src/battery.rs
+++ b/dashboard/src/battery.rs
@@ -1,9 +1,47 @@
 use std::time::Duration;
 
+use battery::{Battery, State, Technology, units::*};
 use tokio::{sync::mpsc::UnboundedSender, time::sleep};
 
 use crate::{error::AppError, messages::EventMessage};
 
+#[derive(Copy, Clone, Debug)]
+pub struct BatteryData {
+    state_of_health: Ratio,
+    state_of_charge: Ratio,
+    energy: Energy,
+    energy_full: Energy,
+    energy_full_design: Energy,
+    energy_rate: Power,
+    state: State,
+    voltage: ElectricPotential,
+    temperature: Option<ThermodynamicTemperature>,
+    technology: Technology,
+    cycle_count: Option<u32>,
+    time_to_full: Option<Time>,
+    time_to_empty: Option<Time>,
+}
+
+impl From<&Battery> for BatteryData {
+    fn from(value: &Battery) -> Self {
+        Self {
+            state_of_health: value.state_of_health(),
+            state_of_charge: value.state_of_charge(),
+            energy: value.energy(),
+            energy_full: value.energy_full(),
+            energy_full_design: value.energy_full_design(),
+            energy_rate: value.energy_rate(),
+            state: value.state(),
+            voltage: value.voltage(),
+            temperature: value.temperature(),
+            technology: value.technology(),
+            cycle_count: value.cycle_count(),
+            time_to_full: value.time_to_full(),
+            time_to_empty: value.time_to_empty(),
+        }
+    }
+}
+
 pub async fn battery_listener(s2c_tx: UnboundedSender<EventMessage>) -> Result<(), AppError> {
     let manager = ::battery::Manager::new()?;
 
@@ -16,9 +54,7 @@ pub async fn battery_listener(s2c_tx: UnboundedSender<EventMessage>) -> Result<(
         let s2c_tx = s2c_tx.clone();
         async move {
             loop {
-                s2c_tx
-                    .send(EventMessage::BatteryPercentage(battery.state_of_charge()))
-                    .ok();
+                s2c_tx.send(EventMessage::Battery((&battery).into())).ok();
 
                 sleep(Duration::from_secs(30)).await;
 
diff --git a/dashboard/src/messages.rs b/dashboard/src/messages.rs
index 78bda63..663cfa7 100644
--- a/dashboard/src/messages.rs
+++ b/dashboard/src/messages.rs
@@ -1,7 +1,6 @@
-use battery::units::Ratio;
 use hass_rs::HassEntity;
 
-use crate::home_assistant::CalendarEvent;
+use crate::{battery::BatteryData, home_assistant::CalendarEvent};
 
 #[derive(Clone)]
 pub enum CommandMessage {
@@ -18,5 +17,5 @@ pub enum EventMessage {
     EntityUpdated(HassEntity),
     EntityRemoved(HassEntity),
     CalendarUpdated(Vec<CalendarEvent>),
-    BatteryPercentage(Ratio),
+    Battery(BatteryData),
 }
diff --git a/dashboard/src/ui.rs b/dashboard/src/ui.rs
index 5e7961a..a18bcea 100644
--- a/dashboard/src/ui.rs
+++ b/dashboard/src/ui.rs
@@ -1,12 +1,15 @@
 slint::include_modules!();
 
+use std::sync::Arc;
+
 use crate::{
+    battery::BatteryData,
     ha_ext::*,
     home_assistant::CalendarEvent,
     messages::{CommandMessage, EventMessage},
 };
 
-use battery::units::Ratio;
+use battery::Battery;
 use hass_rs::HassEntity;
 use paste::paste;
 use slint::{Model, ModelRc, VecModel, Weak, language::ColorScheme};
@@ -122,7 +125,7 @@ pub fn apply_calendars(app: &Weak<AppWindow>, entities: Vec<CalendarEvent>) {
     }
 }
 
-pub fn apply_battery(app: &Weak<AppWindow>, batt: Ratio) {
+pub fn apply_battery(app: &Weak<AppWindow>, batt: BatteryData) {
     // ..
     dbg!(batt);
 }
@@ -195,7 +198,7 @@ pub async fn update_listener(
             EventMessage::CalendarUpdated(events) => {
                 apply_calendars(&app_weak, events);
             }
-            EventMessage::BatteryPercentage(batt) => {
+            EventMessage::Battery(batt) => {
                 apply_battery(&app_weak, batt);
             }
         }