FullCharge: Offer persistent charge-mode actions on the gesture notification

The reconnect-gesture notification was display-only. It now carries two
actions on its standing states: the adapter's declared protective default
(named after defaultProtectivePolicy, so Adaptive-default adapters aren't
mislabelled as a percentage limit) and "Always 100%".

Both route through the existing serialized ACTION_SET_PERSISTENT_POLICY
command, the same path the widget uses, so they inherit its writability
guard, recovery-target persistence before the risky write, session
cancel-without-restore, forced re-write and surface updates. No new write
path and no change to the writable-setting allowlist.

Actions are attached on IDLE and ARMED only — an explicit allowlist rather
than "not the countdown", because TRIGGER also reaches the builder and a
tick that is starting a full charge must not offer a competing persistent
write. The two PendingIntents differ only in an extra, which does not
factor into PendingIntent equality, so they use distinct request codes.

setPersistentPolicy's refusal branch now posts the recovery notification:
the widget and tile pre-check writability and open the app instead of
dispatching, but a notification action cannot, so its tap would otherwise
be a silent no-op.

Author: d4rken

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

@@ -427,6 +427,9 @@ class ChargeSessionService : Service() {
                 SessionNotifications.gesture(
                     this,
                     decision = decision,
+                    // The notification's mode actions write persistently, so they must offer this
+                    // adapter's declared protective default, not a hardcoded limit.
+                    protectPolicy = adapter.defaultProtectivePolicy,
                     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
@@ -643,6 +646,10 @@ class ChargeSessionService : Service() {
         // would strand a pending target that never converges. The app's controls guide setup.
         if (!repository.refresh().canApply) {
             log(TAG, Logging.Priority.WARN) { "Persistent policy skipped: charging control not writable" }
+            // Tell the user why nothing happened. The widget/tile pre-check writability and open the
+            // app instead of dispatching, but a notification action cannot pre-check, so without this
+            // its tap is a silent no-op (it also covers a surface racing a lost write capability).
+            SessionNotifications.showRecovery(this, R.string.recovery_notification_body_unavailable)
             SurfaceUpdater.updateNow(this)
             continueGestureOrStop()
             return

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

@@ -13,6 +13,7 @@ import androidx.core.content.ContextCompat
 import android.content.pm.PackageManager
 import android.os.Build
 import eu.darken.amply.R
+import eu.darken.amply.charging.core.ChargePolicy
 import eu.darken.amply.main.ui.MainActivity
 
 object SessionNotifications {
@@ -146,9 +147,15 @@ object SessionNotifications {
             .build()
     }
 
+    /**
+     * [protectPolicy] is the adapter's declared protective default and has no default value on
+     * purpose: the action writes it persistently, so the capability has to be handed in by the
+     * caller that resolved the adapter rather than guessed here.
+     */
     fun gesture(
         context: Context,
         decision: QuickFullChargeDecision,
+        protectPolicy: ChargePolicy,
         anyLevel: Boolean = false,
         limitPercent: Int? = null,
     ): Notification {
@@ -208,9 +215,53 @@ object SessionNotifications {
                 ),
             )
         }
+        // Mode switches only on the two standing states. An explicit allowlist, not "not
+        // WAITING_FOR_RECONNECT": TRIGGER also reaches this builder, and neither the 10s countdown
+        // nor the tick that starts a full charge should offer a competing persistent write.
+        if (decision == QuickFullChargeDecision.IDLE || decision == QuickFullChargeDecision.ARMED) {
+            builder
+                .addAction(
+                    R.drawable.ic_launcher_monochrome,
+                    protectActionLabel(context, protectPolicy),
+                    persistentPolicyIntent(context, 8, protectPolicy),
+                )
+                .addAction(
+                    R.drawable.ic_launcher_monochrome,
+                    context.getString(R.string.gesture_notification_action_always_full),
+                    persistentPolicyIntent(context, 9, ChargePolicy.Unrestricted),
+                )
+        }
         return builder.build()
     }
 
+    /** Mirrors the widget's protect-button naming; other policies are not protective defaults today. */
+    private fun protectActionLabel(context: Context, policy: ChargePolicy): String = when (policy) {
+        is ChargePolicy.FixedLimit -> context.getString(
+            R.string.gesture_notification_action_protect_fixed,
+            policy.percent,
+        )
+        ChargePolicy.Adaptive -> context.getString(R.string.gesture_notification_action_protect_adaptive)
+        else -> context.getString(R.string.gesture_notification_action_protect)
+    }
+
+    /**
+     * Both actions share [ChargeSessionService.ACTION_SET_PERSISTENT_POLICY] and differ only in an
+     * extra, which does NOT factor into PendingIntent equality — hence the distinct [requestCode]
+     * per action, or the second would overwrite the first's target.
+     */
+    private fun persistentPolicyIntent(
+        context: Context,
+        requestCode: Int,
+        policy: ChargePolicy,
+    ): PendingIntent = PendingIntent.getForegroundService(
+        context,
+        requestCode,
+        Intent(context, ChargeSessionService::class.java)
+            .setAction(ChargeSessionService.ACTION_SET_PERSISTENT_POLICY)
+            .putExtra(ChargeSessionService.EXTRA_TARGET_POLICY, policy.stableId),
+        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+    )
+
     /**
      * Progress while a restore converges on the charging hardware. Deliberately shares
      * [SESSION_CHANNEL] with [session] rather than the alerting recovery channel: this is the

app/src/main/res/values/strings.xml

@@ -21,11 +21,16 @@
     <string name="gesture_notification_armed_holding">Ready while your charge limit is holding: unplug for 2 seconds, then replug within 10 to charge fully.</string>
     <string name="gesture_notification_waiting_any_level">Waiting for a quick unplug and reconnect at any charge level.</string>
     <string name="gesture_notification_disable_hint">You can turn this notification off (long-press it) without stopping the gesture.</string>
+    <string name="gesture_notification_action_protect_fixed">Limit to %1$d%%</string>
+    <string name="gesture_notification_action_protect_adaptive">Adaptive charging</string>
+    <string name="gesture_notification_action_protect">Charge limit</string>
+    <string name="gesture_notification_action_always_full" formatted="false">Always 100%</string>
     <string name="recovery_channel_name">Charge policy recovery</string>
     <string name="recovery_channel_description">Alerts you when your protective charge limit could not be restored</string>
     <string name="recovery_notification_title">Charge limit needs attention</string>
     <string name="recovery_notification_body">Open Amply and restart Shizuku to restore your protective policy.</string>
     <string name="recovery_notification_body_convergence">The protective policy was rewritten, but the charging hardware has not confirmed it yet. Open Amply to check.</string>
+    <string name="recovery_notification_body_unavailable">Your charge mode wasn\'t changed — charging control isn\'t available right now. Open Amply to check your setup.</string>
     <string name="recovering_notification_title">Restoring charge limit</string>
     <string name="recovering_notification_body">Confirming the protective policy with the charging hardware.</string>
     <string name="setup_unsupported_title">This device isn\'t supported yet</string>

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

@@ -1,16 +1,20 @@
 package eu.darken.amply.fullcharge.core
 
+import android.app.Application
 import android.app.Notification
+import android.content.ComponentName
 import android.content.Context
 import androidx.test.core.app.ApplicationProvider
 import eu.darken.amply.R
+import eu.darken.amply.charging.core.ChargePolicy
 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
+import org.robolectric.Shadows.shadowOf
 import org.robolectric.annotation.Config
 
 @RunWith(RobolectricTestRunner::class)
@@ -19,12 +23,33 @@ class SessionNotificationsGestureTest {
 
     private val context: Context = ApplicationProvider.getApplicationContext()
 
+    private fun notification(
+        decision: QuickFullChargeDecision,
+        protectPolicy: ChargePolicy = ChargePolicy.FixedLimit(80),
+        anyLevel: Boolean = false,
+        limitPercent: Int? = null,
+    ): Notification = SessionNotifications.gesture(
+        context,
+        decision = decision,
+        protectPolicy = protectPolicy,
+        anyLevel = anyLevel,
+        limitPercent = limitPercent,
+    )
+
+    private fun actions(
+        decision: QuickFullChargeDecision,
+        protectPolicy: ChargePolicy = ChargePolicy.FixedLimit(80),
+    ): List<Notification.Action> = notification(decision, protectPolicy).actions?.toList().orEmpty()
+
+    private fun targetPolicyOf(action: Notification.Action): String? = shadowOf(action.actionIntent)
+        .savedIntent
+        .getStringExtra(ChargeSessionService.EXTRA_TARGET_POLICY)
+
     private fun text(
         decision: QuickFullChargeDecision,
         anyLevel: Boolean = false,
         limitPercent: Int? = null,
-    ): String? = SessionNotifications
-        .gesture(context, decision = decision, anyLevel = anyLevel, limitPercent = limitPercent)
+    ): String? = notification(decision, anyLevel = anyLevel, limitPercent = limitPercent)
         .extras
         .getCharSequence(Notification.EXTRA_TEXT)
         ?.toString()
@@ -33,8 +58,7 @@ class SessionNotificationsGestureTest {
         decision: QuickFullChargeDecision,
         anyLevel: Boolean = false,
         limitPercent: Int? = null,
-    ): String? = SessionNotifications
-        .gesture(context, decision = decision, anyLevel = anyLevel, limitPercent = limitPercent)
+    ): String? = notification(decision, anyLevel = anyLevel, limitPercent = limitPercent)
         .extras
         .getCharSequence(Notification.EXTRA_BIG_TEXT)
         ?.toString()
@@ -98,4 +122,63 @@ class SessionNotificationsGestureTest {
         bigText(QuickFullChargeDecision.ARMED)!! shouldContain hint
         bigText(QuickFullChargeDecision.WAITING_FOR_RECONNECT) shouldBe null
     }
+
+    @Test
+    fun `only the standing states offer the mode actions`() {
+        actions(QuickFullChargeDecision.IDLE).size shouldBe 2
+        actions(QuickFullChargeDecision.ARMED).size shouldBe 2
+        actions(QuickFullChargeDecision.WAITING_FOR_RECONNECT).size shouldBe 0
+        actions(QuickFullChargeDecision.TRIGGER).size shouldBe 0
+    }
+
+    @Test
+    fun `the protect action is labelled after the adapter's protective default`() {
+        actions(QuickFullChargeDecision.IDLE, ChargePolicy.FixedLimit(80))[0].title.toString() shouldBe
+            context.getString(R.string.gesture_notification_action_protect_fixed, 80)
+        actions(QuickFullChargeDecision.IDLE, ChargePolicy.Adaptive)[0].title.toString() shouldBe
+            context.getString(R.string.gesture_notification_action_protect_adaptive)
+        actions(QuickFullChargeDecision.IDLE, ChargePolicy.PauseAtFull)[0].title.toString() shouldBe
+            context.getString(R.string.gesture_notification_action_protect)
+    }
+
+    @Test
+    fun `the protect action targets the passed policy and the other one always full`() {
+        targetPolicyOf(actions(QuickFullChargeDecision.IDLE, ChargePolicy.FixedLimit(80))[0]) shouldBe "fixed:80"
+        targetPolicyOf(actions(QuickFullChargeDecision.IDLE, ChargePolicy.Adaptive)[0]) shouldBe "adaptive"
+        targetPolicyOf(actions(QuickFullChargeDecision.IDLE)[1]) shouldBe "unrestricted"
+    }
+
+    @Test
+    fun `both actions are distinct foreground-service intents for the session service`() {
+        val (protect, alwaysFull) = actions(QuickFullChargeDecision.ARMED)
+
+        listOf(protect, alwaysFull).forEach { action ->
+            val shadow = shadowOf(action.actionIntent)
+            shadow.isForegroundService shouldBe true
+            shadow.savedIntent.component shouldBe
+                ComponentName(context, ChargeSessionService::class.java)
+            shadow.savedIntent.action shouldBe ChargeSessionService.ACTION_SET_PERSISTENT_POLICY
+        }
+        // Extras don't factor into PendingIntent equality — only the distinct request codes keep
+        // the second action from overwriting the first one's target.
+        protect.actionIntent shouldNotBe alwaysFull.actionIntent
+    }
+
+    @Test
+    fun `sending an action starts the session service with its policy`() {
+        val application: Application = ApplicationProvider.getApplicationContext()
+        val (protect, alwaysFull) = actions(QuickFullChargeDecision.IDLE, ChargePolicy.Adaptive)
+        shadowOf(application).clearStartedServices()
+
+        protect.actionIntent.send()
+        val protectStart = shadowOf(application).nextStartedService
+        protectStart.component shouldBe ComponentName(context, ChargeSessionService::class.java)
+        protectStart.action shouldBe ChargeSessionService.ACTION_SET_PERSISTENT_POLICY
+        protectStart.getStringExtra(ChargeSessionService.EXTRA_TARGET_POLICY) shouldBe "adaptive"
+
+        alwaysFull.actionIntent.send()
+        val alwaysFullStart = shadowOf(application).nextStartedService
+        alwaysFullStart.action shouldBe ChargeSessionService.ACTION_SET_PERSISTENT_POLICY
+        alwaysFullStart.getStringExtra(ChargeSessionService.EXTRA_TARGET_POLICY) shouldBe "unrestricted"
+    }
 }