feat(battery): support legacy 0x1000 BatteryStatus and its charging quirk

Older devices such as a Bluetooth-direct MX Master 2S expose only the legacy
BatteryStatus feature (0x1000), never the unified 0x1004, so they showed no
battery at all. Implement 0x1000 mirroring the SmartShift 0x2110/0x2111 design
and have the inventory probe prefer 0x1004, falling back to 0x1000 — the same
enhanced-then-legacy order SmartShift uses. 0x1000 reports a percentage but no
level bitmask, so the coarse BatteryLevel is derived from fixed display buckets.

The 0x1000 firmware can't gauge charge under load: it reports discharge_level=0
status=Recharging while charging, which surfaced as a misleading "Charging · 0%".
Two layers handle it:

- hold_percentage_while_charging() carries the last-known percentage forward
  through a charge session (frozen pre-charge value, cache only) so the reading
  stays trackable once one discharge read exists.
- On a cold start (charger plugged before the app opens) there's no prior to
  hold, so the GUI shows "Charging" instead of the bogus 0% across the card,
  summary, and tray menu.

Adds `openlogi diag battery`, which prints the raw 0x1004/0x1000 report so a
claim like "MX2S shows 0% while charging" can be confirmed against the wire.

Verified on hardware: MX2S reports 50% (discharging) over BT-direct, and 0%
status=Recharging while charging.

Author: laofun

crates/openlogi-cli/src/cmd/diag/battery.rs

@@ -0,0 +1,32 @@
+//! `openlogi diag battery` — dump the device's raw battery report.
+//!
+//! Prints exactly what the firmware returns (unified `0x1004` fields, or legacy
+//! `0x1000` `discharge_level`/`next_level`/`status`). Run it once on battery and
+//! once with the charger plugged in to see how the device reports while charging
+//! — e.g. an MX2S returns `discharge_level=0` mid-charge, which is the device's
+//! own limitation, not a bug in the read path.
+
+use anyhow::{Context, Result};
+use clap::Args;
+
+use crate::cmd::diag::select_device;
+
+#[derive(Debug, Args)]
+pub struct BatteryArgs {
+    /// Run against the device whose name contains this string
+    /// (case-insensitive) instead of auto-selecting.
+    #[arg(long, value_name = "NAME")]
+    pub device: Option<String>,
+}
+
+pub async fn run(args: BatteryArgs) -> Result<()> {
+    // 0x1004 UnifiedBattery / 0x1000 BatteryStatus — pick a device with either.
+    let (route, name) = select_device(args.device.as_deref(), &[0x1000, 0x1004]).await?;
+    println!("device: {name} ({route})");
+
+    let line = openlogi_hid::read_battery_raw(&route)
+        .await
+        .context("read battery")?;
+    println!("  {line}");
+    Ok(())
+}

crates/openlogi-cli/src/cmd/diag/mod.rs

@@ -10,6 +10,7 @@ use anyhow::{Result, anyhow};
 use clap::Subcommand;
 use openlogi_hid::{DeviceRoute, dump_features};
 
+pub mod battery;
 pub mod dpi;
 pub mod features;
 pub mod lighting;
