add screen and capture for statistics

Author: SliDeeN

app/src/main/java/com/mg4/control/hardware/EnergyProbe.kt

@@ -104,7 +104,9 @@ object EnergyProbe {
         Signal("Odomètre AOSP", 0x11600204, null),
         Signal("Kilométrage total SAIC", 0x21401566, null),
         // Candidats à un odomètre plus fin que le kilomètre entier : le premier est dans la liste
-        // énumérée par le gestionnaire BMS, les deux autres viennent du combiné.
+        // énumérée par le gestionnaire BMS, les deux autres viennent du combiné. ⚠️ Tous à ZÉRO sur
+        // SWI133 (relevé du 2026-09-20) — d'où l'intégration de la vitesse dans StatsTracker. Gardés
+        // pour vérifier si un firmware A9 répond, eux.
         Signal("Odomètre BMS", 0x2140f447, BMS_SERVICE, validity = 0x2120f448),
         Signal("Odomètre combiné", 0x21407b13, null),
         Signal("Trajet combiné : départ", 0x21407b86, null),

app/src/main/java/com/mg4/control/hardware/EnergyReader.kt

@@ -82,6 +82,8 @@ object EnergyReader {
             // Pas de propriété de puissance : c'est le produit, le courant étant négatif en charge.
             powerKw = if (volts != null && amperes != null) -volts * amperes / 1000f else null,
             rangeKm = int(PROP_RANGE)?.takeIf { it in 1..1500 },
+            // Déjà en km/h chez SAIC malgré la spec AOSP : voir MG4Hardware.getVehicleSpeedKmh().
+            speedKmh = MG4Hardware.getVehicleSpeedKmh()?.takeIf { it in 0f..300f },
             outsideTempC = MG4Hardware.getOutsideTempCelsius(),
         )
     }
