Dashboard: Show charging speed and wattage in more places (#55)

* Battery: Read the charger-advertised maximum from the battery broadcast

The sticky battery broadcast carries EXTRA_MAX_CHARGING_CURRENT and
EXTRA_MAX_CHARGING_VOLTAGE: what the connected supply claims it can
deliver. Both land on BatteryReadout as nullable fields (absent or
non-positive normalizes to null: a device with nothing connected reports
0, which is "no charger", not "a 0 W charger").

StatsPowerCalculator gains advertisedMaxMilliwatts for that pair, with
AOSP BatteryStatus' 5 V fallback when only the current is reported, plus
readout-taking overloads so callers don't re-derive the charge-power
gate. The existing implausibility cap applies to the advertised figure
too.

Also adds the strings the upcoming wattage surfaces need.

* Dashboard: Title the charging card by charging speed

The card headline said only "Charging" whatever the charger delivered.
It now classifies the measured draw into slowly / (plain) / fast / very
fast. The slow and fast bars are AOSP SettingsLib's own bucket values
(5 W / 7.5 W), applied to the measured draw rather than the
charger-advertised maximum AOSP classifies: the measurement is what the
battery actually receives and is the number printed one line below the
headline. The very-fast bar at 15 W is ours, twice the AOSP fast bar, so
modern 20 W+ chargers aren't all lumped in as merely "fast". A draw that
can't be measured keeps the plain title rather than guessing a speed.

BatteryEffect moves from main/ui/dashboard to battery/ui: its tri-state
"is the battery positively not charging" semantics are needed by the
battery hub and the session detail screen, which must not import a
dashboard presentation file. It gains chargePowerFallbackRes, the shared
rule for what to print in place of a withheld wattage.

* Battery: Show live charge power in the hub and the session detail

The wattage was only ever visible in the dashboard card's reading line
and as a recorded peak/average. The battery hub's electrical section now
carries "Charge power" (the gated live figure, so a discharge draw can
never read as charge power) and "Charger max" (the supply's advertised
capability, read through only while something is connected).

The charge session detail gains a live "Power now" row, but only while
the viewed session is the open one the caller vouched for: the detail
query is by id and unrestricted, so it can resolve a dangling open row
from an earlier boot that the boot-scoped live query rejects. The
activity therefore attributes the readout only when the viewed id
equals the live session's id.

Both surfaces distinguish a withheld figure from a missing one: "Not
charging" where the battery positively reported it isn't taking charge,
"Not reported" everywhere else.

* Fix: Read the charger-maximum extras by their literal keys

BatteryManager.EXTRA_MAX_CHARGING_CURRENT/VOLTAGE are @hide constants:
BatteryService puts both into ACTION_BATTERY_CHANGED, but the symbols
are absent from the public SDK's android.jar, so referencing them fails
to compile. The extras themselves are readable (only the constants are
missing), so the reader uses the stable AOSP string keys instead. No
reflection is involved.

Author: d4rken

app/src/main/java/eu/darken/amply/battery/core/BatteryReader.kt

@@ -51,6 +51,8 @@ class BatteryReader @Inject constructor(
             currentNowMicroamps = manager.propertyOrAbsent(BatteryManager.BATTERY_PROPERTY_CURRENT_NOW),
             chargeCounterMicroampHours = manager.propertyOrAbsent(BatteryManager.BATTERY_PROPERTY_CHARGE_COUNTER),
             cycleCount = cycleCount(battery),
+            maxChargingCurrentMicroamps = battery.getIntExtra(EXTRA_MAX_CHARGING_CURRENT, ABSENT),
+            maxChargingVoltageMicrovolts = battery.getIntExtra(EXTRA_MAX_CHARGING_VOLTAGE, ABSENT),
         )
     }
 
