@@ -0,0 +1,193 @@
+package com.mg4.control.hardware
+
+import android.os.Handler
+import android.os.HandlerThread
+import android.os.SystemClock
+import com.mg4.control.debug.AppLogger
+import com.mg4.control.model.PropertySweep
+import com.mg4.control.util.FirmwareInfo
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+/**
+ * Sonde clé, en **lecture seule** : la voiture dit-elle à l'écran de bord si la clé sans fil est
+ * là ? Elle n'écrit rien sur le véhicule. PROVISOIRE — à retirer une fois le relevé fait.
+ *
+ * La recherche dans les firmwares (2026-10-11, cinq tables de propriétés) n'a trouvé AUCUN signal
+ * de présence ni de force de signal — seulement la disponibilité du calculateur PEPS, des codes
+ * d'équipement et des réglages. Reste à le constater sur la voiture, de deux façons :
+ *
+ *  1. **Les signaux nommés** de [SIGNALS], relus à chaque ouverture du Diagnostic.
+ *  2. **Un balayage à l'aveugle** de toutes les propriétés entières et booléennes du constructeur
+ *     ([PropertySweep.sweepable]), comparé au balayage précédent : c'est lui qui dirait si la clé
+ *     se cache sous un autre nom. Il tourne sur son propre fil, sans retarder le Diagnostic ; son
+ *     résultat apparaît donc à l'ouverture SUIVANTE.
+ *
+ * Mode d'emploi : voiture à l'arrêt, sans toucher à rien d'autre —
+ *  a. clé dans la voiture, ouvrir le Diagnostic, attendre 30 s, le fermer ;
+ *  b. éloigner la clé, ouvrir le Diagnostic, attendre 30 s, le fermer ;
+ *  c. rouvrir le Diagnostic : la section « Sonde clé : balayage » liste ce qui a changé entre a et b.
+ */
+object KeyProbe {
+
+    const val TAG = "MG4_KEY"
+
+    private const val AREA_GLOBAL = 0x1000000
+    private const val MAX_RELEVES = 6
+    /** Au-delà, le balayage n'a pas été fait à l'arrêt : inutile de noyer le rapport. */
+    private const val MAX_CHANGEMENTS = 40
+
+    private data class Signal(val name: String, val id: Int)
+
+    private val SIGNALS = listOf(
+        Signal("SENSOR_PEPSAVLBLY (calculateur PEPS joignable)", 0x21401582),
+        Signal("SENSOR_BCMAVLBLY (calculateur de carrosserie, pour comparer)", 0x2140157f),
+        Signal("SENSOR_REMOTELY_START_CAR_STATE", 0x21401562),
+        Signal("COM_AUTO_IDENTIFICATION", 0x2140d70a),
+        Signal("AUTO_KEY_IDEN_RECALL_OPT (mémoire siège/rétros par clé)", 0x2140c62d),
+        Signal("DLOCK_UNLOCK_WITH_KEY", 0x2540c617),
+        Signal("DLOCK_ENTRY_UNLOCK (déverrouillage à l'approche)", 0x2540c618),
+        Signal("CAL_REMOTE_KEYLESS_ENTRY_SYSTEM (équipement)", 0x21704230),
+        Signal("CAL_VEHICLE_START_TYPE (équipement)", 0x2170426d),
+        Signal("SENSOR_EPTRDY (READY, contexte)", 0x2140157c),
+        Signal("IGNITION_STATE (AOSP, contexte)", 0x11400409),
+    )
+
+    /** Une propriété déclarée par le véhicule et les zones où elle se lit. */
+    private class Config(val id: Int, val zones: IntArray)
+
+    private val historique = ArrayDeque<String>()
+    private var dernierBalayage: String? = null
+
+    /** Relevés des signaux nommés, puis le résultat du dernier balayage. */
+    val reports: List<String>
+        @Synchronized get() = historique.toList() + listOfNotNull(dernierBalayage)
+
+    /** Fil dédié : un balayage fait un bon millier de lectures binder. */
+    private val handler: Handler by lazy {
+        Handler(HandlerThread("mg4-key-probe").also { it.start() }.looper)
+    }
+
+    // Fil de la sonde uniquement.
+    private var precedent: Map<String, String>? = null
+    private var precedentA = 0L
+    private var numero = 0
+
+    /** Relève les signaux nommés, lance un balayage en arrière-plan et renvoie le texte du relevé. */
+    fun run(origin: String): String {
+        val horloge = SimpleDateFormat("HH:mm:ss", Locale.ROOT).format(Date())
+        val cpm = MG4Hardware.carPropertyManager()
+        val configs = configs(cpm)
+        val lignes = mutableListOf("══ Sonde clé [$origin] · ${FirmwareInfo.getGeneration()} · $horloge ══")
+        SIGNALS.forEach { s ->
+            val config = configs?.firstOrNull { it.id == s.id }
+            val zones = config?.zones ?: intArrayOf(AREA_GLOBAL, 0)
+            val declaree = if (configs == null) "?" else if (config != null) "oui" else "non"
+            lignes += "  ${s.name} 0x${Integer.toHexString(s.id)} : déclarée=$declaree · " +
+                zones.joinToString(" · ") { z -> "zone 0x${Integer.toHexString(z)}=" + lire(cpm, s.id, z) }
+        }
+        lignes.forEach { AppLogger.i(TAG, it) }
+        garde(lignes.joinToString("\n"))
+        handler.post { balayer(origin) }
+        return lignes.joinToString("\n")
+    }
+
+    // ── Balayage ─────────────────────────────────────────────────────────────
+
+    private fun balayer(origin: String) {
+        val cpm = MG4Hardware.carPropertyManager()
+        val configs = configs(cpm)?.filter { PropertySweep.sweepable(it.id) }
+        if (cpm == null || configs == null) {
+            publier("── Sonde clé : balayage [$origin] impossible — liste des propriétés illisible ──")
+            return
+        }
+        val debut = SystemClock.elapsedRealtime()
+        val releve = HashMap<String, String>()
+        var echecs = 0
+        configs.forEach { c ->
+            c.zones.forEach { zone ->
+                // Zone 0 déclarée pour une propriété globale : c'est à la zone globale du HAL
+                // qu'elle répond sur ces voitures, d'où l'essai des deux.
+                val valeur = if (zone == 0) lireOuNull(cpm, c.id, AREA_GLOBAL) ?: lireOuNull(cpm, c.id, 0)
+                             else lireOuNull(cpm, c.id, zone)
+                if (valeur == null) echecs++ else releve[PropertySweep.key(c.id, zone)] = valeur
+            }
+        }
+        val duree = (SystemClock.elapsedRealtime() - debut) / 1000.0
+        numero++
+        val lignes = mutableListOf(
+            "── Sonde clé : balayage n° $numero [$origin] — ${releve.size} valeurs lues en " +
+                "%.1f s, $echecs illisibles ──".format(Locale.US, duree))
+        val avant = precedent
+        if (avant == null) {
+            lignes += "  premier balayage : rien à comparer. Éloigner la clé, puis rouvrir le Diagnostic."
+        } else {
+            val changements = PropertySweep.changes(avant, releve)
+            val ecart = (SystemClock.elapsedRealtime() - precedentA) / 1000
+            lignes += "  depuis le balayage précédent (il y a $ecart s) : ${changements.size} changement(s)"
+            changements.take(MAX_CHANGEMENTS).forEach { lignes += "    $it" }
+            if (changements.size > MAX_CHANGEMENTS) lignes += "    … et ${changements.size - MAX_CHANGEMENTS} autres"
+        }
+        precedent = releve
+        precedentA = SystemClock.elapsedRealtime()
+        lignes.forEach { AppLogger.i(TAG, it) }
+        publier(lignes.joinToString("\n"))
+    }
+
+    @Synchronized
+    private fun publier(texte: String) {
+        dernierBalayage = texte
+    }
+
+    @Synchronized
+    private fun garde(texte: String) {
+        historique.addLast(texte)
+        while (historique.size > MAX_RELEVES) historique.removeFirst()
+    }
+
+    // ── Lectures ─────────────────────────────────────────────────────────────
+
+    /** Propriétés déclarées par le véhicule avec leurs zones, ou null si la liste est illisible. */
+    private fun configs(cpm: Any?): List<Config>? = runCatching {
+        (cpm!!.javaClass.getMethod("getPropertyList").invoke(cpm) as? List<*>)
+            ?.filterNotNull()
+            ?.mapNotNull { c ->
+                val id = runCatching { c.javaClass.getMethod("getPropertyId").invoke(c) as? Int }.getOrNull()
+                    ?: return@mapNotNull null
+                val zones = runCatching { c.javaClass.getMethod("getAreaIds").invoke(c) as? IntArray }.getOrNull()
+                Config(id, zones?.takeIf { it.isNotEmpty() } ?: intArrayOf(0))
+            }
+    }.getOrNull()
+
+    /** Valeur lisible, ou le nom de l'exception : distinguer « absente » de « refusée » est une réponse. */
+    private fun lire(cpm: Any?, id: Int, zone: Int): String {
+        cpm ?: return "cpm absent"
+        return try {
+            valeur(cpm, id, zone)
+        } catch (e: Exception) {
+            val cause = e.cause ?: e
+            cause.javaClass.simpleName + (cause.message?.let { " ($it)" } ?: "")
+        }
+    }
+
+    private fun lireOuNull(cpm: Any, id: Int, zone: Int): String? =
+        runCatching { valeur(cpm, id, zone) }.getOrNull()
+
+    private fun valeur(cpm: Any, id: Int, zone: Int): String = when (id and 0x00ff0000) {
+        0x00200000 -> typee(cpm, "getBooleanProperty", id, zone)
+        0x00600000 -> typee(cpm, "getFloatProperty", id, zone)
+        0x00700000 -> {
+            // Bloc d'octets (codes d'équipement) : pas d'accesseur typé, on passe par getProperty.
+            val v = cpm.javaClass
+                .getMethod("getProperty", Class::class.java, Int::class.javaPrimitiveType, Int::class.javaPrimitiveType)
+                .invoke(cpm, ByteArray::class.java, id, zone)
+            val octets = v?.javaClass?.getMethod("getValue")?.invoke(v) as? ByteArray
+            octets?.let { PropertySweep.hex(it) } ?: "null"
+        }
+        else -> typee(cpm, "getIntProperty", id, zone)
+    }
+
+    private fun typee(cpm: Any, accesseur: String, id: Int, zone: Int): String =
+        cpm.javaClass.getMethod(accesseur, Int::class.java, Int::class.java).invoke(cpm, id, zone)?.toString() ?: "null"
+}
@@ -3767,6 +3767,12 @@ object MG4Hardware {
             sb.appendLine()
         }
 
+        // Sonde clé (provisoire) : signaux nommés des dernières ouvertures, puis le dernier balayage.
+        KeyProbe.reports.forEach {
+            sb.appendLine(it)
+            sb.appendLine()
+        }
+
         if (gen == FirmwareInfo.Gen.SWI132) {
 
             // ── Binder IVehicleSettingService ─────────────────────────────
 
@@ -0,0 +1,47 @@
+package com.mg4.control.model
+
+/**
+ * Balayage des propriétés du véhicule pour la sonde clé ([com.mg4.control.hardware.KeyProbe]) —
+ * la partie sans véhicule : quoi relire, et quoi signaler entre deux relevés.
+ */
+object PropertySweep {
+
+    private const val GROUPE = 0xf0000000.toInt()
+    private const val GROUPE_CONSTRUCTEUR = 0x20000000
+    private const val TYPE = 0x00ff0000
+    private const val TYPE_ENTIER = 0x00400000
+    private const val TYPE_BOOLEEN = 0x00200000
+
+    /**
+     * Vrai pour une propriété que le balayage relit : entier ou booléen du groupe constructeur.
+     *
+     * Le groupe « système » est laissé de côté — on y trouve les commandes d'usine et
+     * d'alimentation, que personne ne relit en usage normal. Les flottants bougent tout seuls
+     * (vitesse, énergie) et les blocs d'octets sont des codes d'équipement : ni les uns ni les
+     * autres ne diraient si une clé est là.
+     */
+    fun sweepable(id: Int): Boolean =
+        (id and GROUPE) == GROUPE_CONSTRUCTEUR &&
+            ((id and TYPE) == TYPE_ENTIER || (id and TYPE) == TYPE_BOOLEEN)
+
+    /** Clé d'une valeur dans un relevé : identifiant et zone, en hexadécimal. */
+    fun key(id: Int, area: Int): String = "0x" + Integer.toHexString(id) + "@0x" + Integer.toHexString(area)
+
+    /**
+     * Valeurs qui diffèrent entre deux relevés, triées par clé. Une propriété lue une seule des
+     * deux fois est ignorée : une lecture qui échoue par intermittence n'apprend rien.
+     */
+    fun changes(before: Map<String, String>, after: Map<String, String>): List<String> =
+        before.keys.sorted().mapNotNull { cle ->
+            val avant = before[cle]
+            val apres = after[cle] ?: return@mapNotNull null
+            if (avant == apres) null else "$cle : $avant \u2192 $apres"
+        }
+
+    /** Début d'un bloc d'octets en hexadécimal — assez pour comparer deux relevés. */
+    fun hex(bytes: ByteArray, max: Int = 16): String {
+        if (bytes.isEmpty()) return "(vide)"
+        val debut = bytes.take(max).joinToString(" ") { "%02x".format(it.toInt() and 0xff) }
+        return if (bytes.size > max) "$debut\u2026 (${bytes.size} octets)" else debut
+    }
+}
@@ -706,6 +706,9 @@ class SettingsFragment : Fragment() {
             // Sonde lumière/position : un relevé instantané, à prendre en plein jour, au crépuscule
             // et dans un parking couvert. Ceux pris automatiquement au READY sont déjà gardés.
             com.mg4.control.hardware.LightProbe.run("diagnostic")
+            // Sonde clé (provisoire) : signaux nommés tout de suite, balayage complet en
+            // arrière-plan — son résultat est dans le rapport à l'ouverture suivante.
+            com.mg4.control.hardware.KeyProbe.run("diagnostic")
             val report = MG4Hardware.buildDiagnosticReport(appVersion)
             withContext(Dispatchers.Main) {
                 if (isAdded) tvReport.text = report
 
@@ -0,0 +1,88 @@
+package com.mg4.control.model
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Sonde clé — comparer deux relevés de TOUTES les propriétés du véhicule, clé dans la voiture
+ * puis clé éloignée, pour voir si quoi que ce soit bouge.
+ *
+ * Aucune propriété ne porte le nom d'un signal de clé (recherche du 2026-10-11 sur cinq
+ * firmwares) : seul un balayage à l'aveugle peut dire s'il en existe une sous un autre nom.
+ */
+class PropertySweepTest {
+
+    // ── Quelles propriétés relire ────────────────────────────────────────────
+
+    @Test
+    fun `les entiers et les booleens du constructeur sont balayes`() {
+        assertTrue(PropertySweep.sweepable(0x21401582))    // SENSOR_PEPSAVLBLY, entier
+        assertTrue(PropertySweep.sweepable(0x2540c617))    // DLOCK_UNLOCK_WITH_KEY, entier par siège
+        assertTrue(PropertySweep.sweepable(0x21209320))    // feux de croisement, booléen
+    }
+
+    @Test
+    fun `les proprietes du systeme ne sont pas balayees`() {
+        // Groupe « système » : on y trouve les commandes d'usine (EOL) et d'alimentation, que
+        // personne ne relit en usage normal. On s'en tient à ce que lisent les écrans d'origine.
+        assertFalse(PropertySweep.sweepable(0x11408a07))   // PMS_SYSTEM_RESTART
+        assertFalse(PropertySweep.sweepable(0x11400409))   // IGNITION_STATE
+    }
+
+    @Test
+    fun `les flottants et les blocs d octets ne sont pas balayes`() {
+        // Un flottant (vitesse, énergie) bouge tout seul ; un bloc d'octets est un code d'équipement.
+        assertFalse(PropertySweep.sweepable(0x2160f404))   // SoC, flottant
+        assertFalse(PropertySweep.sweepable(0x21704230))   // CAL_REMOTE_KEYLESS_ENTRY_SYSTEM, octets
+    }
+
+    // ── Ce qui a changé entre deux relevés ───────────────────────────────────
+
+    @Test
+    fun `une valeur qui change est signalee avec ses deux valeurs`() {
+        val avant = mapOf("0x21401582@0x1000000" to "1", "0x2140157f@0x1000000" to "1")
+        val apres = mapOf("0x21401582@0x1000000" to "0", "0x2140157f@0x1000000" to "1")
+        assertEquals(listOf("0x21401582@0x1000000 : 1 \u2192 0"), PropertySweep.changes(avant, apres))
+    }
+
+    @Test
+    fun `rien n est signale quand rien ne bouge`() {
+        val releve = mapOf("0x21401582@0x1000000" to "1")
+        assertEquals(emptyList<String>(), PropertySweep.changes(releve, releve))
+    }
+
+    @Test
+    fun `une propriete lue une seule des deux fois n est pas un changement`() {
+        // Une lecture qui échoue une fois sur deux n'apprend rien sur la clé.
+        val avant = mapOf("a" to "1")
+        val apres = mapOf("b" to "1")
+        assertEquals(emptyList<String>(), PropertySweep.changes(avant, apres))
+    }
+
+    @Test
+    fun `les changements sortent dans un ordre stable`() {
+        val avant = mapOf("b" to "0", "a" to "0", "c" to "0")
+        val apres = mapOf("c" to "1", "a" to "1", "b" to "1")
+        assertEquals(
+            listOf("a : 0 \u2192 1", "b : 0 \u2192 1", "c : 0 \u2192 1"),
+            PropertySweep.changes(avant, apres))
+    }
+
+    // ── Affichage ────────────────────────────────────────────────────────────
+
+    @Test
+    fun `la cle d un releve porte l identifiant et la zone en hexadecimal`() {
+        assertEquals("0x21401582@0x1000000", PropertySweep.key(0x21401582, 0x1000000))
+        assertEquals("0x2540c617@0x1", PropertySweep.key(0x2540c617, 1))
+    }
+
+    @Test
+    fun `un bloc d octets s affiche en hexadecimal et reste court`() {
+        assertEquals("01 ff 00", PropertySweep.hex(byteArrayOf(1, -1, 0)))
+        assertEquals("(vide)", PropertySweep.hex(byteArrayOf()))
+        // Un code d'équipement peut faire des dizaines d'octets : le début suffit à le comparer.
+        assertEquals("00 01 02 03\u2026 (6 octets)", PropertySweep.hex(byteArrayOf(0, 1, 2, 3, 4, 5), max = 4))
+    }
+}