FullCharge: State the gesture firing condition in the armed notification

The armed gesture notification passed the latched arming basis
(anyLevelBasis) into the copy. At a holding limit the LIMIT_HOLD branch
wins the latch, so a device sitting at 80% with "Any charge level" on
rendered the identical "Ready at your 80% limit" text as with the option
off - understating a gesture that will in fact re-arm and fire at any
charge level.

The armed and waiting-for-reconnect states now pass the condition the
gesture fires under: the any-level option being on AND its policy
evidence currently PROTECTIVE. Requiring PROTECTIVE evidence avoids the
opposite error of claiming "any charge level" when the option is on but
nothing protective is detected. Idle copy keeps describing the enabled
mode. The engine is untouched, and anyLevelBasis remains in the DEBUG
log line, where the actually-latched basis is the right thing to record.

Fixes review finding F4.

Author: d4rken

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

@@ -448,11 +448,17 @@ class ChargeSessionService : Service() {
                 SessionNotifications.gesture(
                     this,
                     decision = decision,
-                    // Armed copy reflects what actually armed; idle copy explains the enabled mode.
                     anyLevel = when (decision) {
+                        // The armed copy states the condition the gesture will fire under. The
+                        // latched basis is not that condition: at the limit, LIMIT_HOLD wins the
+                        // latch even while any-level is on and qualifying, and naming the limit
+                        // there would understate a gesture that will in fact fire at any level.
+                        // Requiring PROTECTIVE evidence keeps it from overstating in the opposite
+                        // direction, when the option is on but nothing protective is detected.
                         QuickFullChargeDecision.ARMED,
                         QuickFullChargeDecision.WAITING_FOR_RECONNECT,
-                        -> output.anyLevelBasis
+                        -> anyLevel && policyEvidence == PolicyEvidence.PROTECTIVE
+                        // Idle copy explains the enabled mode rather than a live basis.
                         else -> anyLevel
                     },
                     // Verified evidence only, never Amply's write journal: naming a number is a

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

@@ -140,10 +140,11 @@ object SessionNotifications {
             PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
         )
         // Three distinct states, not two. WAITING_FOR_RECONNECT is the time-critical countdown and
-        // stays a bare instruction — the arming basis is history by then. ARMED is what a plugged-in
-        // user actually sees, for hours, so that is where the arming basis (any level vs. a named
-        // limit vs. a generic hold) has to be spelled out. IDLE keeps the passive "waiting" copy,
-        // which explains the enabled mode rather than the current basis.
+        // stays a bare instruction — how the gesture armed is history by then. ARMED is what a
+        // plugged-in user actually sees, for hours, so that is where the condition the gesture will
+        // fire under (any level vs. a named limit vs. a generic hold) has to be spelled out — the
+        // caller passes that condition, not whichever basis happened to latch first. IDLE keeps the
+        // passive "waiting" copy, which explains the enabled mode rather than the current basis.
         val contentText = when (decision) {
             QuickFullChargeDecision.WAITING_FOR_RECONNECT -> context.getString(
                 R.string.gesture_notification_armed,

app/src/test/java/eu/darken/amply/fullcharge/core/SessionNotificationsGestureTest.kt

@@ -7,6 +7,7 @@ import eu.darken.amply.R
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
 import io.kotest.matchers.string.shouldContain
+import io.kotest.matchers.string.shouldNotContain
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
@@ -67,6 +68,20 @@ class SessionNotificationsGestureTest {
             text(QuickFullChargeDecision.IDLE, anyLevel = true)
     }
 
+    @Test
+    fun `armed at a known limit names no percentage once any level qualifies`() {
+        // The device sitting at its holding limit is the common state: the caller must pass the
+        // condition the gesture fires under, so the any-level copy must not name the limit there.
+        val atLimitAnyLevel = text(QuickFullChargeDecision.ARMED, anyLevel = true, limitPercent = 80)
+        val atLimitOnly = text(QuickFullChargeDecision.ARMED, limitPercent = 80)
+
+        atLimitAnyLevel shouldBe
+            context.getString(R.string.gesture_notification_armed_any_level)
+        atLimitOnly shouldBe
+            context.getString(R.string.gesture_notification_armed_limit, 80)
+        atLimitAnyLevel!! shouldNotContain "80%"
+    }
+
     @Test
     fun `the reconnect countdown ignores the arming basis`() {
         val plain = text(QuickFullChargeDecision.WAITING_FOR_RECONNECT)