Merge remote-tracking branch 'origin/main' into feat/stats-chart-dual-axes

# Conflicts:
#	app/src/main/java/eu/darken/amply/stats/ui/StatsCurrentSessionCard.kt

Author: d4rken

app/src/debug/java/eu/darken/amply/screenshots/ScreenshotContent.kt

@@ -88,6 +88,7 @@ private fun DashboardShot(state: DashboardUiState) = PreviewWrapper {
         onOpenBatteryDetail = {},
         onOpenStats = {},
         onOpenLiveSession = {},
+        onRetryCapture = {},
         onPinWidget = {},
         onAddTile = {},
         onDismissQuickAccess = {},
@@ -103,6 +104,7 @@ private fun DashboardShot(state: DashboardUiState) = PreviewWrapper {
         onOpenSupportIssue = {},
         onEmailSupport = {},
         onHelp = {},
+        onDismissInterruption = {},
     )
 }
 

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

@@ -81,7 +81,7 @@ private fun ChargingSection(readout: BatteryReadout) {
         )
         DetailRow(
             stringResource(R.string.battery_detail_status),
-            stringResource(batteryStatusLabel(readout.status)),
+            stringResource(batteryStatusLabel(readout.status, readout.plugged)),
         )
         DetailRow(
             stringResource(R.string.battery_detail_power_source),

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

@@ -9,11 +9,20 @@ import eu.darken.amply.R
  * constants fall back to a generic label rather than crashing or hiding the row.
  */
 
+/**
+ * A bare "Not charging" on a connected device (held at a charge limit — Amply's core scenario)
+ * reads as if the charger weren't detected, so that combination gets an explicit "plugged in"
+ * wording. Other statuses pass through: "Charging"/"Full" already imply a connection.
+ */
 @StringRes
-internal fun batteryStatusLabel(status: Int?): Int = when (status) {
+internal fun batteryStatusLabel(status: Int?, plugged: Int?): Int = when (status) {
     BatteryManager.BATTERY_STATUS_CHARGING -> R.string.battery_status_charging
     BatteryManager.BATTERY_STATUS_DISCHARGING -> R.string.battery_status_discharging
-    BatteryManager.BATTERY_STATUS_NOT_CHARGING -> R.string.battery_status_not_charging
+    BatteryManager.BATTERY_STATUS_NOT_CHARGING -> if ((plugged ?: 0) != 0) {
+        R.string.battery_status_plugged_not_charging
+    } else {
+        R.string.battery_status_not_charging
+    }
     BatteryManager.BATTERY_STATUS_FULL -> R.string.battery_status_full
     else -> R.string.battery_value_unknown
 }

app/src/main/java/eu/darken/amply/fullcharge/core/BootRecoveryFlow.kt

@@ -54,10 +54,30 @@ class BootRecoveryFlow(private val hooks: Hooks) {
         SUPERSEDED,
     }
 
-    suspend fun run(): Outcome {
+    /**
+     * Outcome plus the facts an interruption assessor needs to decide whether the flow actually did
+     * restore work: [restoreAttempted] (the flow called [Hooks.restoreSession]), [rewrites] (re-write
+     * attempts issued, including a failed final one), and [retryRemaining] (a pending target is still
+     * persisted on exit, so a later start will retry).
+     */
+    data class Result(
+        val outcome: Outcome,
+        val restoreAttempted: Boolean,
+        val rewrites: Int,
+        val retryRemaining: Boolean,
+    )
+
+    suspend fun run(): Result {
+        var restoreAttempted = false
+        var rewrites = 0
         val sessionTarget = hooks.currentSessionTarget()
         val pendingTarget = hooks.pendingTarget()
-        val target = pendingTarget ?: sessionTarget ?: return Outcome.NOTHING_TO_DO
+        val target = pendingTarget ?: sessionTarget ?: return Result(
+            outcome = Outcome.NOTHING_TO_DO,
+            restoreAttempted = false,
+            rewrites = 0,
+            retryRemaining = false,
+        )
         var staleIntended: ChargePolicy? = null
         if (pendingTarget != null) {
             // The pending target is always the newest intent: setPersistentPolicy persists it
@@ -76,17 +96,22 @@ class BootRecoveryFlow(private val hooks: Hooks) {
         } else {
             hooks.setPendingTarget(target)
             log(TAG) { "Recovery: restoring ${target.stableId}" }
+            restoreAttempted = true
             if (!hooks.restoreSession()) {
                 log(TAG, Logging.Priority.ERROR) { "Restore failed; session remains persisted" }
                 hooks.notifyFailure(writeFailed = true)
                 hooks.clearPendingTarget()
-                return Outcome.RESTORE_FAILED
+                return Result(
+                    outcome = Outcome.RESTORE_FAILED,
+                    restoreAttempted = true,
+                    rewrites = rewrites,
+                    retryRemaining = false,
+                )
             }
         }
 
         val startedAt = hooks.elapsedRealtime()
         var lastWriteAt = startedAt
-        var rewrites = 0
         while (true) {
             hooks.tick()
             val intended = hooks.intendedTarget()
@@ -95,7 +120,12 @@ class BootRecoveryFlow(private val hooks: Hooks) {
                 // were converging; never write the boot target over a newer choice.
                 log(TAG) { "Boot recovery superseded by ${intended.stableId}" }
                 hooks.clearPendingTarget()
-                return Outcome.SUPERSEDED
+                return Result(
+                    outcome = Outcome.SUPERSEDED,
+                    restoreAttempted = restoreAttempted,
+                    rewrites = rewrites,
+                    retryRemaining = false,
+                )
             }
             val now = hooks.elapsedRealtime()
             val snapshot = hooks.batterySnapshot()
@@ -121,22 +151,37 @@ class BootRecoveryFlow(private val hooks: Hooks) {
                         // write) should be retried by the next service start.
                         log(TAG, Logging.Priority.ERROR) { "Boot recovery re-write failed" }
                         hooks.notifyFailure(writeFailed = true)
-                        return Outcome.GAVE_UP
+                        return Result(
+                            outcome = Outcome.GAVE_UP,
+                            restoreAttempted = restoreAttempted,
+                            rewrites = rewrites,
+                            retryRemaining = true,
+                        )
                     }
                     lastWriteAt = hooks.elapsedRealtime()
                 }
                 RecoveryDecision.DONE_OK -> {
                     log(TAG) { "Boot recovery finished for ${target.stableId}" }
                     hooks.clearPendingTarget()
-                    return Outcome.CONVERGED
+                    return Result(
+                        outcome = Outcome.CONVERGED,
+                        restoreAttempted = restoreAttempted,
+                        rewrites = rewrites,
+                        retryRemaining = false,
+                    )
                 }
                 RecoveryDecision.GIVE_UP -> {
                     log(TAG, Logging.Priority.ERROR) {
                         "Boot recovery: hardware did not converge to ${target.stableId}"
                     }
                     hooks.notifyFailure(writeFailed = false)
                     hooks.clearPendingTarget()
-                    return Outcome.GAVE_UP
+                    return Result(
+                        outcome = Outcome.GAVE_UP,
+                        restoreAttempted = restoreAttempted,
+                        rewrites = rewrites,
+                        retryRemaining = false,
+                    )
                 }
             }
         }

app/src/main/java/eu/darken/amply/fullcharge/core/ChargeSessionManager.kt

@@ -8,6 +8,7 @@ import eu.darken.amply.charging.core.ChargingPreferences
 import eu.darken.amply.fullcharge.core.FullChargeStore
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
+import java.util.UUID
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -16,6 +17,8 @@ class ChargeSessionManager @Inject constructor(
     private val repository: ChargingRepository,
     private val preferences: ChargingPreferences,
     private val sessionStore: FullChargeStore,
+    private val processIdentity: ProcessIdentity,
+    private val bootCountProvider: BootCountProvider,
 ) {
     private val mutex = Mutex()
 
@@ -74,8 +77,20 @@ class ChargeSessionManager @Inject constructor(
         }
         val restorePolicy = (decision as SessionStartDecision.Start).restorePolicy
 
-        // Persist recovery state before removing the limit.
-        sessionStore.startSession(restorePolicy, nowMillis)
+        // Persist recovery state before removing the limit. Stamp this process's identity so a later
+        // pickup can tell whether the session survived a process death (interruption detection), and a
+        // stable work id that survives ownership adoption so a later restore can resolve the warning.
+        sessionStore.startSession(
+            restorePolicy = restorePolicy,
+            startedAtMillis = nowMillis,
+            workId = UUID.randomUUID().toString(),
+            provenance = WorkProvenance(
+                token = processIdentity.token,
+                pid = processIdentity.pid,
+                bootCount = bootCountProvider.current(),
+                createdAtMillis = nowMillis,
+            ),
+        )
         val result = repository.applyTemporary(overridePolicy)
         if (result.success) {
             result