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.

Author: d4rken

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/stats/ui/StatsSessionDetailScreen.kt

@@ -26,25 +26,34 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 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.chargePowerFallbackRes
 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.ChargeCurvePoint
 import eu.darken.amply.stats.core.ChargeSessionSummary
 import eu.darken.amply.stats.core.ChargingType
+import eu.darken.amply.stats.core.StatsPowerCalculator
 import eu.darken.amply.stats.core.StatsSealReason
 
 /**
  * One session's charge curve (percent / power / temperature over time) plus its numeric summary.
  * State-hoisted; a null [state] shows a spinner while the ViewModel resolves the selection, and a
  * resolved state without a summary means the session no longer exists (discarded or cleared) — a
  * notice, never an eternal spinner. An open session's curve/summary keep updating live.
+ *
+ * [readout] is the *live* battery reading, and only the caller can say whether it belongs to the
+ * session being viewed — pass null for any session that isn't the one currently charging, or the
+ * current charge's wattage would be attributed to someone else's history.
  */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun StatsSessionDetailScreen(
     state: StatsDetailState?,
+    readout: BatteryReadout?,
     onBack: () -> Unit,
 ) {
     Scaffold(
@@ -98,7 +107,7 @@ fun StatsSessionDetailScreen(
             verticalArrangement = Arrangement.spacedBy(12.dp),
         ) {
             item { CurveCard(state.curve) }
-            item { SummaryCard(summary) }
+            item { SummaryCard(summary, readout) }
             if (summary.partial) {
                 item {
                     Text(
@@ -127,7 +136,7 @@ private fun CurveCard(curve: List<ChargeCurvePoint>) {
 }
 
 @Composable
-private fun SummaryCard(summary: ChargeSessionSummary) {
+private fun SummaryCard(summary: ChargeSessionSummary, readout: BatteryReadout?) {
     val notReported = stringResource(R.string.battery_value_not_reported)
     AmplyCard(verticalArrangement = Arrangement.spacedBy(AmplyCardDefaults.ItemSpacing)) {
         DetailRow(stringResource(R.string.stats_detail_started), StatsFormat.dateTime(summary.startedAtWallMillis))
@@ -137,6 +146,15 @@ private fun SummaryCard(summary: ChargeSessionSummary) {
         DetailRow(stringResource(R.string.stats_detail_level), StatsFormat.percentRange(summary.startPercent, summary.endPercent))
         DetailRow(stringResource(R.string.stats_detail_duration), StatsFormat.duration(summary.durationMillis) ?: notReported)
         DetailRow(stringResource(R.string.stats_detail_charging_type), stringResource(chargingTypeLabel(summary.chargingType)))
+        // Live, and only for the still-open session the caller vouched for: a closed session's numbers
+        // are all history, and a "now" row beside them would belong to a different charge.
+        if (readout != null && summary.endedAtWallMillis == null) {
+            DetailRow(
+                stringResource(R.string.stats_detail_power_now),
+                StatsFormat.power(StatsPowerCalculator.chargeMilliwatts(readout))
+                    ?: stringResource(chargePowerFallbackRes(BatteryEffect.from(readout))),
+            )
+        }
         DetailRow(stringResource(R.string.stats_detail_avg_power), StatsFormat.power(summary.avgPowerMilliwatts) ?: notReported)
         DetailRow(stringResource(R.string.stats_detail_peak_power), StatsFormat.power(summary.peakPowerMilliwatts) ?: notReported)
         DetailRow(
@@ -174,39 +192,64 @@ private fun DetailRow(label: String, value: String) {
     }
 }
 
+private val previewCurve = (0..20).map { i ->
+    ChargeCurvePoint(
+        elapsedFromStartMillis = i * 180_000L,
+        percent = (42 + i * 3).coerceAtMost(100),
+        powerMilliwatts = (25_000 - i * 900).coerceAtLeast(1_500),
+        temperatureTenthsC = 300 + i * 2,
+    )
+}
+
+private val previewSummary = ChargeSessionSummary(
+    id = 1,
+    startedAtWallMillis = System.currentTimeMillis() - 3_600_000,
+    endedAtWallMillis = System.currentTimeMillis(),
+    durationMillis = 3_600_000,
+    startPercent = 42,
+    endPercent = 100,
+    chargingType = ChargingType.AC,
+    avgPowerMilliwatts = 12_000,
+    peakPowerMilliwatts = 25_000,
+    minTemperatureTenthsC = 300,
+    avgTemperatureTenthsC = 320,
+    maxTemperatureTenthsC = 340,
+    limitHit = false,
+    partial = false,
+    fullReachedAtWallMillis = System.currentTimeMillis() - 60_000,
+    sealReason = StatsSealReason.UNPLUGGED,
+)
+
 @AmplyPreview
 @Composable
 private fun StatsSessionDetailScreenPreview() = PreviewWrapper {
-    val start = 0L
-    val curve = (0..20).map { i ->
-        ChargeCurvePoint(
-            elapsedFromStartMillis = start + i * 180_000L,
-            percent = (42 + i * 3).coerceAtMost(100),
-            powerMilliwatts = (25_000 - i * 900).coerceAtLeast(1_500),
-            temperatureTenthsC = 300 + i * 2,
-        )
-    }
+    StatsSessionDetailScreen(
+        state = StatsDetailState(summary = previewSummary, curve = previewCurve),
+        readout = null,
+        onBack = {},
+    )
+}
+
+@AmplyPreview
+@Composable
+private fun StatsSessionDetailScreenLivePreview() = PreviewWrapper {
+    // The open session that is charging right now: only here does the summary carry a "Power now".
     StatsSessionDetailScreen(
         state = StatsDetailState(
-            summary = ChargeSessionSummary(
-                id = 1,
-                startedAtWallMillis = System.currentTimeMillis() - 3_600_000,
-                endedAtWallMillis = System.currentTimeMillis(),
-                durationMillis = 3_600_000,
-                startPercent = 42,
-                endPercent = 100,
-                chargingType = ChargingType.AC,
-                avgPowerMilliwatts = 12_000,
-                peakPowerMilliwatts = 25_000,
-                minTemperatureTenthsC = 300,
-                avgTemperatureTenthsC = 320,
-                maxTemperatureTenthsC = 340,
-                limitHit = false,
-                partial = false,
-                fullReachedAtWallMillis = System.currentTimeMillis() - 60_000,
-                sealReason = StatsSealReason.UNPLUGGED,
+            summary = previewSummary.copy(
+                endedAtWallMillis = null,
+                endPercent = 78,
+                fullReachedAtWallMillis = null,
+                sealReason = null,
             ),
-            curve = curve,
+            curve = previewCurve,
+        ),
+        readout = BatteryReadout(
+            levelPercent = 78,
+            status = android.os.BatteryManager.BATTERY_STATUS_CHARGING,
+            plugged = android.os.BatteryManager.BATTERY_PLUGGED_AC,
+            voltageMillivolts = 4_100,
+            currentNowMicroamps = 2_050_000,
         ),
         onBack = {},
     )

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

@@ -0,0 +1,115 @@
+package eu.darken.amply.main.ui.battery
+
+import android.app.Application
+import android.os.BatteryManager
+import androidx.compose.ui.test.assertCountEquals
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onAllNodesWithText
+import androidx.compose.ui.test.onNodeWithText
+import androidx.test.core.app.ApplicationProvider
+import eu.darken.amply.R
+import eu.darken.amply.battery.core.BatteryReadout
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.GraphicsMode
+
+/**
+ * The electrical section's two wattage rows. The tall qualifier renders the whole list, so a missing
+ * row is a missing row rather than one scrolled out of the viewport.
+ */
+@RunWith(RobolectricTestRunner::class)
+@GraphicsMode(GraphicsMode.Mode.NATIVE)
+@Config(qualifiers = "+h2400dp")
+class BatteryHubScreenTest {
+    @get:Rule
+    val compose = createComposeRule()
+
+    private val context = ApplicationProvider.getApplicationContext<Application>()
+
+    private fun string(res: Int): String = context.getString(res)
+
+    // Every field reported, so a "Not reported" anywhere on the screen belongs to the row under test.
+    private val charging = BatteryReadout(
+        levelPercent = 82,
+        status = BatteryManager.BATTERY_STATUS_CHARGING,
+        plugged = BatteryManager.BATTERY_PLUGGED_AC,
+        health = BatteryManager.BATTERY_HEALTH_GOOD,
+        technology = "Li-ion",
+        temperatureTenthsC = 314,
+        voltageMillivolts = 4_000,
+        currentNowMicroamps = 2_000_000,
+        chargeCounterMicroampHours = 3_800_000,
+        cycleCount = 142,
+        maxChargingCurrentMicroamps = 2_000_000,
+        maxChargingVoltageMicrovolts = 9_000_000,
+    )
+
+    private fun render(readout: BatteryReadout?) {
+        compose.setContent {
+            BatteryHubScreen(
+                readout = readout,
+                captureEnabled = true,
+                teaser = ChargeTeaserState.None,
+                onBack = {},
+                onOpenHistory = {},
+                onEnableCapture = {},
+                onOpenSession = {},
+            )
+        }
+    }
+
+    @Test
+    fun `the measured charge power and the advertised maximum are both shown`() {
+        render(charging)
+        compose.onNodeWithText(string(R.string.battery_detail_power)).assertExists()
+        // 4.0 V x 2.0 A measured at the battery...
+        compose.onNodeWithText("8.0 W").assertExists()
+        // ...against the 9 V / 2 A the charger claims it could deliver.
+        compose.onNodeWithText(string(R.string.battery_detail_charger_max)).assertExists()
+        compose.onNodeWithText("18.0 W").assertExists()
+    }
+
+    @Test
+    fun `a limit hold says the battery is not charging, not that nothing was reported`() {
+        render(charging.copy(status = BatteryManager.BATTERY_STATUS_NOT_CHARGING))
+        // The status row spells this out as "Plugged in, not charging", so this is the power row.
+        compose.onNodeWithText(string(R.string.battery_value_not_charging)).assertExists()
+    }
+
+    @Test
+    fun `unplugged there is no charge power and nothing advertised`() {
+        render(
+            charging.copy(
+                status = BatteryManager.BATTERY_STATUS_DISCHARGING,
+                plugged = 0,
+                currentNowMicroamps = -500_000,
+            ),
+        )
+        compose.onNodeWithText(string(R.string.battery_value_not_charging)).assertExists()
+        // Nothing is connected, so the advertised maximum is the screen's only "Not reported" — the
+        // extras are not read through while off the charger even when the platform left them set.
+        compose.onNodeWithText(string(R.string.battery_value_not_reported)).assertExists()
+    }
+
+    @Test
+    fun `a charger advertising nothing reports nothing rather than claiming zero`() {
+        render(
+            charging.copy(
+                maxChargingCurrentMicroamps = null,
+                maxChargingVoltageMicrovolts = null,
+            ),
+        )
+        compose.onNodeWithText("8.0 W").assertExists()
+        compose.onNodeWithText(string(R.string.battery_value_not_reported)).assertExists()
+    }
+
+    @Test
+    fun `an unreadable battery never claims the battery is not charging`() {
+        render(null)
+        compose.onNodeWithText(string(R.string.battery_detail_power)).assertExists()
+        compose.onAllNodesWithText(string(R.string.battery_value_not_charging)).assertCountEquals(0)
+    }
+}