@@ -19,6 +20,8 @@ pub mod smartshift;
 pub enum DiagCmd {
     /// Dump every HID++ feature the active device reports.
     Features(features::FeaturesArgs),
+    /// Read the raw battery report (0x1004 or 0x1000 fields).
+    Battery(battery::BatteryArgs),
     /// Read DPI → write a small delta → read back → restore → report.
     Dpi(dpi::DpiArgs),
     /// Read SmartShift mode → toggle → read back → toggle back → report.
@@ -31,6 +34,7 @@ impl DiagCmd {
     pub async fn run(self) -> Result<()> {
         match self {
             Self::Features(args) => features::run(args).await,
+            Self::Battery(args) => battery::run(args).await,
             Self::Dpi(args) => dpi::run(args).await,
             Self::Smartshift(args) => smartshift::run(args).await,
             Self::Lighting(args) => lighting::run(args).await,

crates/openlogi-gui/src/app.rs

@@ -817,17 +817,32 @@ fn status_dot(online: bool) -> AnyElement {
     .into_any_element()
 }
 
+/// True when the device is charging but still reports 0% — the MX2S `0x1000`
+/// firmware can't gauge charge under load, and on a cold start there's no
+/// pre-charge % cached to carry forward. Show "Charging" without the bogus 0%.
+/// ponytail: cold-start only; once any discharge read is cached, the
+/// carry-forward in `inventory.rs` holds it and `percentage` is non-zero.
+pub(crate) fn battery_charging_no_reading(b: &BatteryInfo) -> bool {
+    matches!(
+        b.status,
+        BatteryStatus::Charging | BatteryStatus::ChargingSlow
+    ) && b.percentage == 0
+}
+
 /// Battery readout for a gallery card: a charge/level glyph plus the
 /// percentage, in the muted metadata style.
 fn battery_view(b: &BatteryInfo, pal: Palette) -> AnyElement {
-    h_flex()
+    let row = h_flex()
         .gap_1()
         .items_center()
         .text_xs()
         .text_color(pal.text_muted)
-        .child(Icon::new(battery_icon(b)).size_3())
-        .child(format!("{}%", b.percentage))
-        .into_any_element()
+        .child(Icon::new(battery_icon(b)).size_3());
+    if battery_charging_no_reading(b) {
+        row.child(tr!("Charging")).into_any_element()
+    } else {
+        row.child(format!("{}%", b.percentage)).into_any_element()
+    }
 }
 
 /// Pick the battery glyph from charge state first (charging / full / error),
@@ -1338,7 +1353,11 @@ fn battery_summary(battery: &BatteryInfo, pal: Palette) -> impl IntoElement {
                 .text_xs()
                 .text_color(pal.text_muted)
                 .child(status)
-                .child(format!("{}%", battery.percentage)),
+                .child(if battery_charging_no_reading(battery) {
+                    String::new()
+                } else {
+                    format!("{}%", battery.percentage)
+                }),
         )
         .child(
             div()
@@ -1697,7 +1716,35 @@ fn accessibility_status(pal: Palette, granted: bool) -> AnyElement {
 
 #[cfg(test)]
 mod tests {
-    use super::{Capabilities, DetailTab, DeviceKind, DeviceRecord};
+    use super::{
+        BatteryInfo, BatteryLevel, BatteryStatus, Capabilities, DetailTab, DeviceKind,
+        DeviceRecord, battery_charging_no_reading,
+    };
+
+    /// "Charging" replaces the bogus percentage only when charging *and* the
+    /// reading is still 0% (cold start, no cached pre-charge value). A non-zero
+    /// charge or a real 0% while discharging keeps the number.
+    #[test]
+    fn charging_without_reading_suppresses_percentage() {
+        let b = |percentage, status| BatteryInfo {
+            percentage,
+            level: BatteryLevel::Good,
+            status,
+        };
+        assert!(battery_charging_no_reading(&b(0, BatteryStatus::Charging)));
+        assert!(battery_charging_no_reading(&b(
+            0,
+            BatteryStatus::ChargingSlow
+        )));
+        assert!(!battery_charging_no_reading(&b(
+            40,
+            BatteryStatus::Charging
+        )));
+        assert!(!battery_charging_no_reading(&b(
+            0,
+            BatteryStatus::Discharging
+        )));
+    }
 
     fn record(kind: DeviceKind, capabilities: Option<Capabilities>) -> DeviceRecord {
         DeviceRecord {

crates/openlogi-gui/src/app_menu.rs

@@ -218,6 +218,9 @@ fn device_menu_items(cx: &App) -> Vec<MenuItem> {
         Some(state) if !state.device_list.is_empty() => {
             for record in &state.device_list {
                 let title = match &record.battery {
+                    Some(battery) if crate::app::battery_charging_no_reading(battery) => {
+                        format!("{} · {}", record.display_name, tr!("Charging"))
+                    }
                     Some(battery) => format!("{} · {}%", record.display_name, battery.percentage),
                     None => record.display_name.clone(),
                 };