@@ -66,5 +68,11 @@ class BatteryReader @Inject constructor(
 
         // BatteryManager.EXTRA_CYCLE_COUNT — inlined to avoid a hard API-34 symbol reference.
         const val EXTRA_CYCLE_COUNT = "android.os.extra.CYCLE_COUNT"
+
+        // BatteryManager.EXTRA_MAX_CHARGING_CURRENT/VOLTAGE are @hide: BatteryService puts them into
+        // ACTION_BATTERY_CHANGED, but the constants are absent from the public SDK. The literal keys
+        // are stable AOSP identifiers.
+        const val EXTRA_MAX_CHARGING_CURRENT = "max_charging_current"
+        const val EXTRA_MAX_CHARGING_VOLTAGE = "max_charging_voltage"
     }
 }

app/src/main/java/eu/darken/amply/battery/core/BatteryReadout.kt

@@ -23,6 +23,17 @@ data class BatteryReadout(
     val currentNowMicroamps: Int? = null,
     val chargeCounterMicroampHours: Int? = null,
     val cycleCount: Int? = null,
+    /**
+     * Charger-advertised maximum, not a measurement: what the connected supply says it can deliver.
+     * Only meaningful while something is connected, and never a substitute for the measured draw.
+     *
+     * Sourced from the `max_charging_current` / `max_charging_voltage` extras of
+     * [android.content.Intent.ACTION_BATTERY_CHANGED]. The framework populates them, but their
+     * `BatteryManager` constants are `@hide` and absent from the public SDK, so `BatteryReader` reads
+     * the literal AOSP keys.
+     */
+    val maxChargingCurrentMicroamps: Int? = null,
+    val maxChargingVoltageMicrovolts: Int? = null,
 ) {
     /**
      * External power is reported. A null (not reported) [plugged] collapses conservatively to false —

app/src/main/java/eu/darken/amply/battery/core/BatteryReadoutFactory.kt

@@ -29,6 +29,8 @@ object BatteryReadoutFactory {
         currentNowMicroamps: Int = ABSENT,
         chargeCounterMicroampHours: Int = ABSENT,
         cycleCount: Int = ABSENT,
+        maxChargingCurrentMicroamps: Int = ABSENT,
+        maxChargingVoltageMicrovolts: Int = ABSENT,
     ): BatteryReadout = BatteryReadout(
         levelPercent = percentOf(level, scale),
         status = status.orNull(),
@@ -42,6 +44,10 @@ object BatteryReadoutFactory {
         currentNowMicroamps = currentNowMicroamps.orNull(),
         chargeCounterMicroampHours = chargeCounterMicroampHours.orNull(),
         cycleCount = cycleCount.orNull(),
+        // The charger extras are advertised capabilities: a device that reports them while nothing is
+        // connected reports 0, which is "no charger" rather than "a 0 W charger".
+        maxChargingCurrentMicroamps = maxChargingCurrentMicroamps.positiveOrNull(),
+        maxChargingVoltageMicrovolts = maxChargingVoltageMicrovolts.positiveOrNull(),
     )
 
     /** Percent only when the level/scale pair is internally consistent; otherwise `null`. */
@@ -51,4 +57,6 @@ object BatteryReadoutFactory {
     }
 
     private fun Int.orNull(): Int? = if (this == ABSENT) null else this
+
+    private fun Int.positiveOrNull(): Int? = if (this == ABSENT || this <= 0) null else this
 }

…amply/main/ui/dashboard/BatteryEffect.kt …darken/amply/battery/ui/BatteryEffect.ktapp/src/main/java/eu/darken/amply/main/ui/dashboard/BatteryEffect.kt renamed to app/src/main/java/eu/darken/amply/battery/ui/BatteryEffect.kt app/src/main/java/eu/darken/amply/main/ui/dashboard/BatteryEffect.kt renamed to app/src/main/java/eu/darken/amply/battery/ui/BatteryEffect.kt

@@ -1,6 +1,8 @@
-package eu.darken.amply.main.ui.dashboard
+package eu.darken.amply.battery.ui
 
 import android.os.BatteryManager