@@ -90,6 +92,10 @@ object EnergyReader {
      * Capacité de la batterie annoncée par le véhicule, en kWh — `null` si la propriété ne répond
      * pas ou rend une valeur invraisemblable.
      *
+     * **La MG4 ne la publie pas** : sondée le 2026-09-20 sur SWI133, la propriété rend 0,0. Le
+     * réglage manuel reste donc la seule source. La lecture est gardée parce qu'elle ne coûte rien
+     * et que les firmwares A9 pourraient, eux, répondre.
+     *
      * AOSP la donne en Wh ; certains véhicules la publient déjà en kWh, d'où les deux échelles
      * acceptées. Elle sert de valeur par défaut au réglage de l'onglet Statistiques : c'est mieux
      * qu'un 62 arbitraire, sans priver l'utilisateur du dernier mot — la valeur annoncée peut être

app/src/main/java/com/mg4/control/hardware/StatsCollector.kt

@@ -27,6 +27,13 @@ object StatsCollector {
     /** Assez fin pour dater un trajet à la demi-minute, assez lâche pour ne rien coûter. */
     private const val TICK_MS = 30_000L
 
+    /**
+     * Cadence en roulant. La distance vient de l'intégration de la vitesse, faute d'odomètre plus
+     * fin que le kilomètre : à trente secondes, un trapèze couvrirait un demi-kilomètre de route
+     * sur une seule droite, et l'intégration ne ferait pas mieux que l'odomètre qu'elle remplace.
+     */
+    private const val TICK_DRIVING_MS = 10_000L
+
     private val thread = HandlerThread("mg4-stats").apply { start() }
     private val worker = Handler(thread.looper)
 
@@ -41,13 +48,26 @@ object StatsCollector {
      * boîtier s'apprête à couper l'application. Attendre le tic suivant, trente secondes plus tard,
      * revenait à jouer le trajet à pile ou face : on relève donc **immédiatement** au changement.
      */
-    private val readyListener = ReadyWatcher.Listener { _, _ -> worker.post { sample() } }
+    private val readyListener = ReadyWatcher.Listener { _, _ ->
+        worker.post {
+            if (running) {
+                sample()
+                // La cadence dépend du contact : on la réarme tout de suite au lieu d'attendre
+                // un tic qui peut être à trente secondes.
+                worker.removeCallbacks(tick)
+                worker.postDelayed(tick, interval())
+            }
+        }
+    }
+
+    private fun interval(): Long =
+        if (ReadyWatcher.ready == true) TICK_DRIVING_MS else TICK_MS
 
     private val tick = object : Runnable {
         override fun run() {
             if (!running) return
             sample()
-            worker.postDelayed(this, TICK_MS)
+            worker.postDelayed(this, interval())
         }
     }
 

app/src/main/java/com/mg4/control/model/EnergySnapshot.kt

@@ -33,6 +33,13 @@ data class EnergySnapshot(
     val powerKw: Float? = null,
     /** Autonomie annoncée par la voiture, en kilomètres. */
     val rangeKm: Int? = null,
+    /**
+     * Vitesse instantanée en km/h, toujours positive.
+     *
+     * C'est la seule voie vers une distance plus fine que le kilomètre : sondés le 2026-09-20,
+     * l'odomètre AOSP, celui du combiné et la carte de trajet rendent tous zéro sur SWI133.
+     */
+    val speedKmh: Float? = null,
     /** Température extérieure en °C, pour expliquer une consommation. */
     val outsideTempC: Float? = null,
 ) {

app/src/main/java/com/mg4/control/model/StatsPending.kt

@@ -23,6 +23,15 @@ data class PendingTrip(
     val climateLast: Float?,
     val accessoriesLast: Float?,
     val regenLast: Float?,
+    /** Distance accumulée en intégrant la vitesse, en km. Voir [Trip.integratedKm]. */
+    val integratedKm: Float = 0f,
+    /** Vitesse du relevé précédent, l'autre côté du trapèze. */
+    val lastSpeedKmh: Float? = null,
+    /**
+     * Vrai dès qu'un intervalle a pu être intégré. Sans ce drapeau, une distance de 0 km ne se
+     * distinguerait pas d'une distance jamais mesurée — et l'écran annoncerait un trajet immobile.
+     */
+    val integrated: Boolean = false,
 )
 
 data class PendingCharge(

app/src/main/java/com/mg4/control/model/StatsRecords.kt

@@ -1,5 +1,6 @@
 package com.mg4.control.model
 
+import kotlin.math.abs
 import kotlin.math.max
 import kotlin.math.roundToInt
 
@@ -12,6 +13,10 @@ import kotlin.math.roundToInt
 data class Trip(
     val startMs: Long,
     val endMs: Long,
+    /**
+     * Distance lue sur l'odomètre du véhicule, **au kilomètre entier** — c'est tout ce qu'il
+     * publie. Elle sert de contrôle à [integratedKm], plus fine mais susceptible de dériver.
+     */
     val distanceKm: Int,
     /**
      * Énergie **brute** relevée sur le compteur du véhicule : la régénération n'en est PAS déduite.
@@ -27,9 +32,36 @@ data class Trip(
     val socStart: Float?,
     val socEnd: Float?,
     val outsideTempC: Float?,
+    /**
+     * Distance obtenue en intégrant la vitesse, au dixième de kilomètre.
+     *
+     * L'odomètre du véhicule est entier et aucune autre source n'a répondu (sondés le 2026-09-20 :
+     * odomètre AOSP, odomètre du combiné, carte de trajet — tous à zéro). Null sur les trajets
+     * enregistrés avant cette mesure, et null si la vitesse n'a jamais pu être relevée.
+     */
+    val integratedKm: Float? = null,
 ) {
     val durationMs: Long get() = max(0L, endMs - startMs)
 
+    /**
+     * Distance retenue pour l'affichage et les ratios.
+     *
+     * L'intégration l'emporte quand elle existe ET qu'elle concorde avec l'odomètre : elle est dix
+     * fois plus fine. En cas de désaccord franc — plus de 2 km ou 15 % —, on retombe sur
+     * l'odomètre : lui ne dérive jamais, et un tel écart trahirait des relevés manqués plutôt
+     * qu'une meilleure mesure.
+     */
+    val distance: Float
+        get() {
+            val integre = integratedKm ?: return distanceKm.toFloat()
+            if (distanceKm <= 0) return integre
+            val ecart = abs(integre - distanceKm)
+            return if (ecart <= max(2f, distanceKm * 0.15f)) integre else distanceKm.toFloat()
+        }
+
+    /** Vrai quand la distance affichée vient de l'intégration, donc connue au dixième. */
+    val distancePrecise: Boolean get() = integratedKm != null && distance == integratedKm
+
     /**
      * Énergie réellement sortie de la batterie : brute moins ce que la régénération a rendu.
      *
@@ -42,13 +74,13 @@ data class Trip(
     /**
      * Consommation moyenne en kWh/100 km, **null sous la distance plancher**.
      *
-     * L'odomètre du véhicule est au kilomètre entier : sur 2 km, la distance est connue à ±50 %
-     * près et le ratio n'aurait aucun sens. Mieux vaut ne rien afficher que d'afficher un chiffre
-     * faux — l'énergie et la distance, elles, restent justes et restent affichées.
+     * Le plancher dépend de la source. Au kilomètre entier, 2 km sont connus à ±50 % près et le
+     * ratio n'aurait aucun sens ; au dixième, un seul kilomètre donne déjà un chiffre honnête.
+     * Mieux vaut ne rien afficher qu'un chiffre faux — l'énergie et la distance, elles, restent
+     * justes et restent affichées.
      */
     val consumptionPer100: Float?
-        get() = if (distanceKm >= MIN_DISTANCE_FOR_RATIO_KM && distanceKm > 0)
-            netEnergyKwh * 100f / distanceKm else null
+        get() = if (distance >= ratioFloor) netEnergyKwh * 100f / distance else null
 
     /**
      * Énergie du moteur : ce qui reste du total une fois la climatisation et les accessoires
@@ -69,13 +101,19 @@ data class Trip(
     /** Vitesse moyenne en km/h, même réserve de précision que la consommation. */
     val averageSpeedKmh: Float?
         get() {
-            if (distanceKm < MIN_DISTANCE_FOR_RATIO_KM || durationMs <= 0L) return null
-            return distanceKm * 3_600_000f / durationMs
+            if (distance < ratioFloor || durationMs <= 0L) return null
+            return distance * 3_600_000f / durationMs
         }
 
+    private val ratioFloor: Float
+        get() = if (distancePrecise) MIN_DISTANCE_PRECISE_KM else MIN_DISTANCE_ODOMETER_KM
+
     companion object {
-        /** En deçà, on n'affiche aucun ratio : l'odomètre est au kilomètre entier. */
-        const val MIN_DISTANCE_FOR_RATIO_KM = 5
+        /** Plancher des ratios quand la distance vient de l'odomètre, au kilomètre entier. */
+        const val MIN_DISTANCE_ODOMETER_KM = 5f
+
+        /** Idem quand elle vient de l'intégration de la vitesse, au dixième. */
+        const val MIN_DISTANCE_PRECISE_KM = 1f
     }
 }
 

app/src/main/java/com/mg4/control/model/StatsSummary.kt

@@ -12,10 +12,10 @@ package com.mg4.control.model
  */
 data class StatsSummary(
     val tripCount: Int,
-    val distanceKm: Int,
+    val distanceKm: Float,
     val energyKwh: Float,
     val regenKwh: Float,
-    val longestTripKm: Int,
+    val longestTripKm: Float,
     val drivingMs: Long,
     val chargeCount: Int,
     val chargedKwh: Float,
@@ -26,22 +26,29 @@ data class StatsSummary(
     val averagePricePerKwh: Float?,
     /** Coût estimé de l'énergie consommée en roulant. */
     val drivingCost: Float?,
+    /**
+     * Vrai si **tous** les trajets de la période ont une distance intégrée. Le plancher des ratios
+     * en dépend : il serait incohérent qu'une ligne de trajet annonce une consommation que le
+     * résumé de la même période refuse d'afficher.
+     */
+    val precise: Boolean,
 ) {
+    private val floor: Float
+        get() = if (precise) Trip.MIN_DISTANCE_PRECISE_KM else Trip.MIN_DISTANCE_ODOMETER_KM
+
     /** kWh/100 km sur la période, null en dessous de la distance plancher. */
     val consumptionPer100: Float?
-        get() = if (distanceKm >= Trip.MIN_DISTANCE_FOR_RATIO_KM)
-            energyKwh * 100f / distanceKm else null
+        get() = if (distanceKm >= floor) energyKwh * 100f / distanceKm else null
 
     val averageSpeedKmh: Float?
-        get() = if (distanceKm >= Trip.MIN_DISTANCE_FOR_RATIO_KM && drivingMs > 0L)
+        get() = if (distanceKm >= floor && drivingMs > 0L)
             distanceKm * 3_600_000f / drivingMs else null
 
     /** Coût aux 100 km, pour comparer avec un plein de carburant. */
     val costPer100: Float?
         get() {
             val cout = drivingCost ?: return null
-            return if (distanceKm >= Trip.MIN_DISTANCE_FOR_RATIO_KM)
-                cout * 100f / distanceKm else null
+            return if (distanceKm >= floor) cout * 100f / distanceKm else null
         }
 
     companion object {
@@ -56,10 +63,10 @@ data class StatsSummary(
             val energie = trips.sumOf { it.netEnergyKwh.toDouble() }.toFloat()
             return StatsSummary(
                 tripCount = trips.size,
-                distanceKm = trips.sumOf { it.distanceKm },
+                distanceKm = trips.sumOf { it.distance.toDouble() }.toFloat().roundTenth(),
                 energyKwh = energie.roundTenth(),
                 regenKwh = trips.sumOf { (it.regenKwh ?: 0f).toDouble() }.toFloat().roundTenth(),
-                longestTripKm = trips.maxOfOrNull { it.distanceKm } ?: 0,
+                longestTripKm = trips.maxOfOrNull { it.distance } ?: 0f,
                 drivingMs = trips.sumOf { it.durationMs },
                 chargeCount = charges.size,
                 chargedKwh = chargedKwh.roundTenth(),
@@ -70,6 +77,7 @@ data class StatsSummary(
                 // Faute de charge sur la période, on retombe sur le tarif alternatif : c'est une
                 // estimation, et l'écran l'annonce comme telle.
                 drivingCost = energie * (prixMoyen ?: settings.priceAc),
+                precise = trips.isNotEmpty() && trips.all { it.distancePrecise },
             )
         }
     }

app/src/main/java/com/mg4/control/model/StatsTracker.kt

@@ -16,6 +16,11 @@ package com.mg4.control.model
  * survit à un boîtier qui s'endort pendant la nuit ; la puissance mesurée, elle, n'existe que si
  * l'application a pu relever quelque chose.
  *
+ * **Distance d'un trajet** : l'odomètre donne le kilomètre entier, et c'est tout ce que le
+ * véhicule publie (les trois autres odomètres du firmware ont été sondés le 2026-09-20, tous à
+ * zéro). La distance fine vient donc de l'intégration de la vitesse par la méthode des trapèzes ;
+ * l'odomètre reste le garde-fou qui détecte une intégration partielle.
+ *
  * **Survie aux coupures** : l'état courant est exposé par [pendingState] pour être enregistré après
  * chaque relevé, et [recover] rouvre ce qui restait en cours au démarrage suivant. Sans ça, tout
  * trajet dont la fin coïncide avec l'extinction du boîtier — c'est-à-dire la plupart — serait perdu.
@@ -71,6 +76,9 @@ class StatsTracker(private val capacityKwh: Float = StatsSettings.DEFAULT_CAPACI
         // ── Trajet ──────────────────────────────────────────────────────────
         val enCours = trip
         if (ready == true) {
+            // Calculé avant la recopie : il dit à la fois combien ajouter et si l'intervalle
+            // comptait, ce qui n'est pas la même chose qu'ajouter zéro.
+            val pas = enCours?.let { integrationStep(it, snapshot) }
             trip = if (enCours == null) PendingTrip(
                 startMs = snapshot.timestampMs,
                 odometerStart = snapshot.odometerKm,
@@ -84,6 +92,7 @@ class StatsTracker(private val capacityKwh: Float = StatsSettings.DEFAULT_CAPACI
                 climateLast = snapshot.climateSinceStartKwh,
                 accessoriesLast = snapshot.accessoriesSinceStartKwh,
                 regenLast = snapshot.regenSinceStartKwh,
+                lastSpeedKmh = snapshot.speedKmh,
             ) else enCours.copy(
                 lastMs = snapshot.timestampMs,
                 odometerLast = snapshot.odometerKm ?: enCours.odometerLast,
@@ -92,8 +101,23 @@ class StatsTracker(private val capacityKwh: Float = StatsSettings.DEFAULT_CAPACI
                 climateLast = snapshot.climateSinceStartKwh ?: enCours.climateLast,
                 accessoriesLast = snapshot.accessoriesSinceStartKwh ?: enCours.accessoriesLast,
                 regenLast = snapshot.regenSinceStartKwh ?: enCours.regenLast,
+                integratedKm = enCours.integratedKm + (pas ?: 0f),
+                integrated = enCours.integrated || pas != null,
+                // Une vitesse manquée ne réinitialise pas le trapèze : le prochain intervalle
+                // repart de la dernière vitesse connue, ce qui sous-estime sans jamais inventer.
+                lastSpeedKmh = snapshot.speedKmh ?: enCours.lastSpeedKmh,
             )
         } else if (ready == false && enCours != null) {
+            // Entre le dernier relevé sous contact et celui qui le coupe, la voiture roulait
+            // encore : sans ce dernier trapèze, chaque trajet perdrait sa fin. Seules la distance
+            // et l'heure de fin sont reprises — les compteurs d'énergie restent ceux du dernier
+            // relevé sous contact, dont on sait qu'ils étaient valides.
+            val fin = integrationStep(enCours, snapshot)
+            if (fin != null) trip = enCours.copy(
+                lastMs = snapshot.timestampMs,
+                integratedKm = enCours.integratedKm + fin,
+                integrated = true,
+            )
             finishTrip()?.let { events += Event.TripEnded(it) }
         }
 
@@ -127,6 +151,22 @@ class StatsTracker(private val capacityKwh: Float = StatsSettings.DEFAULT_CAPACI
         return events
     }
 
+    /**
+     * Distance parcourue depuis le relevé précédent, par la méthode des trapèzes.
+     *
+     * Rend null quand l'intervalle n'est pas mesurable : vitesse inconnue d'un côté ou de l'autre,
+     * ou trou de plus de [MAX_SAMPLE_GAP_MS] — passé ce délai, prolonger la dernière vitesse connue
+     * ne serait plus une mesure mais une supposition. L'intervalle est alors simplement perdu, et
+     * la comparaison avec l'odomètre se chargera de dire que le total n'est plus fiable.
+     */
+    private fun integrationStep(p: PendingTrip, s: EnergySnapshot): Float? {
+        val avant = p.lastSpeedKmh ?: return null
+        val apres = s.speedKmh ?: return null
+        val dt = s.timestampMs - p.lastMs
+        if (dt <= 0L || dt > MAX_SAMPLE_GAP_MS) return null
+        return (avant + apres) / 2f * (dt / 3_600_000f)
+    }
+
     /**
      * Fin de trajet, à partir du dernier relevé observé. Rend null pour un trajet sans distance ni
      * énergie : mettre le contact pour régler la climatisation n'est pas un trajet, et remplirait
@@ -137,7 +177,10 @@ class StatsTracker(private val capacityKwh: Float = StatsSettings.DEFAULT_CAPACI
         trip = null
         val distance = diffKm(p.odometerStart, p.odometerLast)
         val energy = counterDelta(p.energyStart, p.energyLast) ?: 0f
-        if (distance <= 0 && energy <= 0f) return null
+        // La distance intégrée compte dans ce test : un trajet de six cents mètres est un vrai
+        // trajet, même si l'odomètre n'a pas changé de kilomètre.
+        val integre = if (p.integrated) p.integratedKm.roundTenth() else null
+        if (distance <= 0 && energy <= 0f && (integre ?: 0f) <= 0f) return null
         return Trip(
             startMs = p.startMs,
             endMs = p.lastMs,
@@ -149,6 +192,7 @@ class StatsTracker(private val capacityKwh: Float = StatsSettings.DEFAULT_CAPACI
             socStart = p.socStart,
             socEnd = p.socLast,
             outsideTempC = p.tempC,
+            integratedKm = integre,
         )
     }
 
@@ -181,4 +225,13 @@ class StatsTracker(private val capacityKwh: Float = StatsSettings.DEFAULT_CAPACI
         if (start == null || end < start) return end
         return end - start
     }
+
+    companion object {
+        /**
+         * Trou maximal accepté entre deux relevés pour intégrer la vitesse. Le collecteur relève
+         * toutes les dix secondes en roulant : une minute laisse passer cinq relevés manqués, bien
+         * au-delà d'un simple retard de l'ordonnanceur, mais sans couvrir une mise en veille.
+         */
+        const val MAX_SAMPLE_GAP_MS = 60_000L
+    }
 }

app/src/main/java/com/mg4/control/stats/StatsStore.kt

@@ -135,7 +135,7 @@ class StatsStore(private val context: Context) {
     fun addTrip(trip: Trip) = synchronized(LOCK) {
         val h = read()
         write(h.copy(trips = h.trips + trip))
-        AppLogger.i(TAG, "trajet enregistré : ${trip.distanceKm} km · ${trip.energyKwh} kWh")
+        AppLogger.i(TAG, "trajet enregistré : ${trip.distance} km · ${trip.netEnergyKwh} kWh")
     }
 
     fun addCharge(session: ChargeSession) = synchronized(LOCK) {