feat(chargepilot): warn on low charge limit

Author: malys

app/src/main/java/com/evsuite/chargepilot/ChargeLimitAdvice.kt

@@ -0,0 +1,21 @@
+package com.evsuite.chargepilot
+
+/** Read-only warning when a planned charging stop cannot reach its assumed departure charge. */
+internal data class ChargeLimitAdvice(
+    val limitPercent: Int,
+    val departurePercent: Double,
+) {
+    companion object {
+        fun of(
+            usesDepartureCharge: Boolean,
+            departurePercent: Double,
+            limitPercent: Int?,
+        ): ChargeLimitAdvice? {
+            if (!usesDepartureCharge) return null
+            val limit = limitPercent?.takeIf { it in 0..100 } ?: return null
+            if (!departurePercent.isFinite() || departurePercent !in 0.0..100.0) return null
+            if (departurePercent <= limit.toDouble()) return null
+            return ChargeLimitAdvice(limit, departurePercent)
+        }
+    }
+}

app/src/main/java/com/evsuite/chargepilot/ChargeStopActivity.kt

@@ -21,6 +21,7 @@ import com.evsuite.chargepilot.route.RoutingCredentials
 import com.evsuite.chargepilot.route.RoutingTransport
 import com.evsuite.hardware.FirmwareInfo
 import com.evsuite.hardware.saic.NavigationHandoff
+import com.evsuite.hardware.saic.SaicCharging
 import com.evsuite.hardware.saic.SaicNav
 import com.evsuite.hardware.saic.SaicNavGuidance
 import com.evsuite.hardware.telemetry.ChargeStopPlan
@@ -467,13 +468,15 @@ class ChargeStopActivity : AppCompatActivity() {
                 }
                 "$body | second road=${alternative?.viaLabel ?: "none"}"
             }
+            val chargeLimitPercent = SaicCharging.chargeLimitPercent()
             runOnUiThread {
                 if (isFinishing || isDestroyed) return@runOnUiThread
                 render(
                     place, route, chain, effective, chargers, grade, whatIf, alternative,
                     motorwayFree,
                     (if (retried) 2 else 1) + (if (motorwayFree == null) 0 else 1),
                     settings.departurePercent,
+                    chargeLimitPercent,
                 )
                 announce(
                     when {
@@ -626,6 +629,7 @@ class ChargeStopActivity : AppCompatActivity() {
         motorwayFree: MotorwayFree?,
         routeRequests: Int,
         departurePercent: Double,
+        chargeLimitPercent: Int?,
     ) {
         val plan = chain?.legs?.firstOrNull()?.plan
         val charger = chargers.firstOrNull()
@@ -662,7 +666,19 @@ class ChargeStopActivity : AppCompatActivity() {
                 format(it.uncertaintyPercent, "%.1f"),
             )
         }
-        binding.chargeStopDetail.text = listOfNotNull(detail, gradeLine).joinToString("\n")
+        val chargeLimitLine = ChargeLimitAdvice.of(
+            usesDepartureCharge = chain.stops.isNotEmpty(),
+            departurePercent = departurePercent,
+            limitPercent = chargeLimitPercent,
+        )?.let {
+            getString(
+                R.string.charge_stop_limit_advice,
+                it.limitPercent,
+                format(it.departurePercent, "%.0f"),
+            )
+        }
+        binding.chargeStopDetail.text =
+            listOfNotNull(chargeLimitLine, detail, gradeLine).joinToString("\n")
 
         renderCharger(plan, chargers)
         renderWhatIf(whatIf, alternative)

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

@@ -274,6 +274,7 @@ Cette charge atteint environ %4$s à ce rythme</string>
     <string name="charge_stop_no_position">Aucune position. Le récepteur de la voiture a été interrogé et n’a rien répondu. Réessayez à ciel dégagé.</string>
     <string name="charge_stop_plan_none">Aucun arrêt nécessaire · environ %1$s %% à l’arrivée, %2$s %% au-dessus de la réserve</string>
     <string name="charge_stop_plan_stop">Recharger après environ %1$s km (± %2$s km)</string>
+    <string name="charge_stop_limit_advice">La limite de charge du véhicule est de %1$d %%, mais ce trajet prévoit de repartir d’un arrêt à %2$s %%. Relevez la limite dans le véhicule avant de recharger.</string>
     <string name="charge_stop_refused_charge">La charge est illisible : rien ne peut être planifié.</string>
     <string name="charge_stop_refused_route">Aucune longueur d’itinéraire sur laquelle planifier.</string>
     <string name="charge_stop_refused_rate">Pas encore de taux exploitable. Enregistrez quelques trajets et ceci se remplira.</string>

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

@@ -278,6 +278,7 @@ This charge reaches about %4$s at that rate</string>
     <string name="charge_stop_no_position">No position. The car\u2019s receiver was asked and answered nothing. Try again where the sky is clear.</string>
     <string name="charge_stop_plan_none">No stop needed · about %1$s %% left on arrival, %2$s %% above the reserve</string>
     <string name="charge_stop_plan_stop">Charge after about %1$s km (± %2$s km)</string>
+    <string name="charge_stop_limit_advice">Vehicle charge limit is %1$d %%, but this plan assumes leaving a charging stop at %2$s %%. Raise the limit in the vehicle before charging.</string>
     <string name="charge_stop_refused_charge">Charge is unreadable, so there is nothing to plan from.</string>
     <string name="charge_stop_refused_route">No route length to plan against.</string>
     <string name="charge_stop_refused_rate">No usable rate yet. Record a few trips and this fills in.</string>

app/src/test/java/com/evsuite/chargepilot/ChargeLimitAdviceTest.kt

@@ -0,0 +1,31 @@
+package com.evsuite.chargepilot
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class ChargeLimitAdviceTest {
+    @Test
+    fun `plan warns when charging stop departure exceeds vehicle limit`() {
+        assertEquals(
+            ChargeLimitAdvice(limitPercent = 80, departurePercent = 92.0),
+            ChargeLimitAdvice.of(
+                usesDepartureCharge = true,
+                departurePercent = 92.0,
+                limitPercent = 80,
+            ),
+        )
+    }
+
+    @Test
+    fun `sufficient or unreadable limit stays silent`() {
+        assertNull(ChargeLimitAdvice.of(true, departurePercent = 80.0, limitPercent = 80))
+        assertNull(ChargeLimitAdvice.of(true, departurePercent = 80.0, limitPercent = 90))
+        assertNull(ChargeLimitAdvice.of(true, departurePercent = 92.0, limitPercent = null))
+    }
+
+    @Test
+    fun `plan without charging stop does not claim departure target is needed`() {
+        assertNull(ChargeLimitAdvice.of(false, departurePercent = 92.0, limitPercent = 80))
+    }
+}