+import androidx.annotation.StringRes
+import eu.darken.amply.R
 import eu.darken.amply.battery.core.BatteryReadout
 import eu.darken.amply.stats.core.StatsPowerCalculator
 
@@ -76,15 +78,31 @@ sealed interface BatteryEffect {
 }
 
 /**
- * Charge power for the charging card's reading line, or `null` when no figure may be shown.
+ * Charge power for a live reading line, or `null` when no figure may be shown.
  *
  * Delegates to [StatsPowerCalculator.chargeMilliwatts] rather than re-deriving the rule, so the
  * live headline and the recorded curve/peak/average can never disagree about what counts as charge
  * power.
  */
-fun chargePowerMilliwatts(readout: BatteryReadout): Int? = StatsPowerCalculator.chargeMilliwatts(
-    batteryStatus = readout.status,
-    plugged = readout.onCharger,
-    voltageMillivolts = readout.voltageMillivolts,
-    currentNowMicroamps = readout.currentNowMicroamps,
-)
+fun chargePowerMilliwatts(readout: BatteryReadout): Int? = StatsPowerCalculator.chargeMilliwatts(readout)
+
+/**
+ * What to show in place of a withheld charge power, as a string resource.
+ *
+ * "Not charging" is only used where the battery *positively* reported that it isn't taking charge
+ * (unplugged, held at a limit, full). Everywhere else the figure is missing rather than zero — a
+ * connected device with no usable status has not told us it isn't charging — so it falls back to the
+ * shared "Not reported".
+ */
+@StringRes
+fun chargePowerFallbackRes(effect: BatteryEffect): Int = when (effect) {
+    is BatteryEffect.OnBattery,
+    is BatteryEffect.ConnectedNotCharging,
+    is BatteryEffect.Full,
+    -> R.string.battery_value_not_charging
+
+    is BatteryEffect.Charging,
+    is BatteryEffect.Connected,
+    BatteryEffect.Unknown,
+    -> R.string.battery_value_not_reported
+}

app/src/main/java/eu/darken/amply/main/ui/MainActivity.kt

@@ -430,6 +430,14 @@ class MainActivity : ComponentActivity() {
                             val statsDetail by statsViewModel.detailState.collectAsState()
                             StatsSessionDetailScreen(
                                 state = statsDetail,
+                                // Live wattage only for the session that is actually charging now. The
+                                // detail query is by id and unrestricted, so it can resolve a dangling
+                                // open row from an earlier boot that the boot-scoped live query rejects
+                                // — attributing the current draw to it would be a fabrication.
+                                readout = state.batteryReadout.takeIf {
+                                    val live = state.stats.live
+                                    live != null && statsDetail?.summary?.id == live.id
+                                },
                                 onBack = {
                                     statsViewModel.closeSession()
                                     destination = detailOrigin

app/src/main/java/eu/darken/amply/main/ui/battery/BatteryHubScreen.kt

@@ -27,9 +27,11 @@ import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import eu.darken.amply.R
 import eu.darken.amply.battery.core.BatteryReadout
+import eu.darken.amply.battery.ui.BatteryEffect
 import eu.darken.amply.battery.ui.batteryHealthLabel
 import eu.darken.amply.battery.ui.batteryPlugLabel
 import eu.darken.amply.battery.ui.batteryStatusLabel
+import eu.darken.amply.battery.ui.chargePowerFallbackRes
 import eu.darken.amply.battery.ui.formatChargeCounter
 import eu.darken.amply.battery.ui.formatCurrent
 import eu.darken.amply.battery.ui.formatTemperature
@@ -38,6 +40,8 @@ import eu.darken.amply.common.compose.AmplyCard
 import eu.darken.amply.common.compose.AmplyCardDefaults
 import eu.darken.amply.common.compose.AmplyPreview
 import eu.darken.amply.common.compose.PreviewWrapper
+import eu.darken.amply.stats.core.StatsPowerCalculator
+import eu.darken.amply.stats.ui.StatsFormat
 
 /**
  * The single battery/charging destination: the current or last charge and the full live readout, led
@@ -185,6 +189,21 @@ private fun ElectricalSection(readout: BatteryReadout) {
             stringResource(R.string.battery_detail_current),
             formatCurrent(readout.currentNowMicroamps) ?: notReported,
         )
+        // Voltage × current above is a magnitude in either direction; this row is the gated charge
+        // power, so a discharge draw can never be read here as charge power.
+        DetailRow(
+            stringResource(R.string.battery_detail_power),
+            StatsFormat.power(StatsPowerCalculator.chargeMilliwatts(readout))
+                ?: stringResource(chargePowerFallbackRes(BatteryEffect.from(readout))),
+        )
+        // Advertised, not measured: what the connected supply claims. Nothing connected means nothing
+        // to claim, so the extras are only read through while on a charger.
+        DetailRow(
+            stringResource(R.string.battery_detail_charger_max),
+            readout.takeIf { it.onCharger }
+                ?.let { StatsFormat.power(StatsPowerCalculator.advertisedMaxMilliwatts(it)) }
+                ?: notReported,
+        )
         DetailRow(
             stringResource(R.string.battery_detail_charge_counter),
             formatChargeCounter(readout.chargeCounterMicroampHours) ?: notReported,
@@ -251,6 +270,9 @@ private val previewCharging = BatteryReadout(
     currentNowMicroamps = 1_250_000,
     chargeCounterMicroampHours = 3_800_000,
     cycleCount = 142,
+    // A 9 V / 2 A charger advertising itself while the battery measures ~5.2 W.
+    maxChargingCurrentMicroamps = 2_000_000,
+    maxChargingVoltageMicrovolts = 9_000_000,
 )
 
 @AmplyPreview

app/src/main/java/eu/darken/amply/main/ui/dashboard/ChargingCard.kt

@@ -2,6 +2,7 @@ package eu.darken.amply.main.ui.dashboard
 
 import android.os.BatteryManager
 import android.os.SystemClock
+import androidx.annotation.StringRes
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ColumnScope
@@ -22,6 +23,7 @@ import androidx.compose.ui.unit.dp
 import eu.darken.amply.R
 import eu.darken.amply.battery.core.BatteryReadout
 import eu.darken.amply.battery.ui.batteryStatusLabel
+import eu.darken.amply.battery.ui.chargePowerMilliwatts
 import eu.darken.amply.battery.ui.formatTemperature
 import eu.darken.amply.common.compose.AmplyNavigationCard
 import eu.darken.amply.common.compose.AmplyPreview
@@ -87,7 +89,7 @@ fun ChargingCard(
         onClickLabel = stringResource(R.string.dashboard_charging_open_action),
         title = stringResource(
             when {
-                charging -> R.string.dashboard_charging_title_charging
+                charging -> chargingTitle(chargingSpeed(chargePowerMilliwatts(battery)))
                 onCharger -> R.string.dashboard_charging_title_connected
                 else -> R.string.dashboard_charging_title_idle
             },
@@ -114,6 +116,18 @@ fun ChargingCard(
     }
 }
 
+/**
+ * The headline while charging. An unclassifiable draw (no figure, or a device that reports none)
+ * stays at the plain "Charging" — the card never guesses a speed it can't measure.
+ */
+@StringRes
+private fun chargingTitle(speed: ChargingSpeed?): Int = when (speed) {
+    ChargingSpeed.VERY_FAST -> R.string.dashboard_charging_title_very_fast
+    ChargingSpeed.FAST -> R.string.dashboard_charging_title_fast
+    ChargingSpeed.SLOW -> R.string.dashboard_charging_title_slow
+    ChargingSpeed.NORMAL, null -> R.string.dashboard_charging_title_charging
+}
+
 /**
  * "82% · Charging · 12.3 W · 31.4 °C" — the live reading.
  *
@@ -242,6 +256,19 @@ private val previewCharging = BatteryReadout(
     currentNowMicroamps = 2_050_000,
 )
 
+// ~0.6 W — a trickle from a weak supply.
+private val previewChargingSlow = previewCharging.copy(
+    levelPercent = 41,
+    currentNowMicroamps = 150_000,
+)
+
+// ~19.8 W — a dual-cell pack reporting its own voltage on a high-power charger.
+private val previewChargingVeryFast = previewCharging.copy(
+    levelPercent = 22,
+    voltageMillivolts = 9_000,
+    currentNowMicroamps = 2_200_000,
+)
+
 private val previewHolding = previewCharging.copy(
     levelPercent = 80,
     status = BatteryManager.BATTERY_STATUS_NOT_CHARGING,
@@ -297,6 +324,36 @@ private fun ChargingCardLivePreview() = PreviewWrapper {
     }
 }
 
+@AmplyPreview
+@Composable
+private fun ChargingCardSpeedPreview() = PreviewWrapper {
+    // The headline follows the measured draw: trickle, fast (the default fixture), and a high-power
+    // charger. A device that reports no draw keeps the plain "Charging".
+    Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
+        ChargingCard(
+            presentation = ChargingCardPresentation.Live(session = previewLiveSession),
+            readout = previewChargingSlow,
+            onOpenHub = {},
+            onRetryCapture = {},
+            nowElapsedRealtimeMillis = 4_320_000L,
+        )
+        ChargingCard(
+            presentation = ChargingCardPresentation.Live(session = previewLiveSession),
+            readout = previewChargingVeryFast,
+            onOpenHub = {},
+            onRetryCapture = {},
+            nowElapsedRealtimeMillis = 4_320_000L,
+        )
+        ChargingCard(
+            presentation = ChargingCardPresentation.Live(session = previewLiveSession),
+            readout = previewCharging.copy(currentNowMicroamps = null),
+            onOpenHub = {},
+            onRetryCapture = {},
+            nowElapsedRealtimeMillis = 4_320_000L,
+        )
+    }
+}
+
 @AmplyPreview
 @Composable
 private fun ChargingCardConnectedPreview() = PreviewWrapper {

app/src/main/java/eu/darken/amply/main/ui/dashboard/ChargingCardPresentation.kt

@@ -103,3 +103,31 @@ sealed interface ChargingCardPresentation {
         }
     }
 }
+
+/** How fast the battery is being charged, for the card's headline. */
+enum class ChargingSpeed {
+    SLOW,
+    NORMAL,
+    FAST,
+    VERY_FAST,
+}
+
+/**
+ * Buckets a measured charge power, or `null` when there is no figure to classify — an unknown speed
+ * is not a normal one, and the caller falls back to the plain "Charging" headline.
+ *
+ * The SLOW and FAST bars are AOSP SettingsLib's own bucket values (`config_chargingSlowlyThreshold`
+ * 5 W / `config_chargingFastThreshold` 7.5 W), applied here to the *measured* draw rather than to the
+ * charger-advertised maximum AOSP uses — the measurement is what the battery actually receives, and it
+ * is the number shown one line below the headline. VERY_FAST at 15 W is Amply's own, twice the AOSP
+ * fast bar, so the modern 20 W+ chargers that would otherwise all read "fast" are distinguishable.
+ */
+fun chargingSpeed(milliwatts: Int?): ChargingSpeed? {
+    if (milliwatts == null || milliwatts <= 0) return null
+    return when {
+        milliwatts < 5_000 -> ChargingSpeed.SLOW
+        milliwatts > 15_000 -> ChargingSpeed.VERY_FAST
+        milliwatts > 7_500 -> ChargingSpeed.FAST
+        else -> ChargingSpeed.NORMAL
+    }
+}

app/src/main/java/eu/darken/amply/main/ui/dashboard/DashboardScreen.kt

@@ -84,6 +84,7 @@ import eu.darken.amply.fullcharge.core.InterruptionReason
 import eu.darken.amply.fullcharge.core.policyOrNull
 import eu.darken.amply.main.core.formatReport
 import eu.darken.amply.battery.core.BatteryReadout
+import eu.darken.amply.battery.ui.BatteryEffect
 import eu.darken.amply.main.ui.setup.AccessSetupGuide
 import eu.darken.amply.main.ui.setup.OemGuideCard
 import eu.darken.amply.main.ui.setup.UnsupportedDeviceCard

app/src/main/java/eu/darken/amply/stats/core/StatsPowerCalculator.kt

@@ -1,6 +1,7 @@
 package eu.darken.amply.stats.core
 
 import android.os.BatteryManager
+import eu.darken.amply.battery.core.BatteryReadout
 import kotlin.math.abs
 
 /**
@@ -18,6 +19,9 @@ object StatsPowerCalculator {
     /** 250 W — generously above any phone/tablet charger; anything larger is a bad OEM reading. */
     const val MAX_PLAUSIBLE_MILLIWATTS = 250_000
 
+    /** AOSP's assumed charging voltage when a charger advertises a current but no voltage. */
+    private const val DEFAULT_CHARGING_VOLTAGE_MICROVOLTS = 5_000_000
+
     fun milliwatts(voltageMillivolts: Int?, currentNowMicroamps: Int?): Int? {
         if (voltageMillivolts == null || currentNowMicroamps == null) return null
         if (voltageMillivolts <= 0) return null
@@ -49,4 +53,39 @@ object StatsPowerCalculator {
         if (batteryStatus != BatteryManager.BATTERY_STATUS_CHARGING) return null
         return milliwatts(voltageMillivolts, currentNowMicroamps)
     }
+
+    /** [chargeMilliwatts] straight off a readout; `null` readout (nothing observed) yields `null`. */
+    fun chargeMilliwatts(readout: BatteryReadout?): Int? {
+        if (readout == null) return null
+        return chargeMilliwatts(
+            batteryStatus = readout.status,
+            plugged = readout.onCharger,
+            voltageMillivolts = readout.voltageMillivolts,
+            currentNowMicroamps = readout.currentNowMicroamps,
+        )
+    }
+
+    /**
+     * What the connected charger *advertises* it can deliver, in milliwatts — not a measurement, and
+     * never a stand-in for [chargeMilliwatts].
+     *
+     * A missing/non-positive voltage falls back to 5 V, matching AOSP's own `BatteryStatus`: chargers
+     * that report a current but no voltage are USB-spec 5 V supplies, and dropping the figure entirely
+     * would hide the more commonly reported half of the pair.
+     */
+    fun advertisedMaxMilliwatts(maxCurrentMicroamps: Int?, maxVoltageMicrovolts: Int?): Int? {
+        if (maxCurrentMicroamps == null || maxCurrentMicroamps <= 0) return null
+        val microvolts = maxVoltageMicrovolts?.takeIf { it > 0 } ?: DEFAULT_CHARGING_VOLTAGE_MICROVOLTS
+        val mw = (maxCurrentMicroamps.toLong() / 1000L) * (microvolts.toLong() / 1000L) / 1000L
+        if (mw <= 0 || mw > MAX_PLAUSIBLE_MILLIWATTS) return null
+        return mw.toInt()
+    }
+
+    fun advertisedMaxMilliwatts(readout: BatteryReadout?): Int? {
+        if (readout == null) return null
+        return advertisedMaxMilliwatts(
+            maxCurrentMicroamps = readout.maxChargingCurrentMicroamps,
+            maxVoltageMicrovolts = readout.maxChargingVoltageMicrovolts,
+        )
+    }
 }