From 12e4057a926b899310c6482c2568feed28f559be Mon Sep 17 00:00:00 2001
From: malys <malys.training@gmail.com>
Date: Wed, 22 Jul 2026 14:40:52 +0200
Subject: [PATCH 01/13] build: add emulator tasks to mise

emulator-setup / emulator-car / emulator-screen / emulator-stop / run.

No single emulator matches the MG4: the car runs AAOS 9 (API 28) and Google
publishes no Automotive system image below API 33 (checked with
sdkmanager --list). So two AVDs, each faithful on one axis -- emulator-car is
API 33 Automotive (has CarPropertyManager, wrong OS), emulator-screen is API 28
at the MG4's 1920x1080 @ 160dpi panel (right OS and screen, no car service).
Neither exposes the SAIC vendor properties, so those reads fail on both, as
they should.

`run` builds, installs with -g to pre-grant runtime permissions, and launches
the activity on whatever device is attached -- emulator or the car over ADB.

setup aborts if /dev/kvm is missing and warns when the user is not in the kvm
group, rather than handing over an unusably slow emulator.

This is a local dev convenience only; nothing here runs in CI or changes the
build.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 mise.toml | 113 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 113 insertions(+)

diff --git a/mise.toml b/mise.toml
index ba60511..a3d6ced 100644
--- a/mise.toml
+++ b/mise.toml
@@ -31,6 +31,32 @@ BUILD_TOOLS = "34.0.0"
 # Gradle doit tourner sur le JDK de mise. Sans -Dorg.gradle.java.home, Gradle réutilise
 # un daemon déjà lancé par l'extension Java de VS Code, qui embarque un JRE 21 sans
 # jlink : le build échoue alors sur JdkImageTransform, sans rapport avec le code.
+# ── Émulateur ────────────────────────────────────────────────────────────────────
+#
+# ATTENTION sur la fidélité : le véhicule tourne en AAOS 9 (API 28). Google ne publie
+# AUCUNE image système Automotive en dessous d'API 33 — vérifié avec sdkmanager --list.
+# Il n'existe donc pas d'émulateur qui reproduise à la fois l'OS et l'API voiture du MG4.
+# D'où deux profils, chacun fidèle sur un axe :
+#
+#   emulator-car     API 33 Automotive — a bien un CarPropertyManager, mauvaise version
+#                    d'OS. Pour tester le cycle de vie du service et le chemin voiture.
+#                    Les propriétés VENDEUR SAIC (0x216xxxxx : SOC, autonomie) n'existent
+#                    pas dans l'émulateur : ces lectures échoueront, c'est normal.
+#   emulator-screen  API 28 tablette — bonne version d'OS et bon écran (1920x1080 @ 160dpi,
+#                    12,8" HD comme le MG4), mais AUCUN service voiture.
+#                    Pour l'UI, les layouts et la densité.
+#
+# Rien de tout cela ne remplace un essai sur le véhicule.
+# 12,8" HD : 1920x1080 ≈ 172 dpi réels, arrondi au bucket 160 (mdpi).
+
+EMU_CAR_AVD = "mg4control-car"
+EMU_CAR_IMAGE = "system-images;android-33;android-automotive;x86_64"
+EMU_SCREEN_AVD = "mg4control-screen"
+EMU_SCREEN_IMAGE = "system-images;android-28;google_apis;x86_64"
+EMU_WIDTH = "1920"
+EMU_HEIGHT = "1080"
+EMU_DENSITY = "160"
+
 [tasks.bootstrap]
 description = "Installe le SDK Android (platform + build-tools) s'il manque"
 run = """
@@ -83,3 +109,90 @@ run = './gradlew -Dorg.gradle.java.home=$JAVA_HOME assembleOnlineRelease assembl
 
 [tasks.clean]
 run = './gradlew -Dorg.gradle.java.home=$JAVA_HOME clean'
+
+[tasks.emulator-setup]
+description = "Installe l'émulateur + les images système et crée les deux AVD"
+run = '''
+set -e
+SDK="$ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager"
+AVDM="$ANDROID_HOME/cmdline-tools/latest/bin/avdmanager"
+
+if [ ! -e /dev/kvm ]; then
+  echo "ERREUR : /dev/kvm absent — pas d'accélération matérielle, l'émulateur sera inutilisable." >&2
+  echo "Sous WSL2 : activer la virtualisation imbriquée côté Windows." >&2
+  exit 1
+fi
+if ! id -nG | tr ' ' '\n' | grep -qx kvm; then
+  echo "ATTENTION : utilisateur absent du groupe kvm. Corriger avec :" >&2
+  echo "  sudo usermod -aG kvm $USER   # puis se reconnecter" >&2
+fi
+
+yes | "$SDK" --sdk_root="$ANDROID_HOME" --licenses > /dev/null
+"$SDK" --sdk_root="$ANDROID_HOME" "emulator" "platform-tools" "$EMU_CAR_IMAGE" "$EMU_SCREEN_IMAGE"
+
+create_avd() {
+  name="$1"; image="$2"; device="$3"
+  if "$AVDM" list avd 2>/dev/null | grep -q "Name: $name"; then
+    echo "AVD $name déjà présent"
+  else
+    echo no | "$AVDM" create avd -n "$name" -k "$image" -d "$device" --force
+  fi
+  cfg="$HOME/.android/avd/$name.avd/config.ini"
+  # Écran du MG4. Sans ça l'AVD garde la densité du profil générique et les layouts
+  # ne ressemblent pas à ce que voit le conducteur.
+  sed -i '/^hw.lcd/d;/^disk.dataPartition.size/d' "$cfg"
+  {
+    echo "hw.lcd.width=$EMU_WIDTH"
+    echo "hw.lcd.height=$EMU_HEIGHT"
+    echo "hw.lcd.density=$EMU_DENSITY"
+    echo "disk.dataPartition.size=4G"
+  } >> "$cfg"
+  echo "AVD $name configuré en ${EMU_WIDTH}x${EMU_HEIGHT} @ ${EMU_DENSITY}dpi"
+}
+
+create_avd "$EMU_CAR_AVD" "$EMU_CAR_IMAGE" "automotive_1024p_landscape"
+create_avd "$EMU_SCREEN_AVD" "$EMU_SCREEN_IMAGE" "pixel_c"
+'''
+
+[tasks.emulator-car]
+description = "Lance l'émulateur Automotive (API 33 — a un CarPropertyManager)"
+run = '''
+set -e
+# swiftshader_indirect : le GPU hôte n'est pas exposé de façon fiable sous WSL2.
+"$ANDROID_HOME/emulator/emulator" -avd "$EMU_CAR_AVD" \
+  -gpu swiftshader_indirect -no-snapshot-save -no-boot-anim &
+"$ANDROID_HOME/platform-tools/adb" wait-for-device
+echo "Émulateur voiture prêt."
+'''
+
+[tasks.emulator-screen]
+description = "Lance l'émulateur écran MG4 (API 28, 1920x1080 @ 160dpi — pas de service voiture)"
+run = '''
+set -e
+"$ANDROID_HOME/emulator/emulator" -avd "$EMU_SCREEN_AVD" \
+  -gpu swiftshader_indirect -no-snapshot-save -no-boot-anim &
+"$ANDROID_HOME/platform-tools/adb" wait-for-device
+echo "Émulateur écran prêt."
+'''
+
+[tasks.emulator-stop]
+description = "Arrête l'émulateur en cours"
+run = '"$ANDROID_HOME/platform-tools/adb" emu kill || true'
+
+[tasks.run]
+description = "Compile, installe et lance l'APK sur l'émulateur ou le véhicule connecté"
+depends = ["build"]
+run = '''
+set -e
+ADB="$ANDROID_HOME/platform-tools/adb"
+if [ -z "$($ADB devices | sed '1d' | grep -w device || true)" ]; then
+  echo "Aucun appareil connecté. Lancer d'abord 'mise run emulator-car' ou 'mise run emulator-screen'," >&2
+  echo "ou brancher le véhicule en ADB." >&2
+  exit 1
+fi
+APK=$(ls -t app/build/outputs/apk/online/debug/*.apk | head -1)
+echo "Installation de $APK"
+$ADB install -r -g "$APK"
+$ADB shell am start -n "com.mg4.control/com.mg4.control.MainActivity"
+echo "Lancé. Logs : mise run logs"
+'''

From 7fdf819515356d51ec7c1f0709e34f14a8b56337 Mon Sep 17 00:00:00 2001
From: Malys <malys.training@gmail.com>
Date: Wed, 22 Jul 2026 15:04:46 +0200
Subject: [PATCH 02/13] =?UTF-8?q?feat:=20TaskerBridgeService=20=E2=80=94?=
 =?UTF-8?q?=20narrow=20IPC=20surface=20for=20MG4Tasker?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Exposes a 4-method AIDL bridge (ITaskerBridge) that lets a separately
signed companion app (MG4Tasker) read a vehicle snapshot and request
named actions, without granting it any vehicle access of its own.

Design:
- Closed action catalogue, no raw property-write method. A caller can only
  request what the user could already do from MG4Control's UI. VEHICLE_POWER_OFF
  is intentionally excluded.
- Every write still runs in this process, so VehicleWriteGate (0 km/h) applies
  in one place and the per-firmware routing is not duplicated.
- Guarded by a new signature-level permission (com.mg4.control.permission.
  TASKER_BRIDGE); the exported service and the ignition broadcast both require it.
- Ignition broadcast to MG4Tasker is delayed ~8s so the default profile finishes
  applying first, avoiding interleaved write sequences.

Also adds read-only outside-temperature and climate/window reads
(HVAC AC/AUTO/recirc/fan/temperature, window position). These use standard
AOSP property ids and are UNVERIFIED on MG4 firmware — all return null when
unreadable, for the MG4Tasker diagnostic screen to check exposure before any
write path is added. No write counterparts.

Permission added to the allowlist; ProGuard keeps the AIDL stub.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .github/security/permission-allowlist.txt     |   4 +
 app/build.gradle.kts                          |   2 +
 app/proguard-rules.pro                        |   5 +
 app/src/main/AndroidManifest.xml              |  18 ++
 .../com/mg4/control/tasker/ITaskerBridge.aidl |  37 +++
 .../com/mg4/control/hardware/MG4Hardware.kt   |  84 ++++++
 .../mg4/control/service/MG4ControlService.kt  |  34 +++
 .../mg4/control/tasker/TaskerBridgeService.kt | 281 ++++++++++++++++++
 .../control/tasker/TaskerBridgeVerdictTest.kt |  48 +++
 9 files changed, 513 insertions(+)
 create mode 100644 app/src/main/aidl/com/mg4/control/tasker/ITaskerBridge.aidl
 create mode 100644 app/src/main/java/com/mg4/control/tasker/TaskerBridgeService.kt
 create mode 100644 app/src/test/java/com/mg4/control/tasker/TaskerBridgeVerdictTest.kt

diff --git a/.github/security/permission-allowlist.txt b/.github/security/permission-allowlist.txt
index c55a502..23f507a 100644
--- a/.github/security/permission-allowlist.txt
+++ b/.github/security/permission-allowlist.txt
@@ -23,6 +23,10 @@ android.car.permission.CONTROL_CAR_CLIMATE
 # seule une app signée avec la clé plateforme peut l'obtenir. Elle restreint un accès,
 # elle n'en accorde pas.
 com.mg4.control.permission.RECEIVE_HARDKEY
+# Pont MG4Tasker : ferme l'accès au TaskerBridgeService et au broadcast d'allumage.
+# protectionLevel="signature" → réservée aux apps signées avec la clé plateforme.
+# Déclarée ET demandée par MG4Control : demandée pour pouvoir émettre le broadcast.
+com.mg4.control.permission.TASKER_BRIDGE
 # --- network / auto-update (online variant only) ---
 android.permission.INTERNET
 android.permission.ACCESS_NETWORK_STATE
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 63d61d6..b780bd1 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -70,6 +70,8 @@ android {
     buildFeatures {
         viewBinding = true
         buildConfig = true
+        // ITaskerBridge : contrat IPC partagé avec MG4Tasker (même package AIDL des deux côtés).
+        aidl = true
     }
 
     // Tests unitaires JVM (pas de véhicule, pas d'émulateur) : Robolectric a besoin des
diff --git a/app/proguard-rules.pro b/app/proguard-rules.pro
index 603e3c7..770003e 100644
--- a/app/proguard-rules.pro
+++ b/app/proguard-rules.pro
@@ -9,6 +9,11 @@
 # ServiceManager, which was already listed.
 -keep class android.os.SystemProperties { *; }
 
+# Contrat IPC avec MG4Tasker. Le Stub/Proxy AIDL est résolu par nom côté client :
+# renommer ces classes casserait le bind au lieu d'échouer à la compilation.
+-keep interface com.mg4.control.tasker.ITaskerBridge { *; }
+-keep class com.mg4.control.tasker.ITaskerBridge$* { *; }
+
 # Gson (profils + sauvegarde). Sans Signature, le type générique de
 # TypeToken<List<DrivingProfile>> est effacé et la désérialisation rend une liste de
 # LinkedTreeMap : les profils disparaîtraient silencieusement au premier lancement d'une
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index ce3abb3..a63cd47 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -29,6 +29,15 @@
         android:name="com.mg4.control.permission.RECEIVE_HARDKEY"
         android:protectionLevel="signature" />
 
+    <!-- Pont MG4Tasker. En protectionLevel="signature", seule une app signée avec la même
+         clé plateforme peut se lier au service ou recevoir la notification d'allumage.
+         MG4Control la déclare ET la demande : il l'exige des clients du service, et il en a
+         besoin lui-même pour émettre le broadcast vers MG4Tasker. -->
+    <permission
+        android:name="com.mg4.control.permission.TASKER_BRIDGE"
+        android:protectionLevel="signature" />
+    <uses-permission android:name="com.mg4.control.permission.TASKER_BRIDGE" />
+
     <!-- Réseau / auto-update : déclarés UNIQUEMENT dans le flavor online
          (src/online/AndroidManifest.xml). Le flavor offline n'en a aucun, par construction. -->
 
@@ -65,6 +74,15 @@
             android:directBootAware="true"
             android:foregroundServiceType="connectedDevice" />
 
+        <!-- Pont IPC MG4Tasker. exported=true car le client est une autre app, mais l'accès
+             est fermé par la permission signature : seule une app signée avec la clé
+             plateforme de la ROM peut se lier. Le service n'expose aucune écriture de
+             propriété brute — uniquement le catalogue d'actions de TaskerBridgeService. -->
+        <service
+            android:name=".tasker.TaskerBridgeService"
+            android:exported="true"
+            android:permission="com.mg4.control.permission.TASKER_BRIDGE" />
+
         <!-- FileProvider + InstallReceiver (auto-update) : déclarés UNIQUEMENT dans
              le flavor online (src/online/AndroidManifest.xml). Déplacer le FileProvider
              hors du manifest de base évite aussi un conflit d'authority qui empêcherait
diff --git a/app/src/main/aidl/com/mg4/control/tasker/ITaskerBridge.aidl b/app/src/main/aidl/com/mg4/control/tasker/ITaskerBridge.aidl
new file mode 100644
index 0000000..a2b3b5e
--- /dev/null
+++ b/app/src/main/aidl/com/mg4/control/tasker/ITaskerBridge.aidl
@@ -0,0 +1,37 @@
+package com.mg4.control.tasker;
+
+/**
+ * Pont IPC exposé par MG4Control à MG4Tasker.
+ *
+ * Contrat volontairement ÉTROIT : 4 méthodes, jamais une par réglage véhicule.
+ * Ajouter une action au catalogue ne change pas cette interface, seulement le
+ * dispatch interne de applyAction(). Toute écriture véhicule reste exécutée
+ * dans le processus MG4Control, donc soumise à VehicleWriteGate.
+ *
+ * Protégé par la permission signature com.mg4.control.permission.TASKER_BRIDGE.
+ */
+interface ITaskerBridge {
+
+    /**
+     * Instantané de l'état véhicule pour l'évaluation des conditions.
+     * Toutes les clés sont optionnelles : une valeur absente = donnée illisible.
+     * Voir TaskerBridgeService.KEY_* pour la liste.
+     */
+    Bundle readSnapshot();
+
+    /** Profils MG4Control. Bundle : "ids" String[], "names" String[], "defaultId" String. */
+    Bundle listProfiles();
+
+    /** Applique un profil complet. Bundle résultat : voir applyAction. */
+    Bundle applyProfile(String profileId);
+
+    /**
+     * Exécute une action unitaire du catalogue.
+     * @param actionType identifiant stable, ex. "SET_MEDIA_VOLUME"
+     * @param params arguments typés ("int", "bool", "string" selon l'action)
+     * @return Bundle : "ok" boolean, "verdict" String
+     *         (ALLOWED | REFUSED_MOVING | REFUSED_UNKNOWN_SPEED | UNSUPPORTED | ERROR),
+     *         "detail" String optionnel.
+     */
+    Bundle applyAction(String actionType, in Bundle params);
+}
diff --git a/app/src/main/java/com/mg4/control/hardware/MG4Hardware.kt b/app/src/main/java/com/mg4/control/hardware/MG4Hardware.kt
index 3ce8a0d..b6fc45a 100644
--- a/app/src/main/java/com/mg4/control/hardware/MG4Hardware.kt
+++ b/app/src/main/java/com/mg4/control/hardware/MG4Hardware.kt
@@ -155,6 +155,11 @@ object MG4Hardware {
     // d'écriture à 0 km/h (voir VehicleWriteGate).
     private const val PROP_VEHICLE_SPEED = 0x11600207
 
+    // Standard AAOS — VehicleProperty.ENV_OUTSIDE_TEMPERATURE (float, °C).
+    // NON VÉRIFIÉE sur véhicule : tous les firmwares MG4 n'exposent pas cette propriété.
+    // Les appelants doivent traiter null comme « donnée indisponible », pas comme 0 °C.
+    private const val PROP_OUTSIDE_TEMP = 0x11600703
+
     /** Valeurs de IGNITION_STATE (VehicleIgnitionState) — propriété AAOS standard. */
     object IgnitionState {
         const val UNDEFINED = 0
@@ -333,6 +338,85 @@ object MG4Hardware {
         return kotlin.math.abs(mps) * 3.6f
     }
 
+    /**
+     * Température extérieure en °C, ou null si illisible (CPM non prêt, propriété non
+     * supportée par le firmware, exception).
+     *
+     * Le null est significatif : il veut dire « on ne sait pas », pas « il fait 0 °C ».
+     * Une règle météo qui reçoit null ne doit PAS se déclencher.
+     */
+    fun getOutsideTempCelsius(): Float? =
+        getFloatPropertyCPM(PROP_OUTSIDE_TEMP, AREA_GLOBAL)
+            ?: getFloatPropertyCPM(PROP_OUTSIDE_TEMP, 0)
+
+    // -------------------------------------------------------------------------
+    // Climate + windows — READ ONLY, UNVERIFIED on MG4 firmware.
+    //
+    // Standard AOSP VehicleProperty IDs. The R69 OEM sources expose these names, but the
+    // numeric ids and area ids are not confirmed against any MG4 generation. These reads
+    // exist so the MG4Tasker diagnostic screen can show whether a signal is actually
+    // readable BEFORE any write path is added. Every method returns null when unreadable —
+    // callers must treat null as "unknown", never as a value. No write counterpart exists
+    // on purpose: writing a wrong id to the vehicle is exactly the risk being deferred.
+    // -------------------------------------------------------------------------
+
+    private const val PROP_HVAC_AC_ON          = 0x15200505  // HVAC_AC_ON (bool)
+    private const val PROP_HVAC_AUTO_ON        = 0x1520050A  // HVAC_AUTO_ON (bool)
+    private const val PROP_HVAC_RECIRC_ON      = 0x15200508  // HVAC_RECIRC_ON (bool)
+    private const val PROP_HVAC_FAN_SPEED      = 0x15400500  // HVAC_FAN_SPEED (int)
+    private const val PROP_HVAC_TEMPERATURE_SET = 0x15600503 // HVAC_TEMPERATURE_SET (float °C)
+    private const val PROP_WINDOW_POS          = 0x13340BC0  // WINDOW_POS (int, per window area)
+
+    // Candidate HVAC area ids: the seat-heat area used elsewhere, plus GLOBAL and 0.
+    private val HVAC_AREA_CANDIDATES = intArrayOf(AREA_HVAC, AREA_GLOBAL, 0)
+    // VehicleAreaWindow bits: front windshield + the four door windows.
+    private val WINDOW_AREA_CANDIDATES = intArrayOf(0x0001, 0x0010, 0x0040, 0x0100, 0x0400)
+
+    fun getAcOn(): Boolean?          = readHvacBool(PROP_HVAC_AC_ON)
+    fun getHvacAutoOn(): Boolean?    = readHvacBool(PROP_HVAC_AUTO_ON)
+    fun getRecircOn(): Boolean?      = readHvacBool(PROP_HVAC_RECIRC_ON)
+    fun getFanSpeed(): Int?          = readHvacInt(PROP_HVAC_FAN_SPEED)
+    fun getTemperatureSetCelsius(): Float? = readHvacFloat(PROP_HVAC_TEMPERATURE_SET)
+
+    /** True if any door/windshield window reads as not fully closed; null if none readable. */
+    fun isAnyWindowOpen(): Boolean? {
+        var readAny = false
+        for (area in WINDOW_AREA_CANDIDATES) {
+            val pos = readWindowArea(area) ?: continue
+            readAny = true
+            if (pos > 0) return true
+        }
+        return if (readAny) false else null
+    }
+
+    private fun readHvacBool(propId: Int): Boolean? = readHvacInt(propId)?.let { it != 0 }
+
+    /** Sweeps HVAC-manager then CPM across the candidate areas; null when nothing answers. */
+    private fun readHvacInt(propId: Int): Int? {
+        for (area in HVAC_AREA_CANDIDATES) {
+            getIntPropertyHvac(propId, area).takeIf { it >= 0 }?.let { return it }
+            getIntPropertyCPM(propId, area).takeIf { it >= 0 }?.let { return it }
+        }
+        return null
+    }
+
+    private fun readHvacFloat(propId: Int): Float? {
+        val hvac = sCarHvacManager
+        for (area in HVAC_AREA_CANDIDATES) {
+            if (hvac != null) {
+                runCatching {
+                    hvac.javaClass.getMethod("getFloatProperty", Int::class.java, Int::class.java)
+                        .invoke(hvac, propId, area) as? Float
+                }.getOrNull()?.let { return it }
+            }
+            getFloatPropertyCPM(propId, area)?.let { return it }
+        }
+        return null
+    }
+
+    private fun readWindowArea(area: Int): Int? =
+        getIntPropertyCPM(PROP_WINDOW_POS, area).takeIf { it >= 0 }
+
     /** Contexte applicatif, pour les messages utilisateur du verrou d'écriture. */
     internal fun appContext(): Context? = sAppContext
 
diff --git a/app/src/main/java/com/mg4/control/service/MG4ControlService.kt b/app/src/main/java/com/mg4/control/service/MG4ControlService.kt
index ea793c6..5aeb55c 100644
--- a/app/src/main/java/com/mg4/control/service/MG4ControlService.kt
+++ b/app/src/main/java/com/mg4/control/service/MG4ControlService.kt
@@ -29,6 +29,7 @@ import com.mg4.control.model.RegenLevel
 import com.mg4.control.profile.ProfileApplier
 import com.mg4.control.profile.ProfileManager
 import com.mg4.control.shortcut.ShortcutAction
+import com.mg4.control.tasker.TaskerBridgeService
 import com.mg4.control.util.FirmwareInfo
 import com.mg4.control.util.ThemeHelper
 import kotlinx.coroutines.CoroutineScope
@@ -43,6 +44,12 @@ class MG4ControlService : Service() {
         private const val NOTIF_ID     = 1
         private const val PREFS_SHORTCUTS = "mg4_shortcuts"
 
+        /** Destinataire du broadcast d'allumage. Absent = broadcast sans effet, pas d'erreur. */
+        private const val TASKER_PACKAGE = "com.mg4.tasker"
+
+        /** Marge laissée à l'application du profil par défaut (HVAC scrute jusqu'à ~7 s). */
+        private const val TASKER_NOTIFY_DELAY_MS = 8_000L
+
         // Intent action broadcast par le système SAIC pour les touches physiques
         private const val HARDKEY_ACTION   = "com.saic.keyevent.hardkey.report"
 
@@ -447,6 +454,7 @@ class MG4ControlService : Service() {
                     Handler(Looper.getMainLooper()).postDelayed({
                         applyDefaultProfileOnIgnition()
                     }, 500L)
+                    notifyTaskerOnIgnition()
                 }
                 MG4Hardware.CarIgnitionItem.OFF -> {
                     // Extinction → on oublie le choix manuel : le prochain cycle repart sur le défaut/BT
@@ -462,6 +470,32 @@ class MG4ControlService : Service() {
         AppLogger.i(TAG, "Listener Katman5 enregistré")
     }
 
+    /**
+     * Prévient MG4Tasker qu'un cycle d'allumage vient de commencer.
+     *
+     * Le délai n'est pas cosmétique : [applyDefaultProfileOnIgnition] démarre à +500 ms et
+     * ses écritures HVAC scrutent l'état jusqu'à ~7 s. Réveiller le tasker plus tôt le
+     * ferait écrire pendant qu'un profil est en cours d'application — ces écritures
+     * unitaires ne passent pas par le mutex de ProfileApplier et s'entrelaceraient avec
+     * les séquences ADAS multi-étapes. On laisse donc le profil se poser d'abord.
+     *
+     * Broadcast explicite (package ciblé) + permission signature : aucune app tierce ne
+     * peut ni le recevoir ni s'y substituer.
+     */
+    private fun notifyTaskerOnIgnition() {
+        Handler(Looper.getMainLooper()).postDelayed({
+            val intent = Intent(TaskerBridgeService.ACTION_IGNITION_ON).apply {
+                setPackage(TASKER_PACKAGE)
+            }
+            try {
+                sendBroadcast(intent, TaskerBridgeService.PERMISSION_BRIDGE)
+                AppLogger.i(TAG, "IGNITION → notification MG4Tasker envoyée")
+            } catch (e: Exception) {
+                AppLogger.w(TAG, "IGNITION → notification MG4Tasker échouée : ${e.message}")
+            }
+        }, TASKER_NOTIFY_DELAY_MS)
+    }
+
     /**
      * [BT-PROFILES] Enregistre les receivers ACL Bluetooth pour maintenir
      * la liste des appareils connectés dans BluetoothProfileManager.
diff --git a/app/src/main/java/com/mg4/control/tasker/TaskerBridgeService.kt b/app/src/main/java/com/mg4/control/tasker/TaskerBridgeService.kt
new file mode 100644
index 0000000..1afb299
--- /dev/null
+++ b/app/src/main/java/com/mg4/control/tasker/TaskerBridgeService.kt
@@ -0,0 +1,281 @@
+package com.mg4.control.tasker
+
+import android.app.Service
+import android.content.Intent
+import android.os.Bundle
+import android.os.IBinder
+import com.mg4.control.debug.AppLogger
+import com.mg4.control.hardware.MG4Hardware
+import com.mg4.control.hardware.VehicleWriteGate
+import com.mg4.control.model.DriveMode
+import com.mg4.control.model.RegenLevel
+import com.mg4.control.profile.ProfileApplier
+import com.mg4.control.profile.ProfileManager
+import com.mg4.control.util.FirmwareInfo
+import com.mg4.control.bluetooth.BluetoothProfileManager
+
+/**
+ * Pont IPC pour MG4Tasker (voir [ITaskerBridge]).
+ *
+ * Principe : MG4Tasker ne touche JAMAIS le véhicule. Il lit un instantané et demande des
+ * actions nommées ; l'écriture réelle se fait ici, dans le processus qui détient
+ * android.uid.system et [VehicleWriteGate]. Conséquences voulues :
+ *   • un seul processus écrit → pas d'entrelacement de commandes ADAS
+ *   • le verrou 0 km/h reste appliqué à un seul endroit
+ *   • MG4Tasker n'a pas besoin de privilèges véhicule
+ *
+ * Le catalogue d'actions est une liste fermée. Il n'existe volontairement aucune méthode
+ * « écris la propriété 0xNNNN » : un appelant compromis ne peut solliciter que ce que
+ * l'utilisateur peut déjà faire depuis l'UI de MG4Control.
+ *
+ * [VEHICLE_POWER_OFF] est délibérément ABSENT du catalogue. Couper le véhicule est une
+ * action irréversible pour le conducteur ; elle reste réservée à un geste humain explicite
+ * (raccourci volant), jamais à une règle automatique.
+ */
+class TaskerBridgeService : Service() {
+
+    companion object {
+        private const val TAG = "MG4_TASKER_BRIDGE"
+
+        /** Broadcast émis vers MG4Tasker quand l'allumage passe à ON. */
+        const val ACTION_IGNITION_ON = "com.mg4.control.tasker.IGNITION_ON"
+
+        /** Permission signature exigée du récepteur du broadcast ci-dessus. */
+        const val PERMISSION_BRIDGE = "com.mg4.control.permission.TASKER_BRIDGE"
+
+        // ── Clés de l'instantané ────────────────────────────────────────────
+        // Une clé ABSENTE signifie « illisible ». Ne jamais écrire de valeur
+        // sentinelle (-1) : le tasker la prendrait pour une vraie mesure.
+        const val KEY_SPEED_KMH        = "speedKmh"          // float
+        const val KEY_SPEED_READABLE   = "speedReadable"     // boolean (toujours présent)
+        const val KEY_IGNITION         = "ignition"          // int
+        const val KEY_IN_PARK          = "inPark"            // boolean
+        const val KEY_OUTSIDE_TEMP     = "outsideTempC"      // float
+        const val KEY_DRIVE_MODE       = "driveMode"         // int (DriveMode.value)
+        const val KEY_REGEN_LEVEL      = "regenLevel"        // int (RegenLevel.value)
+        const val KEY_SEAT_HEAT_L      = "seatHeatLeft"      // int
+        const val KEY_SEAT_HEAT_R      = "seatHeatRight"     // int
+        const val KEY_STEERING_HEAT    = "steeringHeat"      // boolean
+        const val KEY_MEDIA_VOLUME     = "mediaVolume"       // int
+        const val KEY_MEDIA_VOLUME_MAX = "mediaVolumeMax"    // int
+        const val KEY_BRIGHTNESS       = "brightnessPct"     // int
+        const val KEY_OVERSPEED_ALARM  = "overspeedAlarm"    // boolean
+        const val KEY_SPEED_LIMIT_TONE = "speedLimitTone"    // boolean
+        const val KEY_SOUND_WARNING    = "soundWarning"      // boolean
+        const val KEY_AEB_ENABLED      = "aebEnabled"        // boolean
+        const val KEY_AEB_MODE         = "aebMode"           // int
+        const val KEY_AEB_SENSITIVITY  = "aebSensitivity"    // int
+        const val KEY_ELK_MODE         = "elkMode"           // int
+        const val KEY_ELK_SENSITIVITY  = "elkSensitivity"    // int
+        const val KEY_TSR              = "tsr"               // boolean
+        const val KEY_ENERGY_SAVING    = "energySaving"      // boolean
+        const val KEY_ACC_TJA_MODE     = "accTjaMode"        // int
+        const val KEY_LIMITER_MODE     = "limiterMode"       // int
+        // Climate + windows — read only, unverified (see MG4Hardware). Absent = unreadable.
+        const val KEY_AC_ON            = "acOn"              // boolean
+        const val KEY_HVAC_AUTO        = "hvacAuto"          // boolean
+        const val KEY_RECIRC           = "recirc"            // boolean
+        const val KEY_FAN_SPEED        = "fanSpeed"          // int
+        const val KEY_TEMPERATURE_SET  = "temperatureSetC"   // float
+        const val KEY_WINDOW_OPEN      = "windowOpen"        // boolean
+        const val KEY_FIRMWARE_GEN     = "firmwareGen"       // String
+        const val KEY_BT_MACS          = "btConnectedMacs"   // String[]
+        const val KEY_HAS_AUDIO        = "hasAudioControl"   // boolean
+        const val KEY_HAS_BRIGHTNESS   = "hasBrightness"     // boolean
+
+        // ── Clés du résultat ────────────────────────────────────────────────
+        const val KEY_OK      = "ok"
+        const val KEY_VERDICT = "verdict"
+        const val KEY_DETAIL  = "detail"
+
+        const val VERDICT_ALLOWED       = "ALLOWED"
+        const val VERDICT_MOVING        = "REFUSED_MOVING"
+        const val VERDICT_UNKNOWN_SPEED = "REFUSED_UNKNOWN_SPEED"
+        const val VERDICT_UNSUPPORTED   = "UNSUPPORTED"
+        const val VERDICT_ERROR         = "ERROR"
+
+        /** Clé unique des paramètres d'action (int, boolean ou String selon l'action). */
+        const val PARAM_VALUE = "value"
+
+        /**
+         * Traduit la décision du verrou en verdict transmissible au tasker.
+         *
+         * Fonction pure et exhaustive : si [VehicleWriteGate.Decision] gagne un cas, la
+         * compilation casse ici plutôt que d'envoyer un verdict inventé au tasker, qui
+         * l'afficherait à l'utilisateur comme un motif de refus.
+         */
+        fun verdictOf(decision: VehicleWriteGate.Decision): String = when (decision) {
+            VehicleWriteGate.Decision.ALLOWED               -> VERDICT_ALLOWED
+            VehicleWriteGate.Decision.REFUSED_MOVING        -> VERDICT_MOVING
+            VehicleWriteGate.Decision.REFUSED_UNKNOWN_SPEED -> VERDICT_UNKNOWN_SPEED
+        }
+    }
+
+    private val profileManager by lazy { ProfileManager(applicationContext) }
+
+    override fun onBind(intent: Intent?): IBinder = binder
+
+    private val binder = object : ITaskerBridge.Stub() {
+
+        override fun readSnapshot(): Bundle = Bundle().apply {
+            val speed = MG4Hardware.getVehicleSpeedKmh()
+            putBoolean(KEY_SPEED_READABLE, speed != null)
+            speed?.let { putFloat(KEY_SPEED_KMH, it) }
+
+            MG4Hardware.getCurrentIgnitionState().takeIf { it > 0 }?.let { putInt(KEY_IGNITION, it) }
+            MG4Hardware.isVehicleInPark()?.let { putBoolean(KEY_IN_PARK, it) }
+            MG4Hardware.getOutsideTempCelsius()?.let { putFloat(KEY_OUTSIDE_TEMP, it) }
+
+            MG4Hardware.getDriveMode()?.let { putInt(KEY_DRIVE_MODE, it.value) }
+            MG4Hardware.getRegenLevel()?.let { putInt(KEY_REGEN_LEVEL, it.value) }
+
+            putIfReadable(KEY_SEAT_HEAT_L, MG4Hardware.getSeatHeatLeft())
+            putIfReadable(KEY_SEAT_HEAT_R, MG4Hardware.getSeatHeatRight())
+            putBoolean(KEY_STEERING_HEAT, MG4Hardware.isSteeringHeatOn())
+
+            putIfReadable(KEY_MEDIA_VOLUME, MG4Hardware.getMediaVolume())
+            putIfReadable(KEY_MEDIA_VOLUME_MAX, MG4Hardware.getMediaVolumeMax())
+
+            putBoolean(KEY_HAS_BRIGHTNESS, MG4Hardware.hasBrightnessControl())
+            if (MG4Hardware.hasBrightnessControl()) {
+                putIfReadable(KEY_BRIGHTNESS, MG4Hardware.getScreenBrightnessPercent())
+            }
+
+            putBoolean(KEY_OVERSPEED_ALARM, MG4Hardware.isOverspeedAlarmOn())
+            putBoolean(KEY_SPEED_LIMIT_TONE, MG4Hardware.isSpeedLimitToneOn())
+            putBoolean(KEY_SOUND_WARNING, MG4Hardware.isSoundWarningOn())
+            putBoolean(KEY_AEB_ENABLED, MG4Hardware.isAebEnabled())
+            putIfReadable(KEY_AEB_MODE, MG4Hardware.getAebMode())
+            putIfReadable(KEY_AEB_SENSITIVITY, MG4Hardware.getAebSensitivity())
+            putIfReadable(KEY_ELK_MODE, MG4Hardware.getElkMode())
+            putIfReadable(KEY_ELK_SENSITIVITY, MG4Hardware.getElkSensitivity())
+            putBoolean(KEY_TSR, MG4Hardware.isTsrOn())
+            putBoolean(KEY_ENERGY_SAVING, MG4Hardware.isEnergySavingOn())
+            putIfReadable(KEY_ACC_TJA_MODE, MG4Hardware.getAccTjaMode())
+            putIfReadable(KEY_LIMITER_MODE, MG4Hardware.getSpeedLimiterMode())
+
+            MG4Hardware.getAcOn()?.let { putBoolean(KEY_AC_ON, it) }
+            MG4Hardware.getHvacAutoOn()?.let { putBoolean(KEY_HVAC_AUTO, it) }
+            MG4Hardware.getRecircOn()?.let { putBoolean(KEY_RECIRC, it) }
+            MG4Hardware.getFanSpeed()?.let { putInt(KEY_FAN_SPEED, it) }
+            MG4Hardware.getTemperatureSetCelsius()?.let { putFloat(KEY_TEMPERATURE_SET, it) }
+            MG4Hardware.isAnyWindowOpen()?.let { putBoolean(KEY_WINDOW_OPEN, it) }
+
+            putString(KEY_FIRMWARE_GEN, FirmwareInfo.getGeneration().name)
+            putBoolean(KEY_HAS_AUDIO, MG4Hardware.hasAudioControl())
+            putStringArray(KEY_BT_MACS, BluetoothProfileManager.getConnectedMacs().toTypedArray())
+        }
+
+        override fun listProfiles(): Bundle {
+            val profiles = profileManager.getAll()
+            return Bundle().apply {
+                putStringArray("ids", profiles.map { it.id }.toTypedArray())
+                putStringArray("names", profiles.map { it.name }.toTypedArray())
+                profileManager.getDefaultId()?.let { putString("defaultId", it) }
+            }
+        }
+
+        override fun applyProfile(profileId: String?): Bundle {
+            val profile = profileId?.let { profileManager.getById(it) }
+                ?: return result(false, VERDICT_UNSUPPORTED, "profil introuvable: $profileId")
+
+            // Le gate est ré-évalué réglage par réglage dans ProfileApplier ; on renvoie
+            // ici le verdict courant pour que le tasker sache s'il faut s'attendre à des
+            // refus partiels. L'application elle-même est asynchrone.
+            val verdict = gateVerdict()
+            ProfileApplier.apply(profile, autoStart = true)
+            AppLogger.i(TAG, "applyProfile(${profile.name}) verdict=$verdict")
+            return result(true, verdict, profile.name)
+        }
+
+        override fun applyAction(actionType: String?, params: Bundle?): Bundle {
+            val type = actionType ?: return result(false, VERDICT_UNSUPPORTED, "action nulle")
+            val args = params ?: Bundle()
+            return try {
+                dispatch(type, args)
+            } catch (e: Exception) {
+                AppLogger.w(TAG, "applyAction($type) exception: ${e.message}")
+                result(false, VERDICT_ERROR, e.message)
+            }
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Catalogue d'actions
+    // -------------------------------------------------------------------------
+
+    /**
+     * [gated] = écriture qui change le comportement routier → soumise au verrou 0 km/h.
+     * On calcule le verdict AVANT d'appeler MG4Hardware, uniquement pour pouvoir le
+     * rapporter au tasker. Le refus effectif reste celui de MG4Hardware/VehicleWriteGate :
+     * cette pré-lecture n'est pas la garde, elle l'observe.
+     */
+    private fun dispatch(type: String, args: Bundle): Bundle {
+        val i = { args.getInt(PARAM_VALUE) }
+        val b = { args.getBoolean(PARAM_VALUE) }
+
+        return when (type) {
+            // ── Confort : pas de gate (n'altère pas le comportement routier) ──
+            "SET_SEAT_HEAT_LEFT"       -> ungated { MG4Hardware.setSeatHeatLeft(i()) }
+            "SET_SEAT_HEAT_RIGHT"      -> ungated { MG4Hardware.setSeatHeatRight(i()) }
+            "SET_STEERING_HEAT"        -> ungated { MG4Hardware.setSteeringHeat(b()) }
+            "SET_MEDIA_VOLUME"         -> ungated { MG4Hardware.setMediaVolume(i()) }
+            "SET_SCREEN_BRIGHTNESS"    -> ungated { MG4Hardware.setScreenBrightnessPercent(i()) }
+            "SET_AUDIO_BALANCE"        -> ungated { MG4Hardware.setAudioBalance(i()) }
+            "SET_AUDIO_FADER"          -> ungated { MG4Hardware.setAudioFader(i()) }
+            "SET_BOSE_SOUND_TYPE"      -> ungated { MG4Hardware.setBoseSoundType(i()) }
+            "SET_3D_EFFECT"            -> ungated { MG4Hardware.set3dEffectType(i()) }
+            "SET_TONE_CONTROL"         -> ungated { MG4Hardware.setToneControl(i()) }
+            "SET_SOUND_FIELD"          -> ungated { MG4Hardware.setSoundFieldType(i()) }
+            "SET_SPEED_VOLUME"         -> ungated { MG4Hardware.setSpeedVolumeLevel(i()) }
+            "SET_LAS_WARNING_SOUND"    -> ungated { MG4Hardware.setLasWarningSound(b()) }
+            "SET_LAS_WARNING_VIBRATION"-> ungated { MG4Hardware.setLasWarningVibration(b()) }
+
+            // ── Comportement routier : gated ──────────────────────────────────
+            "SET_DRIVE_MODE"      -> gated { MG4Hardware.setDriveMode(DriveMode.fromValue(i())) }
+            "SET_REGEN_LEVEL"     -> gated { MG4Hardware.setRegenLevel(RegenLevel.fromValue(i())) }
+            "SET_ONE_PEDAL"       -> gated { MG4Hardware.setOnePedal(b()) }
+            "SET_OVERSPEED_ALARM" -> gated { MG4Hardware.setOverspeedAlarm(b()) }
+            "SET_SPEED_LIMIT_TONE"-> gated { MG4Hardware.setSpeedLimitTone(b()) }
+            "SET_SOUND_WARNING"   -> gated { MG4Hardware.setSoundWarning(b()) }
+            "SET_AEB_ENABLED"     -> gated { MG4Hardware.setAebEnabled(b()) }
+            "SET_AEB_MODE"        -> gated { MG4Hardware.setAebMode(i()) }
+            "SET_AEB_SENSITIVITY" -> gated { MG4Hardware.setAebSensitivity(i()) }
+            "SET_ELK_MODE"        -> gated { MG4Hardware.setElkMode(i()) }
+            "SET_ELK_SENSITIVITY" -> gated { MG4Hardware.setElkSensitivity(i()) }
+            "SET_TSR"             -> gated { MG4Hardware.setTsrMode(b()) }
+            "SET_ENERGY_SAVING"   -> gated { MG4Hardware.setEnergySavingMode(b()) }
+            "SET_ACC_TJA_MODE"    -> gated { MG4Hardware.setAccTjaMode(i()) }
+            "SET_LIMITER_MODE"    -> gated { MG4Hardware.setSpeedLimiterMode(i()) }
+            "SET_INTELLIGENT_DRIVE"-> gated { MG4Hardware.setMixedIntelligentDrive(i()) }
+
+            else -> result(false, VERDICT_UNSUPPORTED, "action inconnue: $type")
+        }
+    }
+
+    private inline fun ungated(write: () -> Boolean): Bundle {
+        val ok = write()
+        return result(ok, if (ok) VERDICT_ALLOWED else VERDICT_ERROR)
+    }
+
+    private inline fun gated(write: () -> Boolean): Bundle {
+        val verdict = gateVerdict()
+        if (verdict != VERDICT_ALLOWED) return result(false, verdict)
+        val ok = write()
+        return result(ok, if (ok) VERDICT_ALLOWED else VERDICT_ERROR)
+    }
+
+    private fun gateVerdict(): String =
+        verdictOf(VehicleWriteGate.decide(MG4Hardware.getVehicleSpeedKmh()))
+
+    private fun result(ok: Boolean, verdict: String, detail: String? = null) = Bundle().apply {
+        putBoolean(KEY_OK, ok)
+        putString(KEY_VERDICT, verdict)
+        detail?.let { putString(KEY_DETAIL, it) }
+    }
+
+    /** Les getters MG4Hardware renvoient -1 quand la couche n'est pas prête : on n'écrit rien. */
+    private fun Bundle.putIfReadable(key: String, value: Int) {
+        if (value >= 0) putInt(key, value)
+    }
+}
diff --git a/app/src/test/java/com/mg4/control/tasker/TaskerBridgeVerdictTest.kt b/app/src/test/java/com/mg4/control/tasker/TaskerBridgeVerdictTest.kt
new file mode 100644
index 0000000..16c0342
--- /dev/null
+++ b/app/src/test/java/com/mg4/control/tasker/TaskerBridgeVerdictTest.kt
@@ -0,0 +1,48 @@
+package com.mg4.control.tasker
+
+import com.mg4.control.hardware.VehicleWriteGate
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Le verdict est la seule explication que MG4Tasker peut donner à l'utilisateur quand une
+ * règle ne s'applique pas. S'il est faux ou vide, l'utilisateur voit « rien ne s'est passé »
+ * sans savoir que c'est le verrou de vitesse qui a refusé.
+ */
+class TaskerBridgeVerdictTest {
+
+    @Test
+    fun `chaque decision du verrou a un verdict distinct et non vide`() {
+        val verdicts = VehicleWriteGate.Decision.values()
+            .map { TaskerBridgeService.verdictOf(it) }
+
+        verdicts.forEach { assertTrue("verdict vide", it.isNotBlank()) }
+        assertEquals(
+            "deux décisions ne doivent jamais produire le même verdict",
+            verdicts.size, verdicts.toSet().size
+        )
+    }
+
+    @Test
+    fun `vitesse nulle autorise, vitesse non nulle refuse`() {
+        assertEquals(
+            TaskerBridgeService.VERDICT_ALLOWED,
+            TaskerBridgeService.verdictOf(VehicleWriteGate.decide(0f))
+        )
+        assertEquals(
+            TaskerBridgeService.VERDICT_MOVING,
+            TaskerBridgeService.verdictOf(VehicleWriteGate.decide(42f))
+        )
+    }
+
+    @Test
+    fun `vitesse illisible refuse au lieu de laisser passer`() {
+        // Fail closed : une vitesse inconnue ne doit jamais ouvrir la porte au tasker,
+        // qui écrirait alors sans supervision humaine sur un véhicule potentiellement roulant.
+        assertEquals(
+            TaskerBridgeService.VERDICT_UNKNOWN_SPEED,
+            TaskerBridgeService.verdictOf(VehicleWriteGate.decide(null))
+        )
+    }
+}

From 0681b2a62239d961a48b7f753c874c9979538a7e Mon Sep 17 00:00:00 2001
From: Malys <malys.training@gmail.com>
Date: Thu, 23 Jul 2026 10:11:44 +0200
Subject: [PATCH 03/13] refactor: consume shared MG4Hardware library via git
 submodule

Move the vehicle-access layer (MG4Hardware, VehicleWriteGate, FirmwareInfo,
AppLogger, driving models) out of the app and into the shared MG4Hardware
library, vendored as a git submodule at ./MG4Hardware and consumed as the
:mg4hardware Gradle subproject. One implementation across MG4Control,
MG4Tasker and ABRP_Uploader, no drift.

- VehicleWriteGate no longer references the app's R: it takes a message
  provider, which MG4ControlService sets to MG4Control's localized strings
  (the module falls back to English).
- Every gated setter now carries @RequiresStandstill (in the library).
- Imports repointed to com.mg4.hardware.*; ProGuard keep rules and the
  ProguardRules test updated to the new package.
- CI checks out submodules recursively.

Behaviour is unchanged; this is a structural move. Needs the usual
on-vehicle release check (R8 + reflection + system UID) before shipping.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .github/workflows/release.yml                 |    2 +
 .github/workflows/security.yml                |    6 +
 .github/workflows/tests.yml                   |    2 +
 .gitmodules                                   |    3 +
 MG4Hardware                                   |    1 +
 app/build.gradle.kts                          |    4 +
 app/proguard-rules.pro                        |    6 +-
 app/src/main/java/com/mg4/control/MG4App.kt   |    2 +-
 .../main/java/com/mg4/control/MainActivity.kt |    4 +-
 .../java/com/mg4/control/debug/AppLogger.kt   |  117 -
 .../java/com/mg4/control/debug/CrashLogger.kt |    1 +
 .../com/mg4/control/hardware/MG4Hardware.kt   | 3605 -----------------
 .../mg4/control/hardware/VehicleWriteGate.kt  |   81 -
 .../java/com/mg4/control/model/DriveMode.kt   |   13 -
 .../com/mg4/control/model/DrivingProfile.kt   |   41 -
 .../com/mg4/control/model/ProfileBackup.kt    |   17 -
 .../java/com/mg4/control/model/RegenLevel.kt  |   14 -
 .../com/mg4/control/profile/ProfileApplier.kt |   10 +-
 .../control/profile/ProfileBackupManager.kt   |    6 +-
 .../com/mg4/control/profile/ProfileManager.kt |    4 +-
 .../com/mg4/control/receiver/BootReceiver.kt  |    2 +-
 .../mg4/control/service/MG4ControlService.kt  |   22 +-
 .../control/service/ProfilePickerOverlay.kt   |   10 +-
 .../mg4/control/tasker/TaskerBridgeService.kt |   12 +-
 .../java/com/mg4/control/ui/AdasFragment.kt   |    8 +-
 .../java/com/mg4/control/ui/AudioFragment.kt  |    2 +-
 .../com/mg4/control/ui/ClimateFragment.kt     |    2 +-
 .../com/mg4/control/ui/ConsoleFragment.kt     |    4 +-
 .../com/mg4/control/ui/DashboardFragment.kt   |   18 +-
 .../com/mg4/control/ui/DriveRegenFragment.kt  |    6 +-
 .../java/com/mg4/control/ui/ProfileAdapter.kt |    6 +-
 .../com/mg4/control/ui/ProfileFragment.kt     |   20 +-
 .../com/mg4/control/ui/SettingsFragment.kt    |    4 +-
 .../com/mg4/control/ui/ShortcutsFragment.kt   |    6 +-
 .../com/mg4/control/update/ApkSecurity.kt     |    2 +-
 .../com/mg4/control/update/UpdateChecker.kt   |    2 +-
 .../com/mg4/control/util/FirmwareHelper.kt    |    2 +-
 .../java/com/mg4/control/util/FirmwareInfo.kt |  129 -
 .../java/com/mg4/control/ProguardRulesTest.kt |    4 +-
 .../com/mg4/control/debug/AppLoggerTest.kt    |    1 +
 .../com/mg4/control/debug/CrashLoggerTest.kt  |    1 +
 .../control/hardware/VehicleWriteGateTest.kt  |    3 +-
 .../control/profile/ProfileConcurrencyTest.kt |    6 +-
 .../mg4/control/profile/ProfileManagerTest.kt |    6 +-
 .../control/tasker/TaskerBridgeVerdictTest.kt |    2 +-
 .../com/mg4/control/update/ApkSecurityTest.kt |    1 +
 settings.gradle.kts                           |    5 +
 47 files changed, 123 insertions(+), 4102 deletions(-)
 create mode 100644 .gitmodules
 create mode 160000 MG4Hardware
 delete mode 100644 app/src/main/java/com/mg4/control/debug/AppLogger.kt
 delete mode 100644 app/src/main/java/com/mg4/control/hardware/MG4Hardware.kt
 delete mode 100644 app/src/main/java/com/mg4/control/hardware/VehicleWriteGate.kt
 delete mode 100644 app/src/main/java/com/mg4/control/model/DriveMode.kt
 delete mode 100644 app/src/main/java/com/mg4/control/model/DrivingProfile.kt
 delete mode 100644 app/src/main/java/com/mg4/control/model/ProfileBackup.kt
 delete mode 100644 app/src/main/java/com/mg4/control/model/RegenLevel.kt
 delete mode 100644 app/src/main/java/com/mg4/control/util/FirmwareInfo.kt

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index df24cee..3dede97 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -18,6 +18,8 @@ jobs:
       MG4_KEYSTORE_BASE64: ${{ secrets.MG4_KEYSTORE_BASE64 }}
     steps:
       - uses: actions/checkout@v4
+        with:
+          submodules: recursive
 
       - uses: actions/setup-java@v4
         with:
diff --git a/.github/workflows/security.yml b/.github/workflows/security.yml
index 1d1c87f..2d84da6 100644
--- a/.github/workflows/security.yml
+++ b/.github/workflows/security.yml
@@ -18,6 +18,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+        with:
+          submodules: recursive
       - name: Check manifest permissions
         run: bash .github/security/check-permissions.sh
 
@@ -36,6 +38,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+        with:
+          submodules: recursive
       - uses: actions/setup-python@v5
         with: { python-version: "3.12" }
 
@@ -94,6 +98,8 @@ jobs:
       NVD_API_KEY: ${{ secrets.NVD_API_KEY }}
     steps:
       - uses: actions/checkout@v4
+        with:
+          submodules: recursive
       # Runs only when an NVD API key is configured — otherwise the NVD API is too
       # rate-limited to be useful, and an empty --nvdApiKey breaks the tool.
       - name: OWASP Dependency-Check
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 5be4f4e..da4c45c 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -17,6 +17,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+        with:
+          submodules: recursive
 
       - uses: actions/setup-java@v4
         with:
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..130ca99
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "MG4Hardware"]
+	path = MG4Hardware
+	url = https://github.com/malys/MG4Hardware
diff --git a/MG4Hardware b/MG4Hardware
new file mode 160000
index 0000000..131a2e4
--- /dev/null
+++ b/MG4Hardware
@@ -0,0 +1 @@
+Subproject commit 131a2e4a834d638ec9cc9ee2ffbc6eefb21a9177
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index b780bd1..de01039 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -74,6 +74,7 @@ android {
         aidl = true
     }
 
+
     // Tests unitaires JVM (pas de véhicule, pas d'émulateur) : Robolectric a besoin des
     // ressources Android pour instancier un Context.
     testOptions {
@@ -95,6 +96,9 @@ android {
 }
 
 dependencies {
+    // Shared vehicle layer (git submodule ./MG4Hardware, subproject :mg4hardware).
+    implementation(project(":mg4hardware"))
+
     implementation(libs.androidx.core.ktx)
     implementation(libs.androidx.appcompat)
     implementation(libs.androidx.constraintlayout)
diff --git a/app/proguard-rules.pro b/app/proguard-rules.pro
index 770003e..07e699a 100644
--- a/app/proguard-rules.pro
+++ b/app/proguard-rules.pro
@@ -2,8 +2,8 @@
 -keep class android.car.** { *; }
 -keep class android.os.ServiceManager { *; }
 -keep class com.saicmotor.** { *; }
--keep class com.mg4.control.model.** { *; }
--keep class com.mg4.control.hardware.MG4Hardware { *; }
+-keep class com.mg4.hardware.model.** { *; }
+-keep class com.mg4.hardware.MG4Hardware { *; }
 
 # Reflected by Class.forName in MG4Hardware/FirmwareInfo — same treatment as
 # ServiceManager, which was already listed.
@@ -24,7 +24,7 @@
 -keep class * extends com.google.gson.reflect.TypeToken
 
 # Les champs des classes sérialisées sont lus par réflexion : ne pas les renommer.
--keepclassmembers class com.mg4.control.model.** {
+-keepclassmembers class com.mg4.hardware.model.** {
     <fields>;
     <init>(...);
 }
diff --git a/app/src/main/java/com/mg4/control/MG4App.kt b/app/src/main/java/com/mg4/control/MG4App.kt
index ca7eed8..dbda4e3 100644
--- a/app/src/main/java/com/mg4/control/MG4App.kt
+++ b/app/src/main/java/com/mg4/control/MG4App.kt
@@ -3,7 +3,7 @@ package com.mg4.control
 import android.app.Application
 import android.content.Context
 import androidx.appcompat.app.AppCompatDelegate
-import com.mg4.control.debug.AppLogger
+import com.mg4.hardware.AppLogger
 import com.mg4.control.debug.CrashLogger
 import com.mg4.control.util.LocaleHelper
 import com.mg4.control.util.ThemeHelper
diff --git a/app/src/main/java/com/mg4/control/MainActivity.kt b/app/src/main/java/com/mg4/control/MainActivity.kt
index 1f97135..38d26ab 100644
--- a/app/src/main/java/com/mg4/control/MainActivity.kt
+++ b/app/src/main/java/com/mg4/control/MainActivity.kt
@@ -15,7 +15,7 @@ import androidx.appcompat.app.AppCompatActivity
 import androidx.navigation.NavController
 import androidx.navigation.fragment.NavHostFragment
 import com.google.android.material.button.MaterialButton
-import com.mg4.control.hardware.MG4Hardware
+import com.mg4.hardware.MG4Hardware
 import com.mg4.control.profile.ProfileManager
 import com.mg4.control.service.MG4ControlService
 import kotlinx.coroutines.CoroutineScope
@@ -24,7 +24,7 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import com.mg4.control.update.UpdateChecker
 import com.mg4.control.update.UpdateDialogManager
-import com.mg4.control.util.FirmwareInfo
+import com.mg4.hardware.FirmwareInfo
 import com.mg4.control.util.LocaleHelper
 import com.mg4.control.util.ThemeHelper
 
diff --git a/app/src/main/java/com/mg4/control/debug/AppLogger.kt b/app/src/main/java/com/mg4/control/debug/AppLogger.kt
deleted file mode 100644
index ada1837..0000000
--- a/app/src/main/java/com/mg4/control/debug/AppLogger.kt
+++ /dev/null
@@ -1,117 +0,0 @@
-package com.mg4.control.debug
-
-import android.os.Handler
-import android.os.Looper
-import android.util.Log
-import java.text.SimpleDateFormat
-import java.util.Date
-import java.util.Locale
-import java.util.concurrent.CopyOnWriteArrayList
-
-/**
- * In-app log buffer — mirrors every Log.* call to an in-memory ring buffer
- * so the ConsoleFragment can display them without ADB.
- *
- * Le buffer est un ArrayDeque sous verrou : la CopyOnWriteArrayList précédente recopiait
- * les 400 entrées deux fois par ligne de log, sur le thread appelant — c'est-à-dire
- * pendant l'application d'un profil. Les listeners sont notifiés hors du chemin chaud.
- */
-object AppLogger {
-
-    enum class Level { DEBUG, INFO, WARN, ERROR }
-
-    data class Entry(
-        val time: String,
-        val tag: String,
-        val level: Level,
-        val msg: String
-    )
-
-    private const val MAX_ENTRIES = 400
-    private val sdf = SimpleDateFormat("HH:mm:ss.SSS", Locale.getDefault())
-
-    private val lock = Any()
-    private val buffer = ArrayDeque<Entry>(MAX_ENTRIES)
-
-    /**
-     * Nombre total d'entrées ajoutées depuis le démarrage du processus — l'éviction ne le
-     * décrémente pas. Permet à l'UI de savoir ce qui est nouveau sans comparer des tailles
-     * (la taille cesse de bouger dès que le buffer est plein).
-     */
-    @Volatile
-    var totalCount: Long = 0L
-        private set
-
-    /** Copie instantanée du buffer, de la plus ancienne à la plus récente entrée. */
-    val entries: List<Entry>
-        get() = synchronized(lock) { buffer.toList() }
-
-    private val listeners = CopyOnWriteArrayList<() -> Unit>()
-
-    private val mainHandler = Handler(Looper.getMainLooper())
-
-    /** Notification déjà programmée : une rafale de logs ne donne qu'un seul réveil UI. */
-    @Volatile
-    private var notifyPending = false
-
-    // ---- Public log methods (mirror android.util.Log) ----
-
-    fun d(tag: String, msg: String) { add(tag, Level.DEBUG, msg); Log.d(tag, msg) }
-    fun i(tag: String, msg: String) { add(tag, Level.INFO,  msg); Log.i(tag, msg) }
-    fun w(tag: String, msg: String) { add(tag, Level.WARN,  msg); Log.w(tag, msg) }
-    fun e(tag: String, msg: String) { add(tag, Level.ERROR, msg); Log.e(tag, msg) }
-
-    fun clear() {
-        synchronized(lock) {
-            buffer.clear()
-            totalCount = 0L
-        }
-        notifyListeners()
-    }
-
-    /**
-     * Entrées ajoutées depuis que l'appelant en avait vu [sinceTotal], ou null si les
-     * entrées manquantes ont déjà été évincées — dans ce cas l'appelant doit tout
-     * redessiner.
-     */
-    fun entriesSince(sinceTotal: Long): List<Entry>? = synchronized(lock) {
-        val missing = totalCount - sinceTotal
-        when {
-            missing < 0L          -> null          // buffer vidé entre-temps (clear)
-            missing == 0L         -> emptyList()
-            missing > buffer.size -> null          // trop tard : entrées évincées
-            else                  -> buffer.toList().takeLast(missing.toInt())
-        }
-    }
-
-    // ---- Listener for live UI updates ----
-
-    fun addListener(l: () -> Unit)    { listeners.add(l) }
-    fun removeListener(l: () -> Unit) { listeners.remove(l) }
-
-    // ---- Internal ----
-
-    private fun add(tag: String, level: Level, msg: String) {
-        val entry = Entry(sdf.format(Date()), tag, level, msg)
-        synchronized(lock) {
-            // while et non if : le plafond tient même en cas d'ajouts concurrents.
-            while (buffer.size >= MAX_ENTRIES) buffer.removeFirst()
-            buffer.addLast(entry)
-            totalCount++
-        }
-        notifyListeners()
-    }
-
-    /**
-     * Réveille l'UI sur le thread principal, au plus une fois par rafale : la notification
-     * ne doit pas s'exécuter sur le thread qui journalise.
-     */
-    private fun notifyListeners() {
-        if (listeners.isEmpty() || notifyPending) return
-        notifyPending = true
-        mainHandler.post {
-            notifyPending = false
-            listeners.forEach { runCatching { it.invoke() } }
-        }
-    }
-}
diff --git a/app/src/main/java/com/mg4/control/debug/CrashLogger.kt b/app/src/main/java/com/mg4/control/debug/CrashLogger.kt
index 2036e7a..cc42464 100644
--- a/app/src/main/java/com/mg4/control/debug/CrashLogger.kt
+++ b/app/src/main/java/com/mg4/control/debug/CrashLogger.kt
@@ -2,6 +2,7 @@ package com.mg4.control.debug
 
 import android.content.Context
 import androidx.annotation.VisibleForTesting
+import com.mg4.hardware.AppLogger
 import java.io.File
 import java.text.SimpleDateFormat
 import java.util.Date
diff --git a/app/src/main/java/com/mg4/control/hardware/MG4Hardware.kt b/app/src/main/java/com/mg4/control/hardware/MG4Hardware.kt
deleted file mode 100644
index b6fc45a..0000000
--- a/app/src/main/java/com/mg4/control/hardware/MG4Hardware.kt
+++ /dev/null
@@ -1,3605 +0,0 @@
-package com.mg4.control.hardware
-
-import android.content.ComponentName
-import android.content.Context
-import android.content.Intent
-import android.content.ServiceConnection
-import android.os.Handler
-import android.os.IBinder
-import android.os.Looper
-import android.os.Parcel
-import java.lang.reflect.InvocationHandler
-import java.lang.reflect.Proxy
-import com.mg4.control.debug.AppLogger
-import com.mg4.control.model.DriveMode
-import com.mg4.control.model.RegenLevel
-import com.mg4.control.util.FirmwareInfo
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-
-/**
- * Hardware abstraction layer for MG4 vehicle control.
- * Reconstructed from DriveHub Dort 0.9 smali.
- *
- * Three communication layers (mirrors original exactly):
- *  Katman1 — android.car.Car → CarPropertyManager / CarHvacManager (async ServiceConnection)
- *  Katman2 — ServiceManager.getService("vehiclesetting") → raw IBinder (often SELinux-blocked)
- *  Katman3 — bindService(VehicleService) → IHubService → sub-services (not needed for our use case)
- */
-object MG4Hardware {
-
-    private const val TAG = "MG4_HW"
-
-    // Area IDs
-    private const val AREA_GLOBAL = 0x1000000
-    private const val AREA_HVAC   = 0x75
-
-    // Vehicle property IDs
-    private const val PROP_DRIVE_MODE  = 0x2140a17c
-    private const val PROP_REGEN_LEVEL = 0x2140a191
-    private const val PROP_ONE_PEDAL   = 0x2140a193
-    const val PROP_SEAT_HEAT_L         = 0x15402513
-    const val PROP_SEAT_HEAT_R         = 0x15402514
-    const val PROP_STEERING_HEAT       = 0x1540253a
-
-    // SAIC binder transaction codes
-    private const val TX_SET_DRIVE_MODE  = 0x82
-    private const val TX_SET_REGEN_LEVEL = 0xa1
-    private const val TX_SET_ONE_PEDAL   = 0xa4
-
-    private const val DESCRIPTOR_VEHICLE  = "com.saicmotor.sdk.vehiclesettings.IVehicleSettingService"
-    private const val DESCRIPTOR_VSM132   = "com.saicmotor.vehiclesetting.IVehicleSettingService"
-    private const val PREFS_NAME          = "drivehub_dort"
-    private const val KEY_LAST_DRIVE_MODE = "last_drive_mode"
-
-    // ADAS property IDs — SWI133 (getMixProperty / getIntProperty)
-    private const val PROP_OVERSPEED_ALARM       = 0x503004e
-    private const val PROP_SPEED_LIMIT_TONE      = 0x503004f
-    private const val PROP_MIX_INTELLIGENT_DRIVE = 0x32
-
-    // ELK — Assistant de sortie de voie (SWI133)
-    // Accès via IVehicleSettingService binder (sVehicleBinder) — smali IVehicleSettingService$Stub$Proxy
-    // getLaneKeepingAsstMode()   → TX 0x53 (synchrone, reply: readException + readInt)
-    // setLaneKeepingAsstMode(I)  → TX 0x54 (ONEWAY, data: writeInt(value))
-    // getLaneKeepingAsstSen()    → TX 0x55 (synchrone)
-    // setLaneKeepingAsstSen(I)   → TX 0x56 (ONEWAY)
-    // Mode  : 1=OFF, 2=Alerte(LDW), 3=Aider(LDP), 5=Maintien d'urgence(ELK)
-    // Sen   : 1=Faible, 2=Standard, 3=Élevé
-    private const val TX_ELK_GET_MODE = 0x53
-    private const val TX_ELK_SET_MODE = 0x54
-    private const val TX_ELK_GET_SEN  = 0x55
-    private const val TX_ELK_SET_SEN  = 0x56
-
-    // SWI132 binder TX codes (IVehicleSettingService — DESCRIPTOR_VSM132, two-way flag=0x0)
-    // Setters : 0x057=setSLIFWarningState, 0x128=setOverSpeedSoundMode, 0x12a=setSpeedLimitSoundMode
-    // Getters : 0x058=getSLIFWarningState, 0x129=getOverSpeedSoundMode, 0x12b=getSpeedLimitSoundMode
-    private const val VSM132_TX_SLIF_WARNING    = 0x057
-    private const val VSM132_TX_OVERSPEED_SOUND = 0x128
-    private const val VSM132_TX_SPEED_LIMIT     = 0x12a
-    private const val VSM132_TX_GET_SLIF        = 0x058
-    private const val VSM132_TX_GET_OVERSPEED   = 0x129
-    private const val VSM132_TX_GET_SPEED_LIMIT = 0x12b
-
-    /** Valeurs du mode ELK (LaneKeepingAsstMode). */
-    object ElkMode {
-        const val OFF       = 1   // Désactivé
-        const val ALERT     = 2   // Alerte (LDW)
-        const val ASSIST    = 3   // Aider (LDP)
-        const val EMERGENCY = 5   // Maintien d'urgence (ELK)
-    }
-
-    /** Valeurs de sensibilité ELK. */
-    object ElkSensitivity {
-        const val LOW      = 1   // Faible
-        const val STANDARD = 2   // Standard
-        const val HIGH     = 3   // Élevé
-    }
-
-    // AEB — Système anti-collision avant (SWI133)
-    // PROP_AEB_SWITCH    : CarPropertyManager, AREA_GLOBAL, 1=OFF / 2=ON
-    private const val PROP_AEB_SWITCH    = 0x2140a108  // AAD_FRONT_COLLISION_ASST_SYS (CPM)
-    // PROP_AEB_SYS_MODE  : VPM, ID_AAD_FRONT_COLLISION_ASST_SYS, 1=Alerte / 2=Alerte+Freinage
-    // PROP_AEB_MODE      : VPM, ID_AAD_AUTO_EME_BREAK,            1=Alerte / 2=Alerte+Freinage
-    // Le smali vehiclesettings écrit toujours les deux simultanément via setIntPropertyRecovery
-    private const val PROP_AEB_SYS_MODE    = 0x302000a  // ID_AAD_FRONT_COLLISION_ASST_SYS (VPM)
-    private const val PROP_AEB_MODE        = 0x302000b  // ID_AAD_AUTO_EME_BREAK (VPM)
-    // PROP_AEB_SENSITIVITY : VPM, ForwardCollisionAsstSentItem, 1=Faible / 2=Standard / 3=Élevé
-    private const val PROP_AEB_SENSITIVITY = 0x302000e  // ID_AAD_FRONT_COLLISION_ASST_SEN (VPM)
-
-    // TSR — Reconnaissance des panneaux de vitesse (SLIF Warning)
-    // SWI133 : VPM toggle 0/1 ; SWI68/SWI165 : VSM setSpeedAsstSlifWarning ; SWI69/SWI131 : VSM setSLIFWarningState (inversé)
-    private const val PROP_TSR_MODE = 0x5030049  // ID_AAD_SLIF_WARNING
-
-    // Économie d'énergie (Endurance Mode / Longer Endurance)
-    // SWI133 : VPM PROP_ENERGY_SAVING ; SWI69/SWI131 : VSM setEnduranceMode ; SWI68/SWI165 : VSM setLongerEndurance
-    private const val PROP_ENERGY_SAVING = 0x5030007  // ID_LONGER_ENDURANCE_MODE
-
-    // SWI68 : VehicleSettingManager class name (loaded via launcher context)
-    private const val VSM_CLASS      = "com.saicmotor.sdk.vehiclesettings.manager.VehicleSettingManager"
-    private const val LAUNCHER68_PKG = "com.saicmotor.hmi.launcher"
-
-    // Luminosité écran — ancien SDK (SWI133/68/165) : GeneralManager.setBrightness(Int)/getBrightness().
-    // Plage native 0..255 (constantes DARKEST_VALUE=0x0 / BRIGHTEST_VALUE=0xff confirmées dans le smali).
-    // A9 (SWI132/131/69) = phase 2 (setScreenBrightness(III), params non décodables sans SystemUI).
-    private const val GENERAL_MANAGER_CLASS = "com.saicmotor.sdk.systemsettings.GeneralManager"
-    private const val BRIGHTNESS_NATIVE_MAX = 255
-
-    // Volume média — ancien SDK (SWI133/68/165) : SmartSoundManager.getVolume/setVolume/getMaxVolume(type).
-    // Même SDK systemsettings/BaseManager que GeneralManager (singleton sInstance + init(Context, listener)).
-    private const val SMART_SOUND_MANAGER_CLASS = "com.saicmotor.sdk.systemsettings.SmartSoundManager"
-    private const val BRIGHTNESS_MIN_PERCENT = 5   // plancher de sécurité : ne jamais éteindre l'écran
-
-    // SWI69/SWI131 : accès via CarAdapterClient → queryClient(0x8) → CarVehicleSettingClient
-    // Architecture réelle : CarAdapterClient se connecte à com.saicmotor.caradapter.CarAdapterService,
-    // puis queryClient(code) retourne l'IBinder pour chaque service.
-    // Code 0x8 = CarVehicleSettingClient (vérifié dans VehicleSettingService.onResult() smali)
-    private const val LAUNCHER69_PKG      = "com.saicmotor.launcher"
-    private const val CAR_ADAPTER_CLASS   = "com.saicmotor.carapi.CarAdapterClient"
-    private const val VSM69_CLIENT_CLASS  = "com.saicmotor.carapi.client.CarVehicleSettingClient"
-    private const val VSM_SERVICE_CODE    = 0x8   // queryClient(0x8) → ICarVehicleSettingService
-    private const val VEHICLE_SETTING_PKG = "com.saicmotor.vehiclesetting"  // SWI131 : carapi dans VS
-
-    // Katman5 — VehicleConditionManager (IVehicleConditionService via IHubService "vehiclecondition")
-    private const val VCM_CLASS          = "com.saicmotor.sdk.vehiclesettings.manager.VehicleConditionManager"
-    private const val VCM_LISTENER_CLASS = "com.saicmotor.sdk.vehiclesettings.IVehicleConditionListener"
-
-    // Katman5 SWI69/SWI131 — ICarGeneralService via CarAdapterClient (queryClient(0x1))
-    private const val CAR_GENERAL_CLIENT_CLASS = "com.saicmotor.carapi.client.CarGeneralClient"
-    private const val BIND_CODE_CAR_GENERAL    = 0x1   // ICarAdapterService.queryClient(0x1)
-
-    // Standard AAOS — VehicleProperty.IGNITION_STATE (compatible tous firmwares via CarPropertyManager)
-    private const val PROP_IGNITION_STATE = 0x11400409
-
-    // Standard AAOS — VehicleProperty.PERF_VEHICLE_SPEED (float, m/s). Base du verrou
-    // d'écriture à 0 km/h (voir VehicleWriteGate).
-    private const val PROP_VEHICLE_SPEED = 0x11600207
-
-    // Standard AAOS — VehicleProperty.ENV_OUTSIDE_TEMPERATURE (float, °C).
-    // NON VÉRIFIÉE sur véhicule : tous les firmwares MG4 n'exposent pas cette propriété.
-    // Les appelants doivent traiter null comme « donnée indisponible », pas comme 0 °C.
-    private const val PROP_OUTSIDE_TEMP = 0x11600703
-
-    /** Valeurs de IGNITION_STATE (VehicleIgnitionState) — propriété AAOS standard. */
-    object IgnitionState {
-        const val UNDEFINED = 0
-        const val LOCK      = 1
-        const val OFF       = 2
-        const val ACC       = 3
-        const val ON        = 4   // Clé détectée + frein appuyé = état READY
-        const val START     = 5
-    }
-
-    /**
-     * Valeurs retournées par IVehicleConditionService.getVehicleIgnition() (Katman5).
-     * Source : VehicleConditionConst.smali + CarIgnitionItem.smali (SWI133 launcher).
-     */
-    object CarIgnitionItem {
-        const val OFF       = 0x0   // Voiture éteinte
-        const val ACCESSORY = 0x1   // Accessoires uniquement
-        const val RUN       = 0x2   // Clé ON / état READY
-        const val CRANK     = 0x3   // Démarrage
-    }
-
-    /**
-     * Limiteur de vitesse (Speed Assist System / SAS) — réglage INDÉPENDANT du mode ACC/TJA.
-     * Sur SWI132 il est piloté par setSasMode (et NON par setAccTjaState/SHWA, qui ne l'active pas).
-     * Valeurs confirmées dans le smali SWI132 (SasModel / sas_modes) :
-     *   0 = Désactivé, 2 = Manuel, 3 = Intelligent  (1 = avert. vitesse, modèles TW uniquement)
-     */
-    object SasMode {
-        const val OFF         = 0
-        const val MANUEL      = 2
-        const val INTELLIGENT = 3
-    }
-
-    /** Valeurs de mode ADAS pour firmware SWI68/SWI132 (CarAccTja constants). */
-    object Swi68Mode {
-        const val OFF  = 0x4   // Désactiver
-        const val SHWA = 0x3   // Speed Limit Mode (Limiteur) — SWI132 uniquement
-        const val ACC  = 0x1   // ACC
-        const val TJA  = 0x2   // TJA (Traffic Jam Assist) = ICA dans l'UI SWI132
-    }
-
-    /** Valeurs du mode AEB (communes SWI133 + SWI68). */
-    object AebMode {
-        const val ALARM       = 1   // Alerte seule (FCW)
-        const val ALARM_BRAKE = 2   // Alerte + Freinage automatique d'urgence
-    }
-
-    /** Valeurs de sensibilité AEB — SWI133 uniquement (PROP_AEB_SENSITIVITY = 0x302000e). */
-    object AebSensitivity {
-        const val LOW      = 1   // Faible
-        const val STANDARD = 2   // Standard
-        const val HIGH     = 3   // Élevé
-    }
-
-    @Volatile private var sAppContext: Context? = null
-    @Volatile private var sCar: Any? = null
-    @Volatile private var sCarPropertyManager: Any? = null
-    @Volatile private var sCarHvacManager: Any? = null
-    @Volatile private var sVehicleBinder: IBinder? = null
-    @Volatile private var sVpm: Any? = null          // VehiclePropertyManager instance (SWI133, Katman4)
-    @Volatile private var sVpmService: Any? = null   // mIVehiclePropertyService field value (SWI133)
-    @Volatile private var sVsm: Any? = null          // VehicleSettingManager instance (SWI68, Katman4)
-    @Volatile private var sVsmService: Any? = null   // mVehicleSettingService field value (SWI68)
-    @Volatile private var sVsm133: Any? = null       // VehicleSettingManager instance (SWI133, pour ELK)
-    @Volatile private var sGeneral: Any? = null      // GeneralManager instance (SWI133/68/165, luminosité)
-    @Volatile private var sSmartSound: Any? = null   // SmartSoundManager instance (SWI133/68/165, loudness)
-    @Volatile private var sCarGeneral: Any? = null   // CarGeneralClient instance (A9 SWI132/131/69, luminosité)
-    @Volatile private var sInitialized = false
-    @Volatile private var sCarBindAttempted = false
-    @Volatile var logEnabled = true
-
-    @Volatile private var sDriveModeListener: DriveModeListener? = null
-    @Volatile private var sHvacListener: HvacListener? = null
-
-    // ── Katman5 — IGNITION_STATE via CarPropertyManager (standard AAOS) ──────
-    @Volatile private var sIgnitionCallbackProxy: Any? = null
-    @Volatile private var sIgnitionCallbackRegistered = false
-    private val ignitionCallbacks = java.util.concurrent.CopyOnWriteArrayList<(Int) -> Unit>()
-
-    // ── Katman5 — VehicleConditionManager / ICarGeneralService ───────────────
-    @Volatile private var sVcm: Any? = null
-    @Volatile private var sVcmListener: Any? = null
-    @Volatile private var sVcmCallbackRegistered = false
-    @Volatile private var sLastVcmIgnitionState = -1   // filtre les faux RUN répétés
-    private val vehicleConditionCallbacks = java.util.concurrent.CopyOnWriteArrayList<(Int) -> Unit>()
-    private val katman5ReadyListeners     = java.util.concurrent.CopyOnWriteArrayList<() -> Unit>()
-
-    /** Listeners notifiés dès que Katman1 (CPM + HVAC) est opérationnel. */
-    private val katman1ReadyListeners = java.util.concurrent.CopyOnWriteArrayList<() -> Unit>()
-
-    /** Listeners notifiés dès que Katman4 (mIVehiclePropertyService) est opérationnel. */
-    private val katman4ReadyListeners = java.util.concurrent.CopyOnWriteArrayList<() -> Unit>()
-
-    /**
-     * Exécute [action] dès que CarPropertyManager et CarHvacManager sont disponibles.
-     * Si déjà prêt, exécution immédiate. Sinon, mis en file et déclenché à la connexion.
-     */
-    fun whenKatman1Ready(action: () -> Unit) {
-        if (sCarPropertyManager != null && sCarHvacManager != null) {
-            action()
-        } else {
-            katman1ReadyListeners.add(action)
-        }
-    }
-
-    /**
-     * Exécute [action] dès que le service ADAS (Katman4) est disponible.
-     * SWI133 → mIVehiclePropertyService ; SWI68/SWI69/SWI131 → mVehicleSettingService
-     */
-    fun whenKatman4Ready(action: () -> Unit) {
-        val ready = if (FirmwareInfo.isVsmBased()) sVsmService != null else sVpmService != null
-        if (ready) action() else katman4ReadyListeners.add(action)
-    }
-
-    /** Exécute [action] dès que Katman5 (IVehicleConditionService) est opérationnel. */
-    fun whenKatman5Ready(action: () -> Unit) {
-        if (sVcmCallbackRegistered) action() else katman5ReadyListeners.add(action)
-    }
-
-    /** Enregistre un callback invoqué à chaque changement d'état d'allumage (CarIgnitionItem). */
-    fun registerVehicleConditionListener(callback: (Int) -> Unit) {
-        vehicleConditionCallbacks.add(callback)
-    }
-
-    fun unregisterVehicleConditionListener(callback: (Int) -> Unit) {
-        vehicleConditionCallbacks.remove(callback)
-    }
-
-    /** Enregistre un callback sur IGNITION_STATE via CarPropertyManager (standard AAOS). */
-    fun registerIgnitionCallback(callback: (Int) -> Unit) {
-        ignitionCallbacks.add(callback)
-        if (sCarPropertyManager != null) registerIgnitionPropertyCallback()
-    }
-
-    fun unregisterIgnitionCallback(callback: (Int) -> Unit) {
-        ignitionCallbacks.remove(callback)
-    }
-
-    /** Désenregistre le proxy CarPropertyManager (appeler depuis Service.onDestroy). */
-    fun unregisterIgnitionPropertyCallback() {
-        val cpm = sCarPropertyManager ?: return
-        val proxy = sIgnitionCallbackProxy ?: return
-        try {
-            val m = cpm.javaClass.methods.firstOrNull {
-                it.name == "unregisterCallback" && it.parameterCount == 1
-            } ?: return
-            m.invoke(cpm, proxy)
-            sIgnitionCallbackProxy = null
-            sIgnitionCallbackRegistered = false
-            AppLogger.i(TAG, "  IGNITION_STATE callback unregistered ✓")
-        } catch (e: Exception) {
-            AppLogger.d(TAG, "  IGNITION: unregisterCallback error: ${e.message}")
-        }
-    }
-
-    /**
-     * Lit l'état d'allumage courant via CarPropertyManager.
-     * Retourne -1 si CPM non prêt, 0 si propriété non supportée.
-     */
-    fun getCurrentIgnitionState(): Int {
-        val v0 = getIntPropertyCPM(PROP_IGNITION_STATE, 0)
-        if (v0 > 0) return v0
-        return getIntPropertyCPM(PROP_IGNITION_STATE, AREA_GLOBAL)
-    }
-
-    /**
-     * Vitesse véhicule en km/h, ou null si elle ne peut pas être lue (CPM non prêt,
-     * propriété non supportée, exception). [VehicleWriteGate] traite null comme un refus.
-     */
-    fun getVehicleSpeedKmh(): Float? {
-        val mps = getFloatPropertyCPM(PROP_VEHICLE_SPEED, AREA_GLOBAL)
-            ?: getFloatPropertyCPM(PROP_VEHICLE_SPEED, 0)
-            ?: return null
-        // PERF_VEHICLE_SPEED est signée (négative en marche arrière) : c'est la vitesse
-        // absolue qui compte pour savoir si le véhicule bouge.
-        return kotlin.math.abs(mps) * 3.6f
-    }
-
-    /**
-     * Température extérieure en °C, ou null si illisible (CPM non prêt, propriété non
-     * supportée par le firmware, exception).
-     *
-     * Le null est significatif : il veut dire « on ne sait pas », pas « il fait 0 °C ».
-     * Une règle météo qui reçoit null ne doit PAS se déclencher.
-     */
-    fun getOutsideTempCelsius(): Float? =
-        getFloatPropertyCPM(PROP_OUTSIDE_TEMP, AREA_GLOBAL)
-            ?: getFloatPropertyCPM(PROP_OUTSIDE_TEMP, 0)
-
-    // -------------------------------------------------------------------------
-    // Climate + windows — READ ONLY, UNVERIFIED on MG4 firmware.
-    //
-    // Standard AOSP VehicleProperty IDs. The R69 OEM sources expose these names, but the
-    // numeric ids and area ids are not confirmed against any MG4 generation. These reads
-    // exist so the MG4Tasker diagnostic screen can show whether a signal is actually
-    // readable BEFORE any write path is added. Every method returns null when unreadable —
-    // callers must treat null as "unknown", never as a value. No write counterpart exists
-    // on purpose: writing a wrong id to the vehicle is exactly the risk being deferred.
-    // -------------------------------------------------------------------------
-
-    private const val PROP_HVAC_AC_ON          = 0x15200505  // HVAC_AC_ON (bool)
-    private const val PROP_HVAC_AUTO_ON        = 0x1520050A  // HVAC_AUTO_ON (bool)
-    private const val PROP_HVAC_RECIRC_ON      = 0x15200508  // HVAC_RECIRC_ON (bool)
-    private const val PROP_HVAC_FAN_SPEED      = 0x15400500  // HVAC_FAN_SPEED (int)
-    private const val PROP_HVAC_TEMPERATURE_SET = 0x15600503 // HVAC_TEMPERATURE_SET (float °C)
-    private const val PROP_WINDOW_POS          = 0x13340BC0  // WINDOW_POS (int, per window area)
-
-    // Candidate HVAC area ids: the seat-heat area used elsewhere, plus GLOBAL and 0.
-    private val HVAC_AREA_CANDIDATES = intArrayOf(AREA_HVAC, AREA_GLOBAL, 0)
-    // VehicleAreaWindow bits: front windshield + the four door windows.
-    private val WINDOW_AREA_CANDIDATES = intArrayOf(0x0001, 0x0010, 0x0040, 0x0100, 0x0400)
-
-    fun getAcOn(): Boolean?          = readHvacBool(PROP_HVAC_AC_ON)
-    fun getHvacAutoOn(): Boolean?    = readHvacBool(PROP_HVAC_AUTO_ON)
-    fun getRecircOn(): Boolean?      = readHvacBool(PROP_HVAC_RECIRC_ON)
-    fun getFanSpeed(): Int?          = readHvacInt(PROP_HVAC_FAN_SPEED)
-    fun getTemperatureSetCelsius(): Float? = readHvacFloat(PROP_HVAC_TEMPERATURE_SET)
-
-    /** True if any door/windshield window reads as not fully closed; null if none readable. */
-    fun isAnyWindowOpen(): Boolean? {
-        var readAny = false
-        for (area in WINDOW_AREA_CANDIDATES) {
-            val pos = readWindowArea(area) ?: continue
-            readAny = true
-            if (pos > 0) return true
-        }
-        return if (readAny) false else null
-    }
-
-    private fun readHvacBool(propId: Int): Boolean? = readHvacInt(propId)?.let { it != 0 }
-
-    /** Sweeps HVAC-manager then CPM across the candidate areas; null when nothing answers. */
-    private fun readHvacInt(propId: Int): Int? {
-        for (area in HVAC_AREA_CANDIDATES) {
-            getIntPropertyHvac(propId, area).takeIf { it >= 0 }?.let { return it }
-            getIntPropertyCPM(propId, area).takeIf { it >= 0 }?.let { return it }
-        }
-        return null
-    }
-
-    private fun readHvacFloat(propId: Int): Float? {
-        val hvac = sCarHvacManager
-        for (area in HVAC_AREA_CANDIDATES) {
-            if (hvac != null) {
-                runCatching {
-                    hvac.javaClass.getMethod("getFloatProperty", Int::class.java, Int::class.java)
-                        .invoke(hvac, propId, area) as? Float
-                }.getOrNull()?.let { return it }
-            }
-            getFloatPropertyCPM(propId, area)?.let { return it }
-        }
-        return null
-    }
-
-    private fun readWindowArea(area: Int): Int? =
-        getIntPropertyCPM(PROP_WINDOW_POS, area).takeIf { it >= 0 }
-
-    /** Contexte applicatif, pour les messages utilisateur du verrou d'écriture. */
-    internal fun appContext(): Context? = sAppContext
-
-    interface DriveModeListener { fun onDriveModeChanged(mode: DriveMode) }
-    interface HvacListener {
-        fun onSeatHeatChanged(left: Int, right: Int)
-        fun onSteeringHeatChanged(on: Boolean)
-    }
-
-    // -------------------------------------------------------------------------
-    // Init
-    // -------------------------------------------------------------------------
-
-    fun init(context: Context) {
-        if (sInitialized) return
-        sInitialized = true
-        sAppContext = context.applicationContext
-        AppLogger.i(TAG, "=== MG4Hardware.init() === uid=${android.os.Process.myUid()} sdk=${android.os.Build.VERSION.SDK_INT} device=${android.os.Build.DEVICE}")
-        bindCarService(context)
-        sVehicleBinder = getBinderService("vehiclesetting")
-        when {
-            FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI68  -> initKatman4Swi68(context)
-            FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI165 -> initKatman4Swi68(context)  // même SDK que SWI68
-            FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132 -> initKatman4Swi69(context)  // CarVehicleSettingClient, même path que SWI69
-            FirmwareInfo.isNewGenVsm()                              -> initKatman4Swi69(context)   // SWI69 + SWI131
-            else                                                    -> initKatman4(context)
-        }
-        // Katman5 — détection IGNITION_STATE push (VehicleConditionManager ou ICarGeneralService)
-        // SWI132 utilise ICarGeneralService (même path que SWI69/SWI131) — VehicleConditionManager absent de son smali
-        if (FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132)
-            initKatman5Swi69(context)
-        else
-            initKatman5(context)
-        if (sVehicleBinder != null)
-            AppLogger.i(TAG, "  ✓ Katman2: vehiclesetting binder OK")
-        else
-            AppLogger.w(TAG, "  ✗ Katman2: vehiclesetting null (SELinux — expected)")
-
-        // Démarrage auto du watcher porte au boot si la feature est activée (tous firmwares).
-        startDoorWatcherIfEnabled()
-        // Connexion Car établie même si la feature est OFF → la sonde Diagnostic peut lire les portes.
-        if (hasDoorVolumeFeature()) connectCarProperty()
-
-        AppLogger.i(TAG, "========================================")
-    }
-
-    // -------------------------------------------------------------------------
-    // Katman1 — android.car.Car (async, mirrors original bindCarService exactly)
-    // -------------------------------------------------------------------------
-
-    private fun bindCarService(context: Context) {
-        if (sCarBindAttempted) return
-        sCarBindAttempted = true
-        val carClass: Class<*>
-        try {
-            carClass = Class.forName("android.car.Car")
-            AppLogger.i(TAG, "  Katman1: android.car.Car class found ✓")
-        } catch (e: ClassNotFoundException) {
-            AppLogger.w(TAG, "  Katman1: android.car.Car not found — not Automotive?")
-            return
-        } catch (e: Exception) {
-            AppLogger.e(TAG, "  Katman1: forName error: ${e.message}")
-            return
-        }
-
-        var car: Any? = null
-
-        // Attempt 1: createCar(Context)
-        try {
-            car = carClass.getMethod("createCar", Context::class.java).invoke(null, context)
-            if (car != null) AppLogger.i(TAG, "  Katman1: createCar(Context) → success")
-        } catch (_: Exception) {}
-
-        // Attempt 2: createCar(Context, Handler)
-        if (car == null) {
-            try {
-                car = carClass.getMethod("createCar", Context::class.java, Handler::class.java)
-                    .invoke(null, context, null)
-                if (car != null) AppLogger.i(TAG, "  Katman1: createCar(Context, Handler) → success")
-            } catch (_: Exception) {}
-        }
-
-        // Attempt 3: createCar(Context, ServiceConnection) — async, callback fires when connected
-        var scMethodFound: java.lang.reflect.Method? = null
-        try {
-            scMethodFound = carClass.getMethod("createCar", Context::class.java, ServiceConnection::class.java)
-            AppLogger.i(TAG, "  Katman1: createCar(Context, ServiceConnection) method found")
-        } catch (_: Exception) {}
-
-        if (car == null && scMethodFound != null) {
-            try {
-                val sc = object : ServiceConnection {
-                    override fun onServiceConnected(name: ComponentName?, binder: IBinder?) {
-                        AppLogger.i(TAG, "  Katman1: ServiceConnection.onServiceConnected")
-                        tryGetManagersFromCar(carClass)
-                    }
-                    override fun onServiceDisconnected(name: ComponentName?) {
-                        AppLogger.w(TAG, "  Katman1: Car service disconnected")
-                        sCarPropertyManager = null
-                        sCarHvacManager = null
-                    }
-                }
-                car = scMethodFound.invoke(null, context, sc)
-                if (car != null) AppLogger.i(TAG, "  Katman1: createCar(Context, SC) → callback pending")
-            } catch (e: Exception) {
-                AppLogger.w(TAG, "  Katman1: createCar(Context, SC) error: ${e.message}")
-            }
-        }
-
-        if (car == null) {
-            AppLogger.e(TAG, "  Katman1: all createCar methods failed")
-            return
-        }
-
-        sCar = car
-
-        // Call car.connect() if available (required on older builds)
-        try {
-            carClass.getMethod("connect").invoke(car)
-            AppLogger.i(TAG, "  Katman1: car.connect() called")
-        } catch (_: NoSuchMethodException) {
-            // connect() not present on all builds, ignore
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  Katman1: car.connect() error: ${e.message}")
-        }
-
-        // Try sync managers immediately
-        tryGetManagersFromCar(carClass)
-
-        // Schedule retries — délais étendus pour couvrir le boot lent du Car service SAIC
-        val h = Handler(Looper.getMainLooper())
-        h.postDelayed({ tryGetManagersFromCar(carClass) }, 2_000)
-        h.postDelayed({ tryGetManagersFromCar(carClass) }, 5_000)
-        h.postDelayed({ tryGetManagersFromCar(carClass) }, 10_000)
-        h.postDelayed({ tryGetManagersFromCar(carClass) }, 20_000)
-        h.postDelayed({ tryGetManagersFromCar(carClass) }, 40_000)
-        h.postDelayed({ tryGetManagersFromCar(carClass) }, 60_000)
-    }
-
-    private fun tryGetManagersFromCar(carClass: Class<*>) {
-        val car = sCar ?: return
-        if (sCarPropertyManager != null && sCarHvacManager != null) return // already done
-        try {
-            val connected = try {
-                (carClass.getMethod("isConnected").invoke(car) as? Boolean) ?: true
-            } catch (_: Exception) { true }
-
-            AppLogger.i(TAG, "  Katman1: isConnected() → $connected")
-            if (!connected) {
-                AppLogger.w(TAG, "  Katman1: car not yet connected")
-                return
-            }
-
-            val getCarManager = carClass.getMethod("getCarManager", String::class.java)
-
-            if (sCarPropertyManager == null) {
-                try {
-                    val svc = carClass.getField("PROPERTY_SERVICE").get(null) as String
-                    sCarPropertyManager = getCarManager.invoke(car, svc)
-                    AppLogger.i(TAG, "  Katman1: CarPropertyManager READY ✓")
-                } catch (e: Exception) {
-                    AppLogger.w(TAG, "  Katman1: CarPropertyManager unavailable: ${e.message}")
-                }
-            }
-
-            if (sCarHvacManager == null) {
-                try {
-                    val svc = carClass.getField("HVAC_SERVICE").get(null) as String
-                    sCarHvacManager = getCarManager.invoke(car, svc)
-                    AppLogger.i(TAG, "  Katman1: CarHvacManager READY ✓")
-                } catch (e: Exception) {
-                    AppLogger.w(TAG, "  Katman1: CarHvacManager unavailable: ${e.message}")
-                }
-            }
-
-            // Notifier les abonnés whenKatman1Ready dès que les deux managers sont prêts
-            if (sCarPropertyManager != null && sCarHvacManager != null && katman1ReadyListeners.isNotEmpty()) {
-                val toNotify = katman1ReadyListeners.toList()
-                katman1ReadyListeners.clear()
-                Handler(Looper.getMainLooper()).post { toNotify.forEach { it() } }
-            }
-
-            // Tentative d'enregistrement du callback IGNITION_STATE (best-effort)
-            if (sCarPropertyManager != null) registerIgnitionPropertyCallback()
-        } catch (e: Exception) {
-            AppLogger.e(TAG, "  Katman1: tryGetManagersFromCar error: ${e.message}")
-        }
-    }
-
-    // -------------------------------------------------------------------------
-    // Katman2 — ServiceManager raw binder
-    // -------------------------------------------------------------------------
-
-    private fun getBinderService(serviceName: String): IBinder? {
-        return try {
-            val sm = Class.forName("android.os.ServiceManager")
-            val method = sm.getMethod("getService", String::class.java)
-            (method.invoke(null, serviceName) as? IBinder).also {
-                AppLogger.d(TAG, "getService($serviceName) → $it")
-            }
-        } catch (e: Exception) {
-            AppLogger.e(TAG, "getService($serviceName) error: ${e.message}")
-            null
-        }
-    }
-
-    // -------------------------------------------------------------------------
-    // Katman4 — VehiclePropertyManager via saicmotor.hmi.launcher context
-    // -------------------------------------------------------------------------
-
-    private fun initKatman4(context: Context) {
-        if (sVpm != null) return
-        val launcherCtx: Context
-        val vpmClass: Class<*>
-        try {
-            launcherCtx = context.createPackageContext(
-                LAUNCHER68_PKG,
-                android.content.Context.CONTEXT_INCLUDE_CODE or android.content.Context.CONTEXT_IGNORE_SECURITY
-            )
-            vpmClass = launcherCtx.classLoader
-                .loadClass("com.saicmotor.sdk.vehiclesettings.manager.VehiclePropertyManager")
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  Katman4: package/class error: ${e.message} — will retry")
-            Handler(Looper.getMainLooper()).postDelayed({ initKatman4(context.applicationContext) }, 5_000)
-            return
-        }
-
-        var vpm: Any? = null
-
-        // ---- Constructeurs (priorité) ----
-        // 1) ctor(launcherCtx) — most likely for a class bundled in the launcher APK
-        if (vpm == null) vpm = tryInvoke("ctor(launcherCtx)") {
-            vpmClass.getConstructor(Context::class.java).newInstance(launcherCtx)
-        }
-        // 2) ctor(appCtx)
-        if (vpm == null) vpm = tryInvoke("ctor(appCtx)") {
-            vpmClass.getConstructor(Context::class.java).newInstance(context)
-        }
-        // 3) ctor() no-arg
-        if (vpm == null) vpm = tryInvoke("ctor()") {
-            @Suppress("DEPRECATION") vpmClass.newInstance()
-        }
-
-        // ---- Méthodes statiques de factory ----
-        if (vpm == null) vpm = tryInvoke("getInstance(launcherCtx)") {
-            vpmClass.getMethod("getInstance", Context::class.java).invoke(null, launcherCtx)
-        }
-        if (vpm == null) vpm = tryInvoke("getInstance(appCtx)") {
-            vpmClass.getMethod("getInstance", Context::class.java).invoke(null, context)
-        }
-        if (vpm == null) vpm = tryInvoke("getInstance()") {
-            vpmClass.getMethod("getInstance").invoke(null)
-        }
-
-        if (vpm == null) {
-            AppLogger.w(TAG, "  Katman4: toutes les tentatives ont échoué — will retry")
-            Handler(Looper.getMainLooper()).postDelayed({ initKatman4(context.applicationContext) }, 10_000)
-            return
-        }
-
-        sVpm = vpm
-
-        // 1) bindService() — connecte au service véhicule (async)
-        tryInvoke("vpm.bindService()") { vpm!!.javaClass.getMethod("bindService").invoke(vpm) }
-
-        // 2) init(Context, IVehicleServiceListener) via dynamic proxy — reçoit onServiceConnected
-        initWithServiceListener(vpm!!, context, launcherCtx)
-
-        // 3) VehicleSettingManager pour SWI133 (ELK) — même singleton que SWI68
-        tryInitVsm133(launcherCtx, context)
-
-        // 3b) GeneralManager pour SWI133 (luminosité écran)
-        tryInitGeneralManager(launcherCtx, context)
-
-        // 3c) SmartSoundManager pour SWI133 (loudness audio)
-        tryInitSmartSoundManager(launcherCtx, context)
-
-        // 4) Retries pour récupérer mIVehiclePropertyService et VSM133 une fois le service connecté
-        val h = Handler(Looper.getMainLooper())
-        listOf(2_000L, 5_000L, 10_000L, 15_000L, 20_000L, 30_000L, 45_000L, 60_000L).forEach { delay ->
-            h.postDelayed({
-                if (sVpmService == null) tryGetVpmService(sVpm ?: return@postDelayed)
-                if (sVsm133 == null) tryInitVsm133(launcherCtx, context)
-                if (sGeneral == null) tryInitGeneralManager(launcherCtx, context)
-                if (sSmartSound == null) tryInitSmartSoundManager(launcherCtx, context)
-                if (doorVolumeEnabled() && sCarPropMgr == null) startDoorVolumeWatcher()
-            }, delay)
-        }
-
-        tryGetVpmService(vpm!!)
-        AppLogger.i(TAG, "  Katman4: VPM prêt — mIVehiclePropertyService=${if (sVpmService != null) "OK ✓" else "null (en attente)"}")
-    }
-
-    private fun initWithServiceListener(vpm: Any, context: Context, launcherCtx: Context) {
-        val vpmClass = vpm.javaClass
-
-        // Log all methods for diagnostics
-        val methodSummary = vpmClass.methods.joinToString(", ") { m ->
-            "${m.name}(${m.parameterTypes.joinToString(",") { it.simpleName }})"
-        }
-        AppLogger.d(TAG, "  Katman4: VPM methods = $methodSummary")
-
-        // Strategy 1: Inspect the actual init() signature to get the real listener type
-        val initMethod2 = vpmClass.methods.firstOrNull { m ->
-            m.name == "init" && m.parameterCount == 2 &&
-            Context::class.java.isAssignableFrom(m.parameterTypes[0])
-        }
-
-        if (initMethod2 != null) {
-            val listenerType = initMethod2.parameterTypes[1]
-            AppLogger.i(TAG, "  Katman4: init() trouvé, listener type = ${listenerType.name}")
-
-            // Try dynamic proxy with the actual listener interface type
-            if (listenerType.isInterface) {
-                try {
-                    val proxy = java.lang.reflect.Proxy.newProxyInstance(
-                        listenerType.classLoader, arrayOf(listenerType)
-                    ) { _, method, _ ->
-                        when (method.name) {
-                            "onServiceConnected" -> {
-                                AppLogger.i(TAG, "  Katman4: onServiceConnected ✓")
-                                tryGetVpmService(vpm)
-                            }
-                            "onServiceDisconnected" -> {
-                                AppLogger.w(TAG, "  Katman4: onServiceDisconnected")
-                                sVpmService = null
-                            }
-                            else -> {}
-                        }
-                        null
-                    }
-                    initMethod2.invoke(vpm, context, proxy)
-                    AppLogger.i(TAG, "  Katman4: init(Context, proxy) ✓")
-                    return
-                } catch (e: Exception) {
-                    AppLogger.d(TAG, "  Katman4: init(Context, proxy) failed: ${e.message}")
-                }
-            }
-
-            // Fallback: try init(Context, null) — works if listener is nullable
-            try {
-                initMethod2.invoke(vpm, context, null)
-                AppLogger.i(TAG, "  Katman4: init(Context, null) ✓")
-                return
-            } catch (e: Exception) {
-                AppLogger.d(TAG, "  Katman4: init(Context, null) failed: ${e.message}")
-            }
-        }
-
-        // Strategy 2: init(Context) single-param
-        try {
-            vpmClass.getMethod("init", Context::class.java).invoke(vpm, context)
-            AppLogger.i(TAG, "  Katman4: init(Context) ✓")
-            return
-        } catch (_: NoSuchMethodException) {
-        } catch (e: Exception) {
-            AppLogger.d(TAG, "  Katman4: init(Context) failed: ${e.message}")
-        }
-
-        // Strategy 3: init() no-arg
-        try {
-            vpmClass.getMethod("init").invoke(vpm)
-            AppLogger.i(TAG, "  Katman4: init() ✓")
-            return
-        } catch (_: NoSuchMethodException) {
-        } catch (e: Exception) {
-            AppLogger.d(TAG, "  Katman4: init() failed: ${e.message}")
-        }
-
-        AppLogger.w(TAG, "  Katman4: aucun init() fonctionnel — mIVehiclePropertyService restera null")
-    }
-
-    /** Exécute [block], retourne le résultat ou null, log le résultat/erreur. */
-    private fun tryInvoke(label: String, block: () -> Any?): Any? = try {
-        val r = block()
-        AppLogger.i(TAG, "  Katman4: $label → ${if (r != null) "OK ($r)" else "null"}")
-        r
-    } catch (e: Exception) {
-        AppLogger.d(TAG, "  Katman4: $label → ${e.javaClass.simpleName}: ${e.message}")
-        null
-    }
-
-    private fun tryGetVpmService(vpm: Any) {
-        if (sVpmService != null) return
-        for (cls in generateSequence<Class<*>>(vpm.javaClass) { it.superclass }) {
-            try {
-                val f = cls.getDeclaredField("mIVehiclePropertyService")
-                f.isAccessible = true
-                val svc = f.get(vpm)
-                if (svc != null) {
-                    sVpmService = svc
-                    AppLogger.i(TAG, "  Katman4: mIVehiclePropertyService READY ✓")
-                    // Notify any pending Katman4 listeners
-                    val toNotify = katman4ReadyListeners.toList()
-                    katman4ReadyListeners.clear()
-                    Handler(Looper.getMainLooper()).post { toNotify.forEach { it() } }
-                }
-                return
-            } catch (_: NoSuchFieldException) { continue } catch (_: Exception) { return }
-        }
-    }
-
-    // -------------------------------------------------------------------------
-    // -------------------------------------------------------------------------
-    // SWI133 — VehicleSettingManager (ELK : getLaneKeepingAsstMode / setLaneKeepingAsstMode)
-    // Même singleton que SWI68 mais initialisé dans le chemin SWI133.
-    // -------------------------------------------------------------------------
-
-    private fun tryInitVsm133(launcherCtx: Context, appCtx: Context) {
-        if (sVsm133 != null) return
-        try {
-            val vsmClass = launcherCtx.classLoader.loadClass(VSM_CLASS)
-
-            // Tentative 1 : lire le singleton déjà initialisé par le launcher
-            val f = vsmClass.getDeclaredField("sVehicleSettingManager")
-            f.isAccessible = true
-            val singleton = f.get(null)
-            if (singleton != null) {
-                sVsm133 = singleton
-                AppLogger.i(TAG, "  SWI133: VehicleSettingManager singleton ✓")
-                return
-            }
-
-            // Tentative 2 : appeler init() nous-mêmes (comme SWI68)
-            val initMethod = vsmClass.methods.firstOrNull { m ->
-                m.name == "init" && m.parameterCount == 2 &&
-                Context::class.java.isAssignableFrom(m.parameterTypes[0])
-            } ?: run {
-                AppLogger.w(TAG, "  SWI133: VSM init() non trouvé, singleton sera null")
-                return
-            }
-            val listenerType = initMethod.parameterTypes[1]
-            val listener = if (listenerType.isInterface) {
-                java.lang.reflect.Proxy.newProxyInstance(listenerType.classLoader, arrayOf(listenerType)) { _, method, _ ->
-                    if (method.name == "onServiceConnected") {
-                        AppLogger.i(TAG, "  SWI133: VSM onServiceConnected ✓")
-                        try {
-                            val f2 = vsmClass.getDeclaredField("sVehicleSettingManager")
-                            f2.isAccessible = true
-                            sVsm133 = f2.get(null)
-                            AppLogger.i(TAG, "  SWI133: sVsm133 = ${if (sVsm133 != null) "OK ✓" else "null"}")
-                        } catch (_: Exception) {}
-                    }
-                    null
-                }
-            } else null
-            initMethod.invoke(null, appCtx, listener)
-            AppLogger.i(TAG, "  SWI133: VehicleSettingManager.init() called")
-        } catch (e: Exception) {
-            AppLogger.d(TAG, "  SWI133: tryInitVsm133 exc: ${e.message}")
-        }
-    }
-
-    // -------------------------------------------------------------------------
-    // Luminosité écran — GeneralManager (ancien SDK SWI133/68/165)
-    // GeneralManager.init(Context, ISettingsServiceListener) — singleton sInstance.
-    // Même pattern que tryInitVsm133 ; chargé depuis le launcher com.saicmotor.hmi.launcher.
-    // -------------------------------------------------------------------------
-
-    private fun tryInitGeneralManager(launcherCtx: Context, appCtx: Context) {
-        if (sGeneral != null) return
-        try {
-            val cls = launcherCtx.classLoader.loadClass(GENERAL_MANAGER_CLASS)
-
-            // Tentative 1 : singleton déjà initialisé
-            val f = cls.getDeclaredField("sInstance")
-            f.isAccessible = true
-            f.get(null)?.let {
-                sGeneral = it
-                AppLogger.i(TAG, "  GeneralManager singleton ✓")
-                return
-            }
-
-            // Tentative 2 : init(Context, ISettingsServiceListener) — proxy dynamique
-            val initMethod = cls.methods.firstOrNull { m ->
-                m.name == "init" && m.parameterCount == 2 &&
-                Context::class.java.isAssignableFrom(m.parameterTypes[0])
-            } ?: run {
-                AppLogger.w(TAG, "  GeneralManager init() non trouvé")
-                return
-            }
-            val listenerType = initMethod.parameterTypes[1]
-            val listener = if (listenerType.isInterface) {
-                java.lang.reflect.Proxy.newProxyInstance(listenerType.classLoader, arrayOf(listenerType)) { _, method, _ ->
-                    if (method.name == "onServiceConnected") {
-                        try {
-                            f.get(null)?.let { sGeneral = it }
-                            AppLogger.i(TAG, "  GeneralManager onServiceConnected — sGeneral=${if (sGeneral != null) "OK ✓" else "null"}")
-                        } catch (_: Exception) {}
-                    }
-                    null
-                }
-            } else null
-            initMethod.invoke(null, appCtx, listener)
-            // init() crée sInstance immédiatement (service connecté de façon asynchrone ensuite)
-            f.get(null)?.let { sGeneral = it }
-            AppLogger.i(TAG, "  GeneralManager.init() called — sGeneral=${if (sGeneral != null) "OK ✓" else "null"}")
-        } catch (e: Exception) {
-            AppLogger.d(TAG, "  tryInitGeneralManager exc: ${e.message}")
-        }
-    }
-
-    // -------------------------------------------------------------------------
-    // Loudness — SmartSoundManager (ancien SDK SWI133/68/165)
-    // Même SDK/pattern que GeneralManager : singleton sInstance + init(Context, ISettingsServiceListener).
-    // -------------------------------------------------------------------------
-
-    private fun tryInitSmartSoundManager(launcherCtx: Context, appCtx: Context) {
-        if (sSmartSound != null) return
-        try {
-            val cls = launcherCtx.classLoader.loadClass(SMART_SOUND_MANAGER_CLASS)
-
-            // Tentative 1 : singleton déjà initialisé
-            val f = cls.getDeclaredField("sInstance")
-            f.isAccessible = true
-            f.get(null)?.let {
-                sSmartSound = it
-                AppLogger.i(TAG, "  SmartSoundManager singleton ✓")
-                return
-            }
-
-            // Tentative 2 : init(Context, ISettingsServiceListener) — proxy dynamique
-            val initMethod = cls.methods.firstOrNull { m ->
-                m.name == "init" && m.parameterCount == 2 &&
-                Context::class.java.isAssignableFrom(m.parameterTypes[0])
-            } ?: run {
-                AppLogger.w(TAG, "  SmartSoundManager init() non trouvé")
-                return
-            }
-            val listenerType = initMethod.parameterTypes[1]
-            val listener = if (listenerType.isInterface) {
-                java.lang.reflect.Proxy.newProxyInstance(listenerType.classLoader, arrayOf(listenerType)) { _, method, _ ->
-                    if (method.name == "onServiceConnected") {
-                        try {
-                            f.get(null)?.let { sSmartSound = it }
-                            AppLogger.i(TAG, "  SmartSoundManager onServiceConnected — sSmartSound=${if (sSmartSound != null) "OK ✓" else "null"}")
-                        } catch (_: Exception) {}
-                    }
-                    null
-                }
-            } else null
-            initMethod.invoke(null, appCtx, listener)
-            f.get(null)?.let { sSmartSound = it }
-            AppLogger.i(TAG, "  SmartSoundManager.init() called — sSmartSound=${if (sSmartSound != null) "OK ✓" else "null"}")
-        } catch (e: Exception) {
-            AppLogger.d(TAG, "  tryInitSmartSoundManager exc: ${e.message}")
-        }
-    }
-
-    /** A9 (SWI132/131/69) : luminosité via CarGeneralClient.setScreenBrightness(mode,day,night). */
-    private fun isA9Brightness(): Boolean =
-        FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132
-
-    /** Luminosité écran disponible : ancien SDK (133/68/165) ou A9 (132/131/69). */
-    fun hasBrightnessControl(): Boolean = FirmwareInfo.getGeneration() != FirmwareInfo.Gen.UNKNOWN
-
-    /** Lit la luminosité écran en % (0–100), ou -1 si indisponible. */
-    fun getScreenBrightnessPercent(): Int =
-        if (isA9Brightness()) getBrightnessA9() else getBrightnessOldSdk()
-
-    /**
-     * Règle la luminosité écran en % (0–100). Plancher de sécurité à BRIGHTNESS_MIN_PERCENT
-     * pour ne jamais éteindre l'écran.
-     */
-    fun setScreenBrightnessPercent(pct: Int): Boolean {
-        val clamped = pct.coerceIn(BRIGHTNESS_MIN_PERCENT, 100)
-        return if (isA9Brightness()) setBrightnessA9(clamped) else setBrightnessOldSdk(clamped)
-    }
-
-    // ── Ancien SDK (SWI133/68/165) — GeneralManager.setBrightness(Int), plage native 0..255 ──
-
-    private fun getBrightnessOldSdk(): Int {
-        val g = sGeneral ?: return -1
-        return try {
-            val native = (g.javaClass.getMethod("getBrightness").invoke(g) as? Int) ?: return -1
-            if (native < 0) return -1
-            val pct = (native * 100 / BRIGHTNESS_NATIVE_MAX).coerceIn(0, 100)
-            AppLogger.d(TAG, "  getBrightness native=$native → $pct%")
-            pct
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  getBrightness exc: ${e.message}")
-            -1
-        }
-    }
-
-    private fun setBrightnessOldSdk(clampedPct: Int): Boolean {
-        val g = sGeneral ?: return false
-        val native = (clampedPct * BRIGHTNESS_NATIVE_MAX / 100).coerceIn(0, BRIGHTNESS_NATIVE_MAX)
-        if (logEnabled) AppLogger.i(TAG, "setBrightness → $clampedPct% (native=$native/255)")
-        return try {
-            g.javaClass.getMethod("setBrightness", Int::class.javaPrimitiveType).invoke(g, native)
-            true
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  setBrightness exc: ${e.message}")
-            false
-        }
-    }
-
-    // ── A9 (SWI132/131/69) — luminosité via Settings.System.SCREEN_BRIGHTNESS ──
-    // L'app Settings A9 (GeneralModel.setBrightness) pilote réellement la dalle par
-    // Settings.System.putInt("screen_brightness", 0..255) + passage en mode manuel.
-    // CarGeneralClient.setScreenBrightness(mode,day,night) ne stocke que le jour/nuit
-    // et n'a AUCUN effet sur la dalle (confirmé par les logs SWI132 : valeur lue=0,
-    // aucun changement visuel). L'app étant uid.system, elle peut écrire Settings.System.
-    private const val A9_BRIGHTNESS_NATIVE_MAX = 255
-
-    private fun getBrightnessA9(): Int {
-        val resolver = sAppContext?.contentResolver ?: return -1
-        val native = try {
-            android.provider.Settings.System.getInt(resolver, android.provider.Settings.System.SCREEN_BRIGHTNESS)
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  A9 getBrightness Settings.System exc: ${e.message}"); return -1
-        }
-        if (native < 0) return -1
-        return (native * 100 / A9_BRIGHTNESS_NATIVE_MAX).coerceIn(0, 100)
-    }
-
-    private fun setBrightnessA9(clampedPct: Int): Boolean {
-        val resolver = sAppContext?.contentResolver ?: return false
-        val native = (clampedPct.coerceIn(0, 100) * A9_BRIGHTNESS_NATIVE_MAX / 100).coerceIn(1, A9_BRIGHTNESS_NATIVE_MAX)
-        return try {
-            // Mode manuel, sinon l'auto-luminosité écrase aussitôt la valeur
-            android.provider.Settings.System.putInt(resolver,
-                android.provider.Settings.System.SCREEN_BRIGHTNESS_MODE,
-                android.provider.Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL)
-            android.provider.Settings.System.putInt(resolver,
-                android.provider.Settings.System.SCREEN_BRIGHTNESS, native)
-            if (logEnabled) AppLogger.i(TAG, "A9 brightness → Settings.System.SCREEN_BRIGHTNESS=$native ($clampedPct%)")
-            true
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  A9 setBrightness Settings.System exc: ${e.message}")
-            false
-        }
-    }
-
-    /**
-     * Appelle une méthode sur sVsm133 par réflexion.
-     * Retourne la valeur (Int pour getters, null pour setters void) ou null si erreur.
-     */
-    private fun callVsm133(methodName: String, vararg args: Any?): Any? {
-        val vsm = sVsm133 ?: return null
-        return try {
-            val types = args.map { if (it is Int) Int::class.javaPrimitiveType!! else it!!.javaClass }.toTypedArray()
-            vsm.javaClass.getMethod(methodName, *types).invoke(vsm, *args)
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  SWI133/VSM: $methodName() exc: ${e.message}")
-            null
-        }
-    }
-
-    // Katman4 SWI68 — VehicleSettingManager via saicmotor.hmi.launcher context
-    // -------------------------------------------------------------------------
-
-    private fun initKatman4Swi68(context: Context) {
-        if (sVsm != null) return
-        val launcherCtx: Context
-        val vsmClass: Class<*>
-        try {
-            launcherCtx = context.createPackageContext(
-                LAUNCHER68_PKG,
-                android.content.Context.CONTEXT_INCLUDE_CODE or android.content.Context.CONTEXT_IGNORE_SECURITY
-            )
-            vsmClass = launcherCtx.classLoader.loadClass(VSM_CLASS)
-            AppLogger.i(TAG, "  SWI68: VehicleSettingManager class found ✓")
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  SWI68: class load error: ${e.message} — retry in 5s")
-            Handler(Looper.getMainLooper()).postDelayed({ initKatman4Swi68(context.applicationContext) }, 5_000)
-            return
-        }
-
-        // Appel static : VehicleSettingManager.init(Context, IVehicleServiceListener)
-        val initMethod = vsmClass.methods.firstOrNull { m ->
-            m.name == "init" && m.parameterCount == 2 &&
-            Context::class.java.isAssignableFrom(m.parameterTypes[0])
-        }
-
-        if (initMethod != null) {
-            val listenerType = initMethod.parameterTypes[1]
-            val listenerArg: Any? = if (listenerType.isInterface) {
-                try {
-                    java.lang.reflect.Proxy.newProxyInstance(
-                        listenerType.classLoader, arrayOf(listenerType)
-                    ) { _, method, _ ->
-                        if (method.name == "onServiceConnected") {
-                            AppLogger.i(TAG, "  SWI68: VehicleSettingManager onServiceConnected ✓")
-                            sVsm?.let { tryGetVsmService(it, vsmClass) }
-                        }
-                        null
-                    }
-                } catch (e: Exception) { null.also { AppLogger.d(TAG, "  SWI68: proxy error: ${e.message}") } }
-            } else null
-
-            try {
-                initMethod.invoke(null, context, listenerArg)
-                AppLogger.i(TAG, "  SWI68: VehicleSettingManager.init() called")
-            } catch (e: Exception) {
-                AppLogger.w(TAG, "  SWI68: init() error: ${e.message}")
-            }
-        } else {
-            AppLogger.w(TAG, "  SWI68: init(Context, listener) non trouvé")
-        }
-
-        // Récupère le singleton depuis le champ statique sVehicleSettingManager
-        try {
-            val f = vsmClass.getDeclaredField("sVehicleSettingManager")
-            f.isAccessible = true
-            sVsm = f.get(null)
-            AppLogger.i(TAG, "  SWI68: sVehicleSettingManager = ${if (sVsm != null) "OK ✓" else "null"}")
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  SWI68: sVehicleSettingManager field error: ${e.message}")
-        }
-
-        sVsm?.let { tryGetVsmService(it, vsmClass) }
-
-        // GeneralManager pour SWI68/SWI165 (luminosité écran) — même launcher context
-        tryInitGeneralManager(launcherCtx, context)
-
-        // SmartSoundManager pour SWI68/SWI165 (loudness audio) — même launcher context
-        tryInitSmartSoundManager(launcherCtx, context)
-
-        // Retries pour récupérer mVehicleSettingService et le singleton si pas encore prêt
-        val h = Handler(Looper.getMainLooper())
-        listOf(1_000L, 3_000L, 5_000L, 10_000L, 15_000L, 20_000L, 30_000L).forEach { delay ->
-            h.postDelayed({
-                if (sVsm == null) {
-                    try {
-                        val f = vsmClass.getDeclaredField("sVehicleSettingManager")
-                        f.isAccessible = true
-                        sVsm = f.get(null)
-                        if (sVsm != null) AppLogger.i(TAG, "  SWI68: singleton récupéré @${delay}ms")
-                    } catch (_: Exception) {}
-                }
-                sVsm?.let { if (sVsmService == null) tryGetVsmService(it, vsmClass) }
-                if (sGeneral == null) tryInitGeneralManager(launcherCtx, context)
-                if (sSmartSound == null) tryInitSmartSoundManager(launcherCtx, context)
-            }, delay)
-        }
-    }
-
-    private fun tryGetVsmService(vsm: Any, vsmClass: Class<*>? = null) {
-        if (sVsmService != null) return
-        val cls = vsmClass ?: vsm.javaClass
-        for (c in generateSequence<Class<*>>(cls) { it.superclass }) {
-            try {
-                val f = c.getDeclaredField("mVehicleSettingService")
-                f.isAccessible = true
-                val svc = f.get(vsm)
-                if (svc != null) {
-                    sVsmService = svc
-                    AppLogger.i(TAG, "  SWI68: mVehicleSettingService READY ✓")
-                    val toNotify = katman4ReadyListeners.toList()
-                    katman4ReadyListeners.clear()
-                    Handler(Looper.getMainLooper()).post { toNotify.forEach { it() } }
-                }
-                return
-            } catch (_: NoSuchFieldException) { continue } catch (_: Exception) { return }
-        }
-    }
-
-    // -------------------------------------------------------------------------
-    // Katman4 SWI69/SWI131 — CarVehicleSettingClient via CarAdapterClient
-    //
-    // Architecture réelle (vérifiée dans smali) :
-    //   CarAdapterClient.getInstance(ctx).start()
-    //   → bindService(com.saicmotor.caradapter / CarAdapterService)
-    //   → onResult(0=OK) : queryClient(0x8) → IBinder (ICarVehicleSettingService)
-    //   → new CarVehicleSettingClient(ibinder)
-    //
-    // CarVehicleSettingClient expose exactement les mêmes méthodes que VehicleSettingManager
-    // (getAccTjaState, setAccTjaState, getLasWarningSound, getFcwState, etc.)
-    // -------------------------------------------------------------------------
-
-    private fun initKatman4Swi69(context: Context) {
-        if (sVsm != null) return
-
-        val launcherCtx: Context
-        val adapterClass: Class<*>
-        val clientClass: Class<*>
-        try {
-            launcherCtx = context.createPackageContext(
-                LAUNCHER69_PKG,
-                android.content.Context.CONTEXT_INCLUDE_CODE or android.content.Context.CONTEXT_IGNORE_SECURITY
-            )
-            adapterClass = launcherCtx.classLoader.loadClass(CAR_ADAPTER_CLASS)
-            clientClass  = launcherCtx.classLoader.loadClass(VSM69_CLIENT_CLASS)
-            AppLogger.i(TAG, "  SWI69: CarAdapterClient + CarVehicleSettingClient classes found ✓")
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  SWI69: class load error: ${e.message} — retry in 5s")
-            Handler(Looper.getMainLooper()).postDelayed({ initKatman4Swi69(context.applicationContext) }, 5_000)
-            return
-        }
-
-        // Obtenir le singleton CarAdapterClient
-        val adapter = tryInvoke("SWI69 CarAdapterClient.getInstance(appCtx)") {
-            adapterClass.getMethod("getInstance", Context::class.java).invoke(null, context.applicationContext)
-        } ?: tryInvoke("SWI69 CarAdapterClient.getInstance(launcherCtx)") {
-            adapterClass.getMethod("getInstance", Context::class.java).invoke(null, launcherCtx)
-        }
-
-        if (adapter == null) {
-            AppLogger.w(TAG, "  SWI69: CarAdapterClient.getInstance() failed — retry in 10s")
-            Handler(Looper.getMainLooper()).postDelayed({ initKatman4Swi69(context.applicationContext) }, 10_000)
-            return
-        }
-
-        // Enregistrer le ServiceConnListener (onResult(0) = connecté)
-        val listenerType = adapterClass.declaredClasses
-            .firstOrNull { it.simpleName == "ServiceConnListener" }
-        if (listenerType != null && listenerType.isInterface) {
-            try {
-                val proxy = java.lang.reflect.Proxy.newProxyInstance(
-                    listenerType.classLoader, arrayOf(listenerType)
-                ) { _, method, args ->
-                    if (method.name == "onResult") {
-                        val code = (args?.getOrNull(0) as? Int) ?: -1
-                        AppLogger.i(TAG, "  SWI69: CarAdapterClient.onResult($code)")
-                        if (code == 0) tryInitClientFromAdapter(adapter, adapterClass, clientClass)
-                    }
-                    null
-                }
-                adapterClass.getMethod("setConnListener", listenerType).invoke(adapter, proxy)
-                AppLogger.i(TAG, "  SWI69: ServiceConnListener registered ✓")
-            } catch (e: Exception) {
-                AppLogger.w(TAG, "  SWI69: setConnListener error: ${e.message}")
-            }
-        }
-
-        // Démarrer la connexion à CarAdapterService
-        tryInvoke("SWI69 adapter.start()") {
-            adapterClass.getMethod("start").invoke(adapter)
-        }
-
-        // Tentative immédiate si CarAdapterService était déjà connecté
-        tryInitClientFromAdapter(adapter, adapterClass, clientClass)
-
-        // Retries échelonnés
-        val h = Handler(Looper.getMainLooper())
-        listOf(1_000L, 3_000L, 5_000L, 10_000L, 15_000L, 20_000L, 30_000L, 60_000L).forEach { delay ->
-            h.postDelayed({
-                if (sVsm == null) tryInitClientFromAdapter(adapter, adapterClass, clientClass)
-            }, delay)
-        }
-    }
-
-    /**
-     * Tente d'obtenir un CarVehicleSettingClient via queryClient(0x8).
-     * Appelée à la connexion (onResult=0) et lors des retries.
-     */
-    private fun tryInitClientFromAdapter(adapter: Any, adapterClass: Class<*>, clientClass: Class<*>) {
-        if (sVsm != null) return
-        try {
-            val ibinder = adapterClass
-                .getMethod("queryClient", Int::class.javaPrimitiveType!!)
-                .invoke(adapter, VSM_SERVICE_CODE) as? IBinder
-
-            if (ibinder == null) {
-                AppLogger.d(TAG, "  SWI69: queryClient(0x${VSM_SERVICE_CODE.toString(16)}) → null (pas encore connecté)")
-                return
-            }
-
-            val client = clientClass
-                .getConstructor(IBinder::class.java)
-                .newInstance(ibinder)
-
-            sVsm        = client
-            sVsmService = ibinder
-            AppLogger.i(TAG, "  SWI69: CarVehicleSettingClient READY ✓")
-
-            val toNotify = katman4ReadyListeners.toList()
-            katman4ReadyListeners.clear()
-            Handler(Looper.getMainLooper()).post { toNotify.forEach { it() } }
-        } catch (e: Exception) {
-            AppLogger.d(TAG, "  SWI69: tryInitClientFromAdapter error: ${e.message}")
-        }
-    }
-
-    private fun callVsm(methodName: String, vararg args: Any?): Any? {
-        val vsm = sVsm ?: return null
-        return try {
-            val types = args.map { if (it is Int) Int::class.javaPrimitiveType!! else it!!.javaClass }.toTypedArray()
-            vsm.javaClass.getMethod(methodName, *types).invoke(vsm, *args)
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  SWI68: $methodName() exc: ${e.message}")
-            null
-        }
-    }
-
-    /**
-     * Appelle une méthode void sur sVsm par réflexion.
-     * Contrairement à callVsm(), retourne true si la méthode existe et s'exécute sans exception,
-     * même si invoke() retourne null (comportement normal pour les méthodes void).
-     * Retourne false si sVsm est null ou si une exception est levée (méthode introuvable, etc.).
-     */
-    private fun callVsmVoid(methodName: String, vararg args: Any?): Boolean {
-        // [T-904] Écriture véhicule : autorisée uniquement à l'arrêt, refus si vitesse illisible.
-        if (!VehicleWriteGate.allow("VSM $methodName")) return false
-        val vsm = sVsm ?: return false
-        return try {
-            val types = args.map { if (it is Int) Int::class.javaPrimitiveType!! else it!!.javaClass }.toTypedArray()
-            vsm.javaClass.getMethod(methodName, *types).invoke(vsm, *args)
-            true   // méthode trouvée et appelée sans exception → succès
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  VSM: $methodName() exc: ${e.message}")
-            false
-        }
-    }
-
-    private fun getIntPropertyVpm(propId: Int): Int {
-        val vpm = sVpm ?: return -1
-        return try {
-            (vpm.javaClass.getMethod("getIntProperty", Int::class.java)
-                .invoke(vpm, propId) as? Int) ?: -1
-        } catch (_: Exception) { -1 }
-    }
-
-    private fun setIntPropertyVpm(propId: Int, value: Int): Boolean {
-        // [T-904] Écriture véhicule : autorisée uniquement à l'arrêt, refus si vitesse illisible.
-        if (!VehicleWriteGate.allow("VPM 0x${Integer.toHexString(propId)}")) return false
-        val vpm = sVpm ?: return false
-        return try {
-            vpm.javaClass.getMethod("setIntProperty", Int::class.java, Int::class.java)
-                .invoke(vpm, propId, value)
-            true
-        } catch (_: Exception) { false }
-    }
-
-    /** Variante avec recovery — utilisée par vehiclesettings pour les propriétés FCW/AEB. */
-    private fun setIntPropertyVpmRecovery(propId: Int, value: Int): Boolean {
-        // [T-904] Écriture véhicule : autorisée uniquement à l'arrêt, refus si vitesse illisible.
-        if (!VehicleWriteGate.allow("VPM-recovery 0x${Integer.toHexString(propId)}")) return false
-        val vpm = sVpm ?: return false
-        return try {
-            vpm.javaClass.getMethod("setIntPropertyRecovery", Int::class.java, Int::class.java)
-                .invoke(vpm, propId, value)
-            if (logEnabled) AppLogger.i(TAG, "  VPM setIntRecovery 0x${propId.toString(16)} value=$value ✓")
-            true
-        } catch (e: Exception) {
-            // Fallback sur setIntProperty si setIntPropertyRecovery absent
-            AppLogger.d(TAG, "  VPM setIntRecovery fallback for 0x${propId.toString(16)}: ${e.message}")
-            setIntPropertyVpm(propId, value)
-        }
-    }
-
-    // ── Alimentation véhicule (mise hors tension, infodivertissement maintenu) ─
-    // Reproduit le bouton "Vehicle Power → Off" du launcher MG (onglet Safety).
-    // Valeur 2 sur les 6 firmwares ; seul le chemin d'accès diffère :
-    //   • SWI133        : VehiclePropertyManager.setIntPropertyRecovery(0x6030021, 2)
-    //   • SWI68/SWI165  : VehicleSettingManager.setPowerModeSwitch(2)
-    //   • A9 (132/131/69): CarAdapterClient.queryClient(0xf) → CarComfortabletClient.setPowerModeSwitch(2)
-    // Le véhicule n'exécute la coupure qu'à l'arrêt en position P (garde côté firmware).
-    private const val PROP_POWER_MODE_SWITCH    = 0x6030021   // ID_POWER_MODE_SWITCH (SWI133)
-    private const val POWER_MODE_OFF            = 2
-    private const val COMFORTABLET_CLIENT_CLASS = "com.saicmotor.carapi.client.CarComfortabletClient"
-    private const val CAR_ADAPTER_CLIENT_CLASS  = "com.saicmotor.carapi.CarAdapterClient"
-    private const val COMFORTABLET_SERVICE_CODE = 0xf
-
-    /**
-     * Disponible sur les 6 firmwares : chacun a un check « position P » implémenté (garde de
-     * sécurité — le firmware ne garde PAS la commande, donc sans check P une extinction en roulant
-     * serait possible). Valeur P = 1 partout (cf. isVehicleInPark) :
-     *   • SWI133 : gear VPM 0x5030043 ✓
-     *   • A9 (132/131/69) : CarStateClient.getGearState() ✓ (confirmé SWI132)
-     *   • SWI68/165 : VehicleConditionManager.getCarGear() poll ✓ (confirmé SWI68, même SDK 165)
-     */
-    fun hasVehiclePowerOff(): Boolean =
-        FirmwareInfo.getGeneration() != FirmwareInfo.Gen.UNKNOWN
-
-    /** Coupe l'alimentation du véhicule tout en gardant l'écran/infodivertissement actif. */
-    fun vehiclePowerOff(): Boolean {
-        // Garde de sécurité : jamais d'extinction hors position P (re-vérifiée à l'envoi).
-        if (isVehicleInPark() != true) {
-            AppLogger.w(TAG, "vehiclePowerOff REFUSÉ — levier pas confirmé en P")
-            return false
-        }
-        val gen = FirmwareInfo.getGeneration()
-        AppLogger.i(TAG, "vehiclePowerOff (gen=$gen)")
-        return when {
-            gen == FirmwareInfo.Gen.SWI133 ->
-                setIntPropertyVpmRecovery(PROP_POWER_MODE_SWITCH, POWER_MODE_OFF)
-            gen == FirmwareInfo.Gen.SWI68 || gen == FirmwareInfo.Gen.SWI165 ->
-                // sVsm = VehicleSettingManager (vieux SDK)
-                callVsmVoid("setPowerModeSwitch", POWER_MODE_OFF)
-            FirmwareInfo.isNewGenVsm() || gen == FirmwareInfo.Gen.SWI132 ->
-                vehiclePowerOffA9()
-            else -> false
-        }
-    }
-
-    /** A9 (SWI132/131/69) : obtient CarComfortabletClient via l'adaptateur carapi et coupe l'alim. */
-    private fun vehiclePowerOffA9(): Boolean {
-        val cl = sVsm?.javaClass?.classLoader ?: run {
-            AppLogger.w(TAG, "  A9 power-off: sVsm/classloader null"); return false
-        }
-        return try {
-            val adapterClass = cl.loadClass(CAR_ADAPTER_CLIENT_CLASS)
-            val adapter = adapterClass.getMethod("getInstance", Context::class.java).invoke(null, sAppContext)
-            val binder = adapterClass.getMethod("queryClient", Int::class.javaPrimitiveType)
-                .invoke(adapter, COMFORTABLET_SERVICE_CODE) as? android.os.IBinder
-                ?: run { AppLogger.w(TAG, "  A9 power-off: queryClient(0xf) null"); return false }
-            val comfortClass = cl.loadClass(COMFORTABLET_CLIENT_CLASS)
-            val comfort = comfortClass.getConstructor(android.os.IBinder::class.java).newInstance(binder)
-            comfortClass.getMethod("setPowerModeSwitch", Int::class.javaPrimitiveType).invoke(comfort, POWER_MODE_OFF)
-            AppLogger.i(TAG, "  A9 power-off: CarComfortabletClient.setPowerModeSwitch($POWER_MODE_OFF) ✓")
-            true
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  A9 power-off error: ${e.javaClass.simpleName}: ${e.message}")
-            false
-        }
-    }
-
-    // ── Garde de sécurité : levier en position P ? ───────────────────────────
-    // L'OEM n'autorise le power-off qu'en P (gear == 1), mais NE garde PAS la commande
-    // côté firmware → c'est l'app qui doit vérifier (sinon extinction possible en roulant).
-    // Sources gear par firmware (smali) :
-    //   • SWI133        : VPM getIntProperty(0x5030043) ; PARK = 1 (CAR_GEAR_PARK_RANGE)
-    //   • SWI68/SWI165  : VehicleConditionBean.getCarGear() (signal condition véhicule)
-    //   • A9 (132/131/69): CarStateClient.getGearState()
-    // Seul SWI133 est implémenté ET vérifiable ici ; ailleurs on renvoie null → power-off bloqué.
-    private const val PROP_GEAR_STS   = 0x5030043   // SENSOR_TYPE_GEAR_STS (VPM, SWI133)
-    private const val GEAR_PARK_VALUE = 1
-
-    /**
-     * Levier en P ? true/false si déterminable, null si on ne sait pas (→ bloquer le power-off).
-     * Valeur P = 1 sur tous les firmwares étudiés (SWI133 0x5030043, A9 getGearState confirmé,
-     * SWI68/165 getCarGear = CarGearValue.PARK).
-     */
-    fun isVehicleInPark(): Boolean? {
-        val gen = FirmwareInfo.getGeneration()
-        val gear = when {
-            gen == FirmwareInfo.Gen.SWI133 ->
-                if (sVpm == null) Int.MIN_VALUE else getIntPropertyVpm(PROP_GEAR_STS)
-            FirmwareInfo.isNewGenVsm() || gen == FirmwareInfo.Gen.SWI132 ->
-                readA9GearState()                 // CarStateClient.getGearState()
-            gen == FirmwareInfo.Gen.SWI68 || gen == FirmwareInfo.Gen.SWI165 ->
-                readVcmCarGear()                  // VehicleConditionManager.getCarGear()
-            else -> Int.MIN_VALUE
-        }
-        AppLogger.i(TAG, "isVehicleInPark — gen=$gen gear=$gear (P=$GEAR_PARK_VALUE)")
-        return if (gear < 0) null else gear == GEAR_PARK_VALUE
-    }
-
-    // ── Lecture gear SWI68/165 (poll direct) + A9 (CarStateClient) ───────────
-    private const val CAR_STATE_CLIENT_CLASS = "com.saicmotor.carapi.client.CarStateClient"
-    private const val CAR_STATE_SERVICE_CODE = 0xb
-    @Volatile private var sCarState: Any? = null                   // A9 : CarStateClient (lazy)
-
-    /** SWI68/165 : VehicleConditionManager.getCarGear() (poll synchrone via sVcm). */
-    private fun readVcmCarGear(): Int {
-        val vcm = sVcm ?: return Int.MIN_VALUE
-        return try {
-            (vcm.javaClass.getMethod("getCarGear").invoke(vcm) as? Int) ?: Int.MIN_VALUE
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  getCarGear err: ${e.javaClass.simpleName}: ${e.message}"); Int.MIN_VALUE
-        }
-    }
-
-    /** A9 : CarStateClient.getGearState() via CarAdapterClient.queryClient(0xb). */
-    private fun readA9GearState(): Int {
-        val cl = sVsm?.javaClass?.classLoader ?: return Int.MIN_VALUE
-        return try {
-            if (sCarState == null) {
-                val adapterClass = cl.loadClass(CAR_ADAPTER_CLIENT_CLASS)
-                val adapter = adapterClass.getMethod("getInstance", Context::class.java).invoke(null, sAppContext)
-                val binder = adapterClass.getMethod("queryClient", Int::class.javaPrimitiveType)
-                    .invoke(adapter, CAR_STATE_SERVICE_CODE) as? android.os.IBinder ?: return Int.MIN_VALUE
-                val stateClass = cl.loadClass(CAR_STATE_CLIENT_CLASS)
-                sCarState = stateClass.getConstructor(android.os.IBinder::class.java).newInstance(binder)
-            }
-            (sCarState!!.javaClass.getMethod("getGearState").invoke(sCarState) as? Int) ?: Int.MIN_VALUE
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  A9 getGearState err: ${e.javaClass.simpleName}: ${e.message}"); Int.MIN_VALUE
-        }
-    }
-
-    private fun getMixIntProperty(propId: Int): Int {
-        val vpm = sVpm ?: return -1
-        return try {
-            // Méthode réelle sur VPM : getMixProperty(Class, int)
-            val result = vpm.javaClass
-                .getMethod("getMixProperty", Class::class.java, Int::class.java)
-                .invoke(vpm, Int::class.javaObjectType, propId)
-            when (result) {
-                is Int    -> result
-                is Number -> result.toInt()
-                null      -> { AppLogger.d(TAG, "  Katman4: getMixProperty(0x${propId.toString(16)}) = null"); -1 }
-                else      -> { AppLogger.d(TAG, "  Katman4: getMixProperty(0x${propId.toString(16)}) = $result (${result.javaClass.simpleName})"); -1 }
-            }
-        } catch (e: Exception) {
-            AppLogger.d(TAG, "  Katman4: getMixProperty(0x${propId.toString(16)}) exc: ${e.message}")
-            -1
-        }
-    }
-
-    private fun setMixIntProperty(propId: Int, value: Int): Boolean {
-        val vpm = sVpm ?: return false
-        return try {
-            // Méthode réelle sur VPM : setMixProperty(Class, int, Object)
-            vpm.javaClass
-                .getMethod("setMixProperty", Class::class.java, Int::class.java, Any::class.java)
-                .invoke(vpm, Int::class.javaObjectType, propId, value)
-            AppLogger.i(TAG, "  Katman4: setMixProperty(0x${propId.toString(16)}, $value) ✓")
-            true
-        } catch (e: Exception) {
-            AppLogger.d(TAG, "  Katman4: setMixProperty(0x${propId.toString(16)}, $value) exc: ${e.message}")
-            false
-        }
-    }
-
-    // -------------------------------------------------------------------------
-    // Low-level property accessors
-    // -------------------------------------------------------------------------
-
-    private fun getIntPropertyCPM(propId: Int, areaId: Int): Int {
-        val cpm = sCarPropertyManager ?: return -1
-        return try {
-            (cpm.javaClass
-                .getMethod("getIntProperty", Int::class.java, Int::class.java)
-                .invoke(cpm, propId, areaId) as? Int) ?: -1
-        } catch (e: Exception) {
-            AppLogger.d(TAG, "  CPM getInt 0x${Integer.toHexString(propId)} exc: ${e.message}")
-            -1
-        }
-    }
-
-    /** Lecture float via CarPropertyManager. null = illisible (à distinguer de 0). */
-    private fun getFloatPropertyCPM(propId: Int, areaId: Int): Float? {
-        val cpm = sCarPropertyManager ?: return null
-        return try {
-            cpm.javaClass
-                .getMethod("getFloatProperty", Int::class.java, Int::class.java)
-                .invoke(cpm, propId, areaId) as? Float
-        } catch (e: Exception) {
-            AppLogger.d(TAG, "  CPM getFloat 0x${Integer.toHexString(propId)} exc: ${e.message}")
-            null
-        }
-    }
-
-    private fun setIntPropertyCPM(propId: Int, areaId: Int, value: Int): Boolean {
-        // [T-904] Écriture véhicule : autorisée uniquement à l'arrêt, refus si vitesse illisible.
-        if (!VehicleWriteGate.allow("CPM 0x${Integer.toHexString(propId)}")) return false
-        val cpm = sCarPropertyManager ?: run {
-            AppLogger.w(TAG, "  CPM setInt 0x${Integer.toHexString(propId)} — CPM not ready")
-            return false
-        }
-        return try {
-            cpm.javaClass
-                .getMethod("setIntProperty", Int::class.java, Int::class.java, Int::class.java)
-                .invoke(cpm, propId, areaId, value)
-            if (logEnabled) AppLogger.i(TAG, "  CPM setInt 0x${Integer.toHexString(propId)} area=0x${Integer.toHexString(areaId)} value=$value ✓")
-            true
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  CPM setInt 0x${Integer.toHexString(propId)} error: ${e.message}")
-            false
-        }
-    }
-
-    fun getIntPropertyHvac(propId: Int, areaId: Int): Int {
-        val hvac = sCarHvacManager ?: return -1
-        return try {
-            (hvac.javaClass.getMethod("getIntProperty", Int::class.java, Int::class.java)
-                .invoke(hvac, propId, areaId) as? Int) ?: -1
-        } catch (_: Exception) { -1 }
-    }
-
-    private fun setIntPropertyHvac(propId: Int, areaId: Int, value: Int): Boolean {
-        val hvac = sCarHvacManager ?: return false
-        return try {
-            hvac.javaClass
-                .getMethod("setIntProperty", Int::class.java, Int::class.java, Int::class.java)
-                .invoke(hvac, propId, areaId, value)
-            true
-        } catch (_: Exception) { false }
-    }
-
-    /**
-     * SAIC proprietary binder transact (Katman2 fallback).
-     * Parcel layout from smali: [interfaceToken, AREA_GLOBAL, 1, value, float[], byte[]]
-     */
-    private fun binderTransact(binder: IBinder?, descriptor: String, txCode: Int, value: Int): Boolean {
-        // [T-904] Écriture véhicule : autorisée uniquement à l'arrêt, refus si vitesse illisible.
-        if (!VehicleWriteGate.allow("binder tx=0x${Integer.toHexString(txCode)}")) return false
-        if (binder == null) {
-            AppLogger.w(TAG, "  Binder TX=$txCode — binder null")
-            return false
-        }
-        val data = Parcel.obtain()
-        val reply = Parcel.obtain()
-        return try {
-            data.writeInterfaceToken(descriptor)
-            data.writeInt(AREA_GLOBAL)
-            data.writeInt(1)
-            data.writeInt(value)
-            data.writeFloatArray(FloatArray(0))
-            data.writeByteArray(ByteArray(0))
-            binder.transact(txCode, data, reply, 0)
-            val status = if (reply.dataAvail() > 0) reply.readInt() else 0
-            if (logEnabled) AppLogger.i(TAG, "  Binder TX=$txCode value=$value → status=$status ${if (status == 0) "✓" else "✗ REJECTED"}")
-            status == 0
-        } catch (e: Exception) {
-            AppLogger.e(TAG, "  binderTransact error: ${e.message}")
-            false
-        } finally {
-            data.recycle()
-            reply.recycle()
-        }
-    }
-
-    /**
-     * HVAC toggle — cycles the property by sending value=1 until target is reached.
-     * Timeout: 7 seconds (from original smali: 0x1b58 ms = 7000 ms).
-     */
-    fun setHvacLevelWithToggle(propId: Int, areaId: Int, targetLevel: Int): Boolean {
-        val deadline = System.currentTimeMillis() + 7_000L
-        var lastClickMs = 0L
-        while (System.currentTimeMillis() < deadline) {
-            val current = getIntPropertyHvac(propId, areaId)
-            if (current == targetLevel) {
-                if (logEnabled) AppLogger.i(TAG, "HVAC target reached: $targetLevel")
-                return true
-            }
-            val now = System.currentTimeMillis()
-            if (now - lastClickMs >= 500L) {
-                if (logEnabled) AppLogger.i(TAG, "HVAC click → current=$current target=$targetLevel")
-                setIntPropertyHvac(propId, areaId, 1)
-                lastClickMs = now
-                try { Thread.sleep(200) } catch (_: InterruptedException) {}
-            } else {
-                try { Thread.sleep(250) } catch (_: InterruptedException) {}
-            }
-        }
-        AppLogger.e(TAG, "HVAC timeout! prop=0x${Integer.toHexString(propId)}")
-        return false
-    }
-
-    // -------------------------------------------------------------------------
-    // Public vehicle control API
-    // -------------------------------------------------------------------------
-
-    fun setDriveMode(mode: DriveMode): Boolean {
-        if (logEnabled) AppLogger.i(TAG, "setDriveMode → ${mode.label} (${mode.value})")
-        val ok = setIntPropertyCPM(PROP_DRIVE_MODE, AREA_GLOBAL, mode.value)
-        if (!ok) binderTransact(sVehicleBinder, DESCRIPTOR_VEHICLE, TX_SET_DRIVE_MODE, mode.value)
-        sAppContext?.getSharedPreferences(PREFS_NAME, 0)?.edit()
-            ?.putInt(KEY_LAST_DRIVE_MODE, mode.value)?.apply()
-        return ok
-    }
-
-    fun setRegenLevel(level: RegenLevel): Boolean {
-        if (logEnabled) AppLogger.i(TAG, "setRegenLevel → ${level.label} (${level.value})")
-        return if (level == RegenLevel.ONE_PEDAL) {
-            val ok = setOnePedal(true)
-            if (!ok) {
-                setIntPropertyCPM(PROP_REGEN_LEVEL, AREA_GLOBAL, level.value)
-                binderTransact(sVehicleBinder, DESCRIPTOR_VEHICLE, TX_SET_REGEN_LEVEL, level.value)
-            }
-            ok
-        } else {
-            setOnePedal(false)
-            val ok = setIntPropertyCPM(PROP_REGEN_LEVEL, AREA_GLOBAL, level.value)
-            if (!ok) binderTransact(sVehicleBinder, DESCRIPTOR_VEHICLE, TX_SET_REGEN_LEVEL, level.value)
-            ok
-        }
-    }
-
-    fun setOnePedal(enabled: Boolean): Boolean {
-        if (logEnabled) AppLogger.i(TAG, "setOnePedal → ${if (enabled) "On" else "Off"}")
-        val intVal = if (enabled) 1 else 0
-        val ok = setIntPropertyCPM(PROP_ONE_PEDAL, AREA_GLOBAL, intVal)
-        if (!ok) binderTransact(sVehicleBinder, DESCRIPTOR_VEHICLE, TX_SET_ONE_PEDAL, intVal)
-        return ok
-    }
-
-    fun getSeatHeatLeft(): Int  = getIntPropertyHvac(PROP_SEAT_HEAT_L, AREA_HVAC).coerceAtLeast(0)
-    fun getSeatHeatRight(): Int = getIntPropertyHvac(PROP_SEAT_HEAT_R, AREA_HVAC).coerceAtLeast(0)
-    fun isSteeringHeatOn(): Boolean = getIntPropertyHvac(PROP_STEERING_HEAT, AREA_HVAC) > 0
-
-    fun getDriveMode(): DriveMode? {
-        val cpm = sCarPropertyManager ?: return null
-        return try {
-            val raw = (cpm.javaClass
-                .getMethod("getIntProperty", Int::class.java, Int::class.java)
-                .invoke(cpm, PROP_DRIVE_MODE, AREA_GLOBAL) as? Int) ?: return null
-            DriveMode.fromValue(raw)
-        } catch (_: Exception) { null }
-    }
-
-    fun getRegenLevel(): RegenLevel? {
-        val cpm = sCarPropertyManager ?: return null
-        return try {
-            val raw = (cpm.javaClass
-                .getMethod("getIntProperty", Int::class.java, Int::class.java)
-                .invoke(cpm, PROP_REGEN_LEVEL, AREA_GLOBAL) as? Int) ?: return null
-            RegenLevel.fromValue(raw)
-        } catch (_: Exception) { null }
-    }
-
-    fun setSeatHeatLeft(level: Int): Boolean {
-        if (logEnabled) AppLogger.i(TAG, "setSeatHeatLeft → $level")
-        return setHvacLevelWithToggle(PROP_SEAT_HEAT_L, AREA_HVAC, level)
-    }
-
-    fun setSeatHeatRight(level: Int): Boolean {
-        if (logEnabled) AppLogger.i(TAG, "setSeatHeatRight → $level")
-        return setHvacLevelWithToggle(PROP_SEAT_HEAT_R, AREA_HVAC, level)
-    }
-
-    fun setSteeringHeat(on: Boolean): Boolean {
-        if (logEnabled) AppLogger.i(TAG, "setSteeringHeat → $on")
-        val current = getIntPropertyHvac(PROP_STEERING_HEAT, AREA_HVAC)
-        if ((current > 0) == on) return true
-        // Send a single click and wait for state confirmation (avoids on/off oscillation)
-        setIntPropertyHvac(PROP_STEERING_HEAT, AREA_HVAC, 1)
-        val deadline = System.currentTimeMillis() + 2_000L
-        while (System.currentTimeMillis() < deadline) {
-            try { Thread.sleep(300) } catch (_: InterruptedException) {}
-            if ((getIntPropertyHvac(PROP_STEERING_HEAT, AREA_HVAC) > 0) == on) return true
-        }
-        return false
-    }
-
-    // -------------------------------------------------------------------------
-    // ADAS API (Katman4)
-    // -------------------------------------------------------------------------
-
-    fun isOverspeedAlarmOn(): Boolean {
-        if (FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132) {
-            // Priorité VSM (CarVehicleSettingClient) — confirmé dans smali SWI132
-            // getOverSpeedSoundMode() : 0=OFF, 1/2/3=ON
-            val vsm = callVsm("getOverSpeedSoundMode") as? Int
-            if (vsm != null) {
-                AppLogger.d(TAG, "  SWI132 overspeed GET via VSM → $vsm")
-                return vsm > 0
-            }
-            return swi132BinderGet(VSM132_TX_GET_OVERSPEED) == 1
-        }
-        return getIntPropertyVpm(PROP_OVERSPEED_ALARM) > 0
-    }
-
-    fun setOverspeedAlarm(on: Boolean): Boolean {
-        if (logEnabled) AppLogger.i(TAG, "setOverspeedAlarm → $on")
-        if (FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132) {
-            // Essai 1 : CarVehicleSettingClient — setOverSpeedSoundMode(I)V est une méthode void ;
-            // callVsmVoid() détecte le succès même quand invoke() retourne null (comportement normal).
-            if (callVsmVoid("setOverSpeedSoundMode", if (on) 1 else 0)) {
-                AppLogger.i(TAG, "  SWI132 overspeed → VSM OK")
-                return true
-            }
-            AppLogger.w(TAG, "  SWI132 overspeed: VSM failed — essai binder")
-            // Essai 2 : binder direct (TX 0x128, bloqué SELinux sur certains builds)
-            if (swi132BinderSet(VSM132_TX_OVERSPEED_SOUND, if (on) 1 else 0)) return true
-            AppLogger.w(TAG, "  SWI132 overspeed: tous les paths ont échoué")
-            return false
-        }
-        return setIntPropertyVpm(PROP_OVERSPEED_ALARM, if (on) 1 else 0)
-    }
-
-    fun isSpeedLimitToneOn(): Boolean {
-        if (FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132) {
-            // getSpeedLimitSoundMode() : 0=OFF, valeur positive=ON
-            val vsm = callVsm("getSpeedLimitSoundMode") as? Int
-            if (vsm != null) {
-                AppLogger.d(TAG, "  SWI132 speedLimit GET via VSM → $vsm")
-                return vsm > 0
-            }
-            return swi132BinderGet(VSM132_TX_GET_SPEED_LIMIT) == 1
-        }
-        return getIntPropertyVpm(PROP_SPEED_LIMIT_TONE) > 0
-    }
-
-    fun setSpeedLimitTone(on: Boolean): Boolean {
-        if (logEnabled) AppLogger.i(TAG, "setSpeedLimitTone → $on")
-        if (FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132) {
-            // Essai 1 : CarVehicleSettingClient — setSpeedLimitSoundMode(I)V (méthode void)
-            if (callVsmVoid("setSpeedLimitSoundMode", if (on) 1 else 0)) {
-                AppLogger.i(TAG, "  SWI132 speedLimit → VSM OK")
-                return true
-            }
-            AppLogger.w(TAG, "  SWI132 speedLimit: VSM failed — essai binder")
-            // Essai 2 : binder direct (TX 0x12a)
-            if (swi132BinderSet(VSM132_TX_SPEED_LIMIT, if (on) 1 else 0)) return true
-            AppLogger.w(TAG, "  SWI132 speedLimit: tous les paths ont échoué")
-            return false
-        }
-        return setIntPropertyVpm(PROP_SPEED_LIMIT_TONE, if (on) 1 else 0)
-    }
-
-    /** Returns 0–4 (Off/Limiteur/Auto/ACC/ICA), or -1 if Katman4 not ready. */
-    fun getMixedIntelligentDrive(): Int = getMixIntProperty(PROP_MIX_INTELLIGENT_DRIVE)
-    fun setMixedIntelligentDrive(value: Int): Boolean {
-        if (logEnabled) AppLogger.i(TAG, "setMixedIntelligentDrive → $value")
-        // Primary: setMixProperty (smali-accurate). Fallback: setIntProperty if method missing.
-        if (setMixIntProperty(PROP_MIX_INTELLIGENT_DRIVE, value)) return true
-        return setIntPropertyVpm(PROP_MIX_INTELLIGENT_DRIVE, value)
-    }
-
-    // ── SWI68 / SWI69 ADAS API — VehicleSettingManager (noms de méthodes différents) ──
-
-    /**
-     * Retourne le mode ACC/TJA actuel (0x4=Off, 0x1=ACC, 0x2=TJA), ou -1 si pas prêt.
-     * SWI68/SWI165 : getAccTjaMode()   SWI69/SWI131/SWI132 : getAccTjaState()
-     */
-    fun getAccTjaMode(): Int {
-        val useNewApi = FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132
-        val method = if (useNewApi) "getAccTjaState" else "getAccTjaMode"
-        if (logEnabled) AppLogger.i(TAG, "$method →")
-        return (callVsm(method) as? Int) ?: -1
-    }
-
-    /** SWI68/SWI165 : setAccTjaMode(I)V   SWI69/SWI131/SWI132 : setAccTjaState(I)V — void */
-    fun setAccTjaMode(mode: Int): Boolean {
-        val useNewApi = FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132
-        val method = if (useNewApi) "setAccTjaState" else "setAccTjaMode"
-        if (logEnabled) AppLogger.i(TAG, "$method → 0x${mode.toString(16)}")
-        return callVsmVoid(method, mode)   // void method — callVsmVoid évite le faux-négatif
-    }
-
-    /**
-     * Limiteur de vitesse — API unifiée pour tous les firmwares VSM.
-     * Le limiteur est un réglage INDÉPENDANT du mode ACC/TJA, avec les mêmes valeurs partout
-     * (0=Désactivé, 2=Manuel, 3=Intelligent — vérifié dans le smali de chaque firmware),
-     * seul le nom de méthode binder diffère :
-     *   SWI132/SWI131/SWI69 : getSasMode/setSasMode        (CarVehicleSettingClient)
-     *   SWI68/SWI165        : getSpeedAsstMode/setSpeedAsstMode (VehicleSettingManager)
-     */
-    private fun useSasApi(): Boolean =
-        FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132
-
-    /** Lit le mode du limiteur de vitesse. Retourne 0/2/3, ou -1 si indisponible. */
-    fun getSpeedLimiterMode(): Int {
-        val method = if (useSasApi()) "getSasMode" else "getSpeedAsstMode"
-        if (logEnabled) AppLogger.i(TAG, "$method →")
-        return (callVsm(method) as? Int) ?: -1
-    }
-
-    /** Configure le mode du limiteur de vitesse. 0=Désactivé, 2=Manuel, 3=Intelligent. */
-    fun setSpeedLimiterMode(mode: Int): Boolean {
-        val method = if (useSasApi()) "setSasMode" else "setSpeedAsstMode"
-        if (logEnabled) AppLogger.i(TAG, "$method → $mode")
-        return callVsmVoid(method, mode)
-    }
-
-    /**
-     * SWI68/SWI165 : getLaneKeepingWarningSound()
-     * SWI69/SWI131/SWI132 : getLasWarningSound()   (confirmé dans smali SWI132)
-     * Valeurs : 2=ON / 1=OFF
-     */
-    fun isSoundWarningOn(): Boolean {
-        val method = if (FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132)
-            "getLasWarningSound" else "getLaneKeepingWarningSound"
-        return ((callVsm(method) as? Int) ?: 1) == 2
-    }
-
-    /** SWI68 : setLaneKeepingWarningSound(I)   SWI69/SWI131/SWI132 : setLasWarningSound(I) — void */
-    fun setSoundWarning(on: Boolean): Boolean {
-        if (logEnabled) AppLogger.i(TAG, "setSoundWarning → $on")
-        val method = if (FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132)
-            "setLasWarningSound" else "setLaneKeepingWarningSound"
-        return callVsmVoid(method, if (on) 2 else 1)
-    }
-
-    // ── AEB — Système anti-collision avant ──────────────────────────────────
-
-    /**
-     * Retourne true si le système anti-collision avant est activé.
-     * SWI133          : lit PROP_AEB_SWITCH (2=ON, 1=OFF) via CarPropertyManager.
-     * SWI68 / SWI165  : getFcwAlarmMode() == 2  (FCW_ALARM_ON=2, FCW_ALARM_OFF=1)
-     *                   Vérifié dans SafeSettingsRepository SWI165 — même API que SWI68.
-     * SWI69 / SWI131  : getFcwState() — 1=DÉSACTIVÉ, 2=ACTIVÉ
-     */
-    fun isAebEnabled(): Boolean {
-        return when {
-            // SWI69 / SWI131 / SWI132 — CarVehicleSettingClient : getFcwState() (1=OFF, 2=ON)
-            FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132 ->
-                (callVsm("getFcwState") as? Int) == 2
-            FirmwareInfo.isVsmBased()  -> (callVsm("getFcwAlarmMode") as? Int) == 2  // SWI68 / SWI165
-            else                       -> getIntPropertyCPM(PROP_AEB_SWITCH, AREA_GLOBAL) == 0x2  // SWI133
-        }
-    }
-
-    fun setAebEnabled(on: Boolean): Boolean {
-        if (logEnabled) AppLogger.i(TAG, "setAebEnabled → $on")
-        return when {
-            // SWI69 / SWI131 / SWI132 — CarVehicleSettingClient (même API)
-            // setFcwState(I)V et setFcwAutoBrakeMode(I)V sont des méthodes VOID →
-            // callVsmVoid() est utilisé pour éviter le faux-négatif de callVsm() != null.
-            FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132 -> {
-                // OFF : setFcwState(1) + setFcwAutoBrakeMode(1) + setFcwSensitivity(0)
-                // ON  : setFcwState(2) + setFcwAutoBrakeMode(curMode)
-                // Le launcher conditionne son affichage à fcwState==1 AND autoBreakState==1
-                // → sans setFcwAutoBrakeMode, son switch reste ON même quand l'AEB est désactivé
-                if (on) {
-                    val sOk = callVsmVoid("setFcwState", 2)
-                    val curMode = (callVsm("getFcwAutoBrakeMode") as? Int) ?: 1
-                    val mOk = callVsmVoid("setFcwAutoBrakeMode", curMode)
-                    sOk || mOk
-                } else {
-                    callVsmVoid("setFcwState", 1)
-                    callVsmVoid("setFcwAutoBrakeMode", 1)
-                    callVsmVoid("setFcwSensitivity", 0)
-                }
-            }
-            FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI68 ||
-            FirmwareInfo.isSWI165() -> {
-                // SWI68 / SWI165 : setFcwAlarmMode(2=ON / 1=OFF) + setFcwAutoBrakeMode(1) si OFF
-                // Vérifié dans SafeSettingsRepository SWI165 — même API que SWI68,
-                // setAutoEmergencyBraking() n'est jamais utilisé par l'app officielle.
-                // setFcwAlarmMode(I)V et setFcwAutoBrakeMode(I)V sont void → callVsmVoid()
-                if (on) callVsmVoid("setFcwAlarmMode", 2)
-                else { callVsmVoid("setFcwAlarmMode", 1) or callVsmVoid("setFcwAutoBrakeMode", 1) }
-            }
-            else -> setIntPropertyCPM(PROP_AEB_SWITCH, AREA_GLOBAL, if (on) 0x2 else 0x1)
-        }
-    }
-
-    /**
-     * Retourne le mode AEB courant (1=Alerte, 2=Alerte+Freinage), ou -1 si pas prêt.
-     * SWI133          : PROP_AEB_MODE (0x302000b) via VehiclePropertyManager.
-     * SWI68/SWI69/SWI131 : getFcwAutoBrakeMode() (1=Alerte, 2=Alerte+Freinage).
-     */
-    fun getAebMode(): Int {
-        return if (FirmwareInfo.isVsmBased()) {
-            (callVsm("getFcwAutoBrakeMode") as? Int) ?: AebMode.ALARM
-        } else {
-            val raw = getIntPropertyVpm(PROP_AEB_MODE)
-            if (raw < 1) -1 else raw
-        }
-    }
-
-    fun setAebMode(mode: Int): Boolean {
-        if (logEnabled) AppLogger.i(TAG, "setAebMode → $mode")
-        return when {
-            // SWI69 / SWI131 / SWI132 — CarVehicleSettingClient : fixer mode puis activer
-            // setFcwAutoBrakeMode(I)V et setFcwState(I)V sont void → callVsmVoid()
-            FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132 -> {
-                // L'ordre : 1) fixer le mode, 2) activer (commit le mode).
-                val modeVal = if (mode == AebMode.ALARM_BRAKE) 2 else 1
-                val mOk = callVsmVoid("setFcwAutoBrakeMode", modeVal)
-                val sOk = callVsmVoid("setFcwState", 2)
-                mOk || sOk
-            }
-            FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI68 ||
-            FirmwareInfo.isSWI165() -> {
-                // SWI68 / SWI165 : setFcwAutoBrakeMode uniquement (1=Alerte, 2=Alerte+Freinage)
-                callVsm("setFcwAutoBrakeMode", if (mode == AebMode.ALARM_BRAKE) 2 else 1) != null
-            }
-            else -> {
-                // SWI133 smali exact
-                if (mode == AebMode.ALARM_BRAKE) {
-                    val r1 = setIntPropertyVpmRecovery(PROP_AEB_SYS_MODE, AebMode.ALARM_BRAKE)
-                    val r2 = setIntPropertyVpmRecovery(PROP_AEB_MODE, AebMode.ALARM_BRAKE)
-                    r1 || r2
-                } else {
-                    setIntPropertyVpmRecovery(PROP_AEB_MODE, AebMode.ALARM)
-                }
-            }
-        }
-    }
-
-    /**
-     * Retourne la sensibilité AEB courante (1=Faible, 2=Standard, 3=Élevé), ou -1 si pas prêt.
-     * SWI133         : PROP_AEB_SENSITIVITY (0x302000e, VPM)
-     * SWI68/SWI165   : VehicleSettingManager.getFcwSensitivity()
-     * SWI69/SWI131   : CarVehicleSettingClient.getFcwSensitivity()
-     */
-    fun getAebSensitivity(): Int {
-        return if (FirmwareInfo.isVsmBased()) {
-            (callVsm("getFcwSensitivity") as? Int)?.takeIf { it > 0 }?.also {
-                AppLogger.d(TAG, "  AEB GET sensitivity=$it via VSM ✓")
-            } ?: -1
-        } else {
-            val raw = getIntPropertyVpm(PROP_AEB_SENSITIVITY)
-            if (raw < 1) -1 else raw
-        }
-    }
-
-    /**
-     * Définit la sensibilité AEB (1=Faible, 2=Standard, 3=Élevé).
-     * SWI133         : PROP_AEB_SENSITIVITY (0x302000e, VPM)
-     * SWI68/SWI165   : VehicleSettingManager.setFcwSensitivity(I)
-     * SWI69/SWI131   : CarVehicleSettingClient.setFcwSensitivity(I)
-     */
-    fun setAebSensitivity(level: Int): Boolean {
-        // setFcwSensitivity(I)V est void → callVsmVoid() pour éviter le faux-négatif
-        return if (FirmwareInfo.isVsmBased()) {
-            AppLogger.i(TAG, "  AEB SET sensitivity=$level via VSM")
-            callVsmVoid("setFcwSensitivity", level)
-        } else {
-            AppLogger.i(TAG, "  AEB SET sensitivity=$level via VPM")
-            setIntPropertyVpmRecovery(PROP_AEB_SENSITIVITY, level)
-        }
-    }
-
-    // -------------------------------------------------------------------------
-    // ELK — Assistant de sortie de voie (SWI133 uniquement pour l'instant)
-    // Utilise IVehicleSettingService via sVehicleBinder (TX 0x53–0x56)
-    // -------------------------------------------------------------------------
-
-    /**
-     * Retourne le mode ELK courant (1=OFF, 2=Alerte, 3=Aider, 5=Maintien d'urgence).
-     * Routage par firmware :
-     *   SWI133         → VSM133 (getLaneKeepingAsstMode) → binder TX 0x53
-     *   SWI68/SWI165   → VSM    (getLaneKeepingAsstMode)
-     *   SWI69/SWI131   → VSM    (getLasMode)
-     */
-    fun getElkMode(): Int = when {
-        !FirmwareInfo.isVsmBased() -> {
-            val vsm = callVsm133("getLaneKeepingAsstMode")
-            if (vsm is Int && vsm > 0) {
-                AppLogger.d(TAG, "  ELK GET mode=$vsm via VSM133 ✓")
-                vsm
-            } else elkBinderGet(TX_ELK_GET_MODE)
-        }
-        FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132 -> {
-            // SWI69/SWI131/SWI132 — CarVehicleSettingClient
-            (callVsm("getLasMode") as? Int)?.takeIf { it > 0 }?.also {
-                AppLogger.d(TAG, "  ELK GET mode=$it via VSM (Las) ✓")
-            } ?: -1
-        }
-        else -> {
-            // SWI68/SWI165 — VehicleSettingManager
-            (callVsm("getLaneKeepingAsstMode") as? Int)?.takeIf { it > 0 }?.also {
-                AppLogger.d(TAG, "  ELK GET mode=$it via VSM ✓")
-            } ?: -1
-        }
-    }
-
-    /**
-     * Définit le mode ELK.
-     * Routage identique à getElkMode().
-     */
-    fun setElkMode(mode: Int): Boolean = when {
-        !FirmwareInfo.isVsmBased() -> {
-            if (sVsm133 != null) {
-                AppLogger.i(TAG, "  ELK SET mode=$mode via VSM133")
-                if (!VehicleWriteGate.allow("VSM133 setLaneKeepingAsstMode")) {
-                    false
-                } else {
-                    callVsm133("setLaneKeepingAsstMode", mode)
-                    true
-                }
-            } else elkBinderSet(TX_ELK_SET_MODE, mode)
-        }
-        FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132 -> {
-            // SWI69/SWI131/SWI132 — CarVehicleSettingClient
-            AppLogger.i(TAG, "  ELK SET mode=$mode via VSM (Las)")
-            callVsm("setLasMode", mode)
-            true
-        }
-        else -> {
-            // SWI68/SWI165 — VehicleSettingManager
-            AppLogger.i(TAG, "  ELK SET mode=$mode via VSM")
-            callVsm("setLaneKeepingAsstMode", mode)
-            true
-        }
-    }
-
-    /**
-     * Retourne la sensibilité ELK courante (1=Faible, 2=Standard, 3=Élevé).
-     * Routage par firmware — identique à getElkMode().
-     */
-    fun getElkSensitivity(): Int = when {
-        !FirmwareInfo.isVsmBased() -> {
-            val vsm = callVsm133("getLaneKeepingAsstSen")
-            if (vsm is Int && vsm > 0) {
-                AppLogger.d(TAG, "  ELK GET sen=$vsm via VSM133 ✓")
-                vsm
-            } else elkBinderGet(TX_ELK_GET_SEN)
-        }
-        FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132 -> {
-            // SWI69/SWI131/SWI132 — CarVehicleSettingClient
-            (callVsm("getLasSensitivity") as? Int)?.takeIf { it > 0 }?.also {
-                AppLogger.d(TAG, "  ELK GET sen=$it via VSM (Las) ✓")
-            } ?: -1
-        }
-        else -> {
-            // SWI68/SWI165 — VehicleSettingManager
-            (callVsm("getLaneKeepingAsstSen") as? Int)?.takeIf { it > 0 }?.also {
-                AppLogger.d(TAG, "  ELK GET sen=$it via VSM ✓")
-            } ?: -1
-        }
-    }
-
-    /**
-     * Définit la sensibilité ELK.
-     * Routage identique à getElkMode().
-     */
-    fun setElkSensitivity(level: Int): Boolean = when {
-        !FirmwareInfo.isVsmBased() -> {
-            if (sVsm133 != null) {
-                AppLogger.i(TAG, "  ELK SET sensitivity=$level via VSM133")
-                if (!VehicleWriteGate.allow("VSM133 setLaneKeepingAsstSen")) {
-                    false
-                } else {
-                    callVsm133("setLaneKeepingAsstSen", level)
-                    true
-                }
-            } else elkBinderSet(TX_ELK_SET_SEN, level)
-        }
-        FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132 -> {
-            // SWI69/SWI131/SWI132 — CarVehicleSettingClient
-            AppLogger.i(TAG, "  ELK SET sensitivity=$level via VSM (Las)")
-            callVsm("setLasSensitivity", level)
-            true
-        }
-        else -> {
-            // SWI68/SWI165 — VehicleSettingManager
-            AppLogger.i(TAG, "  ELK SET sensitivity=$level via VSM")
-            callVsm("setLaneKeepingAsstSen", level)
-            true
-        }
-    }
-
-    /** Retourne true si l'ELK est activé (mode ≠ OFF). */
-    fun isElkEnabled(): Boolean {
-        val mode = getElkMode()
-        return mode > 0 && mode != ElkMode.OFF
-    }
-
-    /**
-     * SWI132 — Alerte sonore (LAS Warning Sound) : 0=OFF, 1=ON.
-     * Retourne -1 si erreur ou firmware non SWI132.
-     */
-    fun getLasWarningSound(): Int {
-        if (FirmwareInfo.getGeneration() != FirmwareInfo.Gen.SWI132) return -1
-        return (callVsm("getLasWarningSound") as? Int)?.also {
-            AppLogger.d(TAG, "  LAS GET sound=$it via VSM ✓")
-        } ?: -1
-    }
-
-    fun setLasWarningSound(enabled: Boolean): Boolean {
-        if (FirmwareInfo.getGeneration() != FirmwareInfo.Gen.SWI132) return false
-        AppLogger.i(TAG, "  LAS SET sound=${if (enabled) "ON" else "OFF"} via VSM")
-        callVsm("setLasWarningSound", if (enabled) 1 else 0)
-        return true
-    }
-
-    /**
-     * SWI132 — Rappel par vibration (LAS Warning Vibration) : 0=OFF, 1=ON.
-     * Retourne -1 si erreur ou firmware non SWI132.
-     */
-    fun getLasWarningVibration(): Int {
-        if (FirmwareInfo.getGeneration() != FirmwareInfo.Gen.SWI132) return -1
-        return (callVsm("getLasWarningVibration") as? Int)?.also {
-            AppLogger.d(TAG, "  LAS GET vibration=$it via VSM ✓")
-        } ?: -1
-    }
-
-    fun setLasWarningVibration(enabled: Boolean): Boolean {
-        if (FirmwareInfo.getGeneration() != FirmwareInfo.Gen.SWI132) return false
-        AppLogger.i(TAG, "  LAS SET vibration=${if (enabled) "ON" else "OFF"} via VSM")
-        callVsm("setLasWarningVibration", if (enabled) 1 else 0)
-        return true
-    }
-
-    /**
-     * GET via IVehicleSettingService binder — layout smali :
-     *   data : [writeInterfaceToken]
-     *   transact(code, data, reply, 0)
-     *   reply: readException() + readInt()
-     */
-    private fun elkBinderGet(txCode: Int): Int {
-        val binder = sVehicleBinder ?: run {
-            AppLogger.d(TAG, "  ELK GET TX=0x${txCode.toString(16)} — sVehicleBinder null")
-            return -1
-        }
-        val data  = Parcel.obtain()
-        val reply = Parcel.obtain()
-        return try {
-            data.writeInterfaceToken(DESCRIPTOR_VEHICLE)
-            val ok = binder.transact(txCode, data, reply, 0)
-            if (!ok) {
-                AppLogger.d(TAG, "  ELK GET TX=0x${txCode.toString(16)} — transact returned false")
-                return -1
-            }
-            reply.readException()
-            val result = reply.readInt()
-            AppLogger.d(TAG, "  ELK GET TX=0x${txCode.toString(16)} = $result")
-            result
-        } catch (e: Exception) {
-            AppLogger.d(TAG, "  ELK GET TX=0x${txCode.toString(16)} exc: ${e.message}")
-            -1
-        } finally {
-            data.recycle()
-            reply.recycle()
-        }
-    }
-
-    /**
-     * SET via IVehicleSettingService binder — layout smali :
-     *   data : [writeInterfaceToken, writeInt(value)]
-     *   transact(code, data, null, FLAG_ONEWAY=1)
-     */
-    private fun elkBinderSet(txCode: Int, value: Int): Boolean {
-        val binder = sVehicleBinder ?: run {
-            AppLogger.d(TAG, "  ELK SET TX=0x${txCode.toString(16)} — sVehicleBinder null")
-            return false
-        }
-        val data = Parcel.obtain()
-        return try {
-            data.writeInterfaceToken(DESCRIPTOR_VEHICLE)
-            data.writeInt(value)
-            binder.transact(txCode, data, null, IBinder.FLAG_ONEWAY)
-            AppLogger.i(TAG, "  ELK SET TX=0x${txCode.toString(16)} value=$value ✓")
-            true
-        } catch (e: Exception) {
-            AppLogger.d(TAG, "  ELK SET TX=0x${txCode.toString(16)} exc: ${e.message}")
-            false
-        } finally {
-            data.recycle()
-        }
-    }
-
-    /**
-     * GET via IVehicleSettingService SWI132 (DESCRIPTOR_VSM132, two-way flag=0x0).
-     * Retourne la valeur entière lue, ou -1 en cas d'erreur.
-     */
-    private fun swi132BinderGet(txCode: Int): Int {
-        val binder = sVehicleBinder ?: run {
-            AppLogger.d(TAG, "  SWI132 GET TX=0x${txCode.toString(16)} — sVehicleBinder null")
-            return -1
-        }
-        val data  = Parcel.obtain()
-        val reply = Parcel.obtain()
-        return try {
-            data.writeInterfaceToken(DESCRIPTOR_VSM132)
-            val ok = binder.transact(txCode, data, reply, 0)
-            if (!ok) {
-                AppLogger.d(TAG, "  SWI132 GET TX=0x${txCode.toString(16)} — transact false")
-                return -1
-            }
-            reply.readException()
-            val result = reply.readInt()
-            AppLogger.d(TAG, "  SWI132 GET TX=0x${txCode.toString(16)} = $result")
-            result
-        } catch (e: Exception) {
-            AppLogger.d(TAG, "  SWI132 GET TX=0x${txCode.toString(16)} exc: ${e.message}")
-            -1
-        } finally {
-            data.recycle()
-            reply.recycle()
-        }
-    }
-
-    /**
-     * SET via IVehicleSettingService SWI132 (DESCRIPTOR_VSM132, two-way flag=0x0).
-     * Différent de elkBinderSet : utilise le bon DESCRIPTOR et flag two-way.
-     */
-    private fun swi132BinderSet(txCode: Int, value: Int): Boolean {
-        val binder = sVehicleBinder ?: run {
-            AppLogger.d(TAG, "  SWI132 SET TX=0x${txCode.toString(16)} — sVehicleBinder null")
-            return false
-        }
-        val data  = Parcel.obtain()
-        val reply = Parcel.obtain()
-        return try {
-            data.writeInterfaceToken(DESCRIPTOR_VSM132)
-            data.writeInt(value)
-            binder.transact(txCode, data, reply, 0)
-            reply.readException()
-            AppLogger.i(TAG, "  SWI132 SET TX=0x${txCode.toString(16)} value=$value ✓")
-            true
-        } catch (e: Exception) {
-            AppLogger.d(TAG, "  SWI132 SET TX=0x${txCode.toString(16)} exc: ${e.message}")
-            false
-        } finally {
-            data.recycle()
-            reply.recycle()
-        }
-    }
-
-    // -------------------------------------------------------------------------
-    // TSR — Reconnaissance des panneaux de vitesse
-    // -------------------------------------------------------------------------
-
-    fun isTsrOn(): Boolean = when {
-        FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132 ->
-            // Priorité CarVehicleSettingClient (binder vehiclesetting bloqué SELinux)
-            // Convention identique SWI69/SWI131 : 0=ON, 1=OFF
-            (callVsm("getSLIFWarningState") as? Int)?.let { raw ->
-                AppLogger.d(TAG, "  SWI132 TSR GET via VSM → $raw")
-                raw == 0
-            } ?: (swi132BinderGet(VSM132_TX_GET_SLIF) == 1)  // fallback binder (rarement accessible)
-        FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI133 ->
-            getIntPropertyVpm(PROP_TSR_MODE) > 0
-        FirmwareInfo.isNewGenVsm() ->   // SWI69 + SWI131 — convention inversée : 0=ON, 1=OFF
-            (callVsm("getSLIFWarningState") as? Int) == 0
-        FirmwareInfo.isVsmBased() ->    // SWI68 + SWI165
-            (callVsm("getSpeedAsstSlifWarning") as? Int) == 1
-        else -> false
-    }
-
-    fun setTsrMode(enabled: Boolean): Boolean {
-        AppLogger.i(TAG, "setTsrMode → $enabled")
-        return when {
-            FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132 -> {
-                // Priorité CarVehicleSettingClient — setSLIFWarningState(I)V confirmé dans smali SWI132
-                // Convention identique SWI69/SWI131 : 0=activer, 1=désactiver
-                if (callVsmVoid("setSLIFWarningState", if (enabled) 0 else 1)) {
-                    AppLogger.i(TAG, "  SWI132 TSR → VSM OK")
-                    true
-                } else {
-                    // Fallback binder direct (bloqué SELinux sur la plupart des builds SWI132)
-                    AppLogger.w(TAG, "  SWI132 TSR: VSM failed — essai binder TX 0x057")
-                    swi132BinderSet(VSM132_TX_SLIF_WARNING, if (enabled) 1 else 0)
-                }
-            }
-            FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI133 -> {
-                // SWI133 : le firmware remet OVERSPEED et SPEED_TONE à ON quand le SLIF est réactivé
-                // → on sauvegarde avant et on restaure après.
-                val prefs = sAppContext?.getSharedPreferences("mg4_settings", 0)
-                if (!enabled) {
-                    val overspeedOn = isOverspeedAlarmOn()
-                    val speedToneOn = isSpeedLimitToneOn()
-                    prefs?.edit()
-                        ?.putBoolean("tsr_saved_overspeed", overspeedOn)
-                        ?.putBoolean("tsr_saved_speed_tone", speedToneOn)
-                        ?.apply()
-                    AppLogger.i(TAG, "  TSR OFF — sauvegarde overspeed=$overspeedOn speedTone=$speedToneOn")
-                }
-                val ok = setIntPropertyVpmRecovery(PROP_TSR_MODE, if (enabled) 1 else 0)
-                if (enabled && ok) {
-                    Thread.sleep(400)
-                    val savedOverspeed = prefs?.getBoolean("tsr_saved_overspeed", true) ?: true
-                    val savedSpeedTone = prefs?.getBoolean("tsr_saved_speed_tone", true) ?: true
-                    AppLogger.i(TAG, "  TSR ON — restauration overspeed=$savedOverspeed speedTone=$savedSpeedTone")
-                    setOverspeedAlarm(savedOverspeed)
-                    setSpeedLimitTone(savedSpeedTone)
-                }
-                ok
-            }
-            FirmwareInfo.isNewGenVsm() -> {   // SWI69 + SWI131 — convention inversée : 0=activer, 1=désactiver
-                // setSLIFWarningState(I)V est void → callVsmVoid()
-                callVsmVoid("setSLIFWarningState", if (enabled) 0 else 1)
-            }
-            FirmwareInfo.isVsmBased() -> {    // SWI68 + SWI165
-                // L'avertissement sonore pourrait être remis à ON lors de la réactivation du TSR
-                // → on sauvegarde avant et on restaure après.
-                val prefs = sAppContext?.getSharedPreferences("mg4_settings", 0)
-                if (!enabled) {
-                    val soundOn = isSoundWarningOn()
-                    prefs?.edit()?.putBoolean("tsr_saved_sound_warning", soundOn)?.apply()
-                    AppLogger.i(TAG, "  TSR OFF — sauvegarde soundWarning=$soundOn")
-                }
-                // setSpeedAsstSlifWarning(I)V est void → callVsmVoid()
-                if (!callVsmVoid("setSpeedAsstSlifWarning", if (enabled) 1 else 0)) return false
-                if (enabled) {
-                    Thread.sleep(400)
-                    val savedSound = prefs?.getBoolean("tsr_saved_sound_warning", true) ?: true
-                    AppLogger.i(TAG, "  TSR ON — restauration soundWarning=$savedSound")
-                    setSoundWarning(savedSound)
-                }
-                true
-            }
-            else -> false
-        }
-    }
-
-    /**
-     * SWI133 : retourne (overspeed, speedTone) tels que sauvegardés lors du dernier TSR OFF.
-     * Utilisé par l'UI pour mettre à jour les switches après la réactivation du TSR, sans
-     * relire le hardware (le VPM a une latence de propagation qui renverrait encore ON
-     * pendant ~500–1000ms après les écritures internes de setTsrMode).
-     */
-    fun savedTsrAlerts(): Pair<Boolean, Boolean> {
-        val prefs = sAppContext?.getSharedPreferences("mg4_settings", 0)
-        return Pair(
-            prefs?.getBoolean("tsr_saved_overspeed",  true) ?: true,
-            prefs?.getBoolean("tsr_saved_speed_tone", true) ?: true
-        )
-    }
-
-    // -------------------------------------------------------------------------
-    // Économie d'énergie (Endurance Mode)
-    // -------------------------------------------------------------------------
-
-    fun isEnergySavingOn(): Boolean = when {
-        FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI133 ->
-            getIntPropertyVpm(PROP_ENERGY_SAVING) == 1
-        FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132 ->  // SWI69 + SWI131 + SWI132
-            (callVsm("getEnduranceMode") as? Int) == 1
-        FirmwareInfo.isVsmBased() ->        // SWI68 + SWI165
-            (callVsm("getLongerEndurance") as? Int) == 1
-        else -> false
-    }
-
-    fun setEnergySavingMode(enabled: Boolean): Boolean {
-        AppLogger.i(TAG, "setEnergySavingMode → $enabled")
-        return when {
-            FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI133 ->
-                setIntPropertyVpmRecovery(PROP_ENERGY_SAVING, if (enabled) 1 else 0)
-            FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132 -> {  // SWI69 + SWI131 + SWI132
-                // setEnduranceMode(I)V est void → callVsmVoid()
-                callVsmVoid("setEnduranceMode", if (enabled) 1 else 0)
-            }
-            FirmwareInfo.isVsmBased() -> {   // SWI68 + SWI165
-                // setLongerEndurance(I)V est void → callVsmVoid()
-                callVsmVoid("setLongerEndurance", if (enabled) 1 else 0)
-            }
-            else -> false
-        }
-    }
-
-    fun isKatman4Ready(): Boolean =
-        if (FirmwareInfo.isVsmBased()) sVsm != null && sVsmService != null
-        else                           sVpm != null && sVpmService != null
-    fun isKatman4VpmCreated(): Boolean      = sVpm != null || sVsm != null
-    fun isCarPropertyManagerReady(): Boolean = sCarPropertyManager != null
-    fun isCarHvacManagerReady(): Boolean     = sCarHvacManager != null
-
-    // -------------------------------------------------------------------------
-    // IGNITION_STATE — CarPropertyManager callback (standard AAOS, tous firmwares)
-    // -------------------------------------------------------------------------
-
-    /**
-     * Enregistre un CarPropertyEventCallback sur PROP_IGNITION_STATE via réflexion.
-     * Protégé par [sIgnitionCallbackRegistered] — ne s'exécute qu'une seule fois.
-     * Lit l'état courant immédiatement après l'enregistrement : CPM ne notifie que sur changement,
-     * donc si la voiture est déjà READY au moment du bind, aucun event ne serait reçu sans cette lecture.
-     */
-    private fun registerIgnitionPropertyCallback() {
-        if (sIgnitionCallbackRegistered) return
-        val cpm = sCarPropertyManager ?: return
-        try {
-            val allRegMethods = cpm.javaClass.methods
-                .filter { it.name == "registerCallback" }
-                .joinToString(" | ") { m ->
-                    "(${m.parameterTypes.joinToString(",") { it.simpleName }})"
-                }
-            AppLogger.i(TAG, "  IGNITION: CPM.registerCallback variants: $allRegMethods")
-
-            val registerMethod = cpm.javaClass.methods.firstOrNull { m ->
-                m.name == "registerCallback" && m.parameterCount == 3
-            } ?: run {
-                AppLogger.w(TAG, "  IGNITION: NO 3-param registerCallback! Available: $allRegMethods")
-                return
-            }
-
-            val callbackType = registerMethod.parameterTypes[0]
-            AppLogger.i(TAG, "  IGNITION: callbackType=${callbackType.simpleName} isInterface=${callbackType.isInterface}")
-
-            if (!callbackType.isInterface) {
-                AppLogger.w(TAG, "  IGNITION: ${callbackType.name} NOT interface — proxy impossible")
-                return
-            }
-
-            val proxy = java.lang.reflect.Proxy.newProxyInstance(
-                callbackType.classLoader, arrayOf(callbackType)
-            ) { _, method, args ->
-                if (method.name == "onChangeEvent" && args != null) {
-                    val cpv = args[0] ?: return@newProxyInstance null
-                    try {
-                        val value = cpv.javaClass.getMethod("getValue").invoke(cpv) as? Int
-                        if (value != null) {
-                            AppLogger.i(TAG, "IGNITION_STATE event → $value (${ignitionStateName(value)})")
-                            dispatchIgnitionState(value)
-                        } else {
-                            AppLogger.w(TAG, "  IGNITION: onChangeEvent getValue() retourné null")
-                        }
-                    } catch (e: Exception) {
-                        AppLogger.w(TAG, "  IGNITION: onChangeEvent parse error: ${e.message}")
-                    }
-                } else if (method.name == "onErrorEvent") {
-                    AppLogger.w(TAG, "  IGNITION: onErrorEvent args=${args?.joinToString()}")
-                }
-                null
-            }
-
-            sIgnitionCallbackProxy = proxy   // référence forte pour éviter le GC
-            registerMethod.invoke(cpm, proxy, PROP_IGNITION_STATE, 0f)
-            sIgnitionCallbackRegistered = true
-            AppLogger.i(TAG, "  IGNITION_STATE callback registered ✓ (propId=0x${PROP_IGNITION_STATE.toString(16)})")
-
-            // Lecture immédiate de l'état courant
-            Handler(Looper.getMainLooper()).postDelayed({
-                val currentState = getCurrentIgnitionState()
-                AppLogger.i(TAG, "  IGNITION: état initial lu = $currentState (${ignitionStateName(currentState)})")
-                if (currentState > 0) {
-                    dispatchIgnitionState(currentState)
-                }
-            }, 300L)
-
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  IGNITION: registerCallback error: ${e.javaClass.simpleName}: ${e.message}")
-        }
-    }
-
-    private fun dispatchIgnitionState(state: Int) {
-        val toNotify = ignitionCallbacks.toList()
-        if (toNotify.isEmpty()) return
-        Handler(Looper.getMainLooper()).post { toNotify.forEach { it(state) } }
-    }
-
-    private fun ignitionStateName(state: Int) = when (state) {
-        IgnitionState.ON        -> "ON/READY"
-        IgnitionState.OFF       -> "OFF"
-        IgnitionState.ACC       -> "ACC"
-        IgnitionState.LOCK      -> "LOCK"
-        IgnitionState.START     -> "START"
-        IgnitionState.UNDEFINED -> "UNDEFINED"
-        else                    -> "?"
-    }
-
-    // -------------------------------------------------------------------------
-    // Katman5 SWI69/SWI131 — ICarGeneralService via CarAdapterClient (queryClient(0x1))
-    // -------------------------------------------------------------------------
-
-    private data class Swi69Ctx(
-        val ctx: Context,
-        val adapterClass: Class<*>,
-        val generalClientClass: Class<*>
-    )
-
-    private fun findSwi69Classes(context: Context): Swi69Ctx? {
-        for (pkg in listOf(LAUNCHER69_PKG, VEHICLE_SETTING_PKG)) {
-            try {
-                val ctx = context.createPackageContext(
-                    pkg,
-                    android.content.Context.CONTEXT_INCLUDE_CODE or android.content.Context.CONTEXT_IGNORE_SECURITY
-                )
-                return Swi69Ctx(
-                    ctx,
-                    ctx.classLoader.loadClass(CAR_ADAPTER_CLASS),
-                    ctx.classLoader.loadClass(CAR_GENERAL_CLIENT_CLASS)
-                )
-            } catch (_: Exception) {}
-        }
-        return null
-    }
-
-    private fun initKatman5Swi69(context: Context) {
-        if (sVcmCallbackRegistered) return
-
-        val classes = findSwi69Classes(context) ?: run {
-            AppLogger.w(TAG, "  Katman5 SWI69: CarAdapterClient/CarGeneralClient introuvable — retry in 10s")
-            Handler(Looper.getMainLooper()).postDelayed({ initKatman5Swi69(context.applicationContext) }, 10_000)
-            return
-        }
-        val (_, adapterClass, generalClientClass) = classes
-        AppLogger.i(TAG, "  Katman5 SWI69: classes chargées ✓")
-
-        fun trySetupGeneralClient(): Boolean {
-            if (sVcmCallbackRegistered) return true
-
-            val adapter = try {
-                adapterClass.getMethod("getInstance", Context::class.java)
-                    .invoke(null, context.applicationContext)
-            } catch (_: Exception) { null } ?: return false
-
-            val ibinder = try {
-                adapterClass.getMethod("queryClient", Int::class.javaPrimitiveType!!)
-                    .invoke(adapter, BIND_CODE_CAR_GENERAL) as? IBinder
-            } catch (_: Exception) { null } ?: run {
-                AppLogger.d(TAG, "  Katman5 SWI69: queryClient(0x${BIND_CODE_CAR_GENERAL.toString(16)}) → null")
-                return false
-            }
-
-            val client = try {
-                generalClientClass.getConstructor(IBinder::class.java).newInstance(ibinder)
-            } catch (e: Exception) {
-                AppLogger.w(TAG, "  Katman5 SWI69: CarGeneralClient ctor error: ${e.message}")
-                return false
-            }
-            sCarGeneral = client   // conservé pour la luminosité écran A9 (setScreenBrightness)
-
-            val registMethod = generalClientClass.methods.firstOrNull {
-                it.name == "registListener" && it.parameterCount == 1
-            } ?: run {
-                AppLogger.w(TAG, "  Katman5 SWI69: registListener non trouvé")
-                return false
-            }
-
-            val callbackType = registMethod.parameterTypes[0]
-            if (!callbackType.isInterface) {
-                AppLogger.w(TAG, "  Katman5 SWI69: callback non-interface — proxy impossible")
-                return false
-            }
-
-            // Binder réel nécessaire pour l'enregistrement cross-process via AIDL.
-            // ICarGeneralService est dans un processus distant (com.saicmotor.caradapter) :
-            // registListener() appelle writeStrongBinder(callback.asBinder()) — un proxy qui
-            // retourne null pour asBinder() transmettrait un binder null au service, qui ne
-            // pourrait jamais rappeler. On crée donc un Binder concret qui implémente onTransact
-            // pour le code 0x7 (TRANSACTION_onIgnitionStateChange, identique sur SWI69 et SWI131).
-            val callbackBinder = object : android.os.Binder() {
-                override fun onTransact(
-                    code: Int, data: android.os.Parcel,
-                    reply: android.os.Parcel?, flags: Int
-                ): Boolean {
-                    return when (code) {
-                        0x7 -> { // TRANSACTION_onIgnitionStateChange
-                            data.enforceInterface("com.saicmotor.carapi.general.ICarGeneralCallback")
-                            val ignition = data.readInt()
-                            AppLogger.i(TAG, "  Katman5 SWI69: onTransact ignition=$ignition (${carIgnitionName(ignition)})")
-                            dispatchVehicleConditionIgnition(ignition)
-                            reply?.writeNoException()
-                            true
-                        }
-                        else -> super.onTransact(code, data, reply, flags)
-                    }
-                }
-            }
-
-            val proxy = try {
-                java.lang.reflect.Proxy.newProxyInstance(
-                    callbackType.classLoader, arrayOf(callbackType)
-                ) { _, method, args ->
-                    when (method.name) {
-                        "onIgnitionStateChange" -> {
-                            // Chemin in-process (rare) — le service appelle directement l'interface
-                            val ignition = args?.get(0) as? Int
-                            if (ignition != null) {
-                                AppLogger.i(TAG, "  Katman5 SWI69: ignition=$ignition (${carIgnitionName(ignition)})")
-                                dispatchVehicleConditionIgnition(ignition)
-                            }
-                        }
-                        "asBinder" -> return@newProxyInstance callbackBinder
-                    }
-                    null
-                }
-            } catch (e: Exception) {
-                AppLogger.w(TAG, "  Katman5 SWI69: proxy creation error: ${e.message}")
-                return false
-            }
-
-            return try {
-                registMethod.invoke(client, proxy)
-                sVcmListener = callbackBinder  // référence forte sur le Binder pour éviter le GC
-                sVcmCallbackRegistered = true
-                AppLogger.i(TAG, "  Katman5 SWI69: ICarGeneralCallback enregistré ✓")
-
-                val toNotify = katman5ReadyListeners.toList()
-                katman5ReadyListeners.clear()
-                Handler(Looper.getMainLooper()).post { toNotify.forEach { it() } }
-
-                Handler(Looper.getMainLooper()).postDelayed({
-                    try {
-                        val ignition = generalClientClass.getMethod("getIgnitionState").invoke(client) as? Int
-                        if (ignition != null) {
-                            AppLogger.i(TAG, "  Katman5 SWI69: état initial ignition=$ignition")
-                            dispatchVehicleConditionIgnition(ignition)
-                        }
-                    } catch (e: Exception) {
-                        AppLogger.d(TAG, "  Katman5 SWI69: getIgnitionState error: ${e.message}")
-                    }
-                }, 500L)
-
-                true
-            } catch (e: Exception) {
-                AppLogger.w(TAG, "  Katman5 SWI69: registListener error: ${e.message}")
-                false
-            }
-        }
-
-        if (!trySetupGeneralClient()) {
-            val h = Handler(Looper.getMainLooper())
-            listOf(2_000L, 5_000L, 10_000L, 20_000L, 30_000L, 60_000L).forEach { delay ->
-                h.postDelayed({ if (!sVcmCallbackRegistered) trySetupGeneralClient() }, delay)
-            }
-        }
-    }
-
-    // -------------------------------------------------------------------------
-    // Katman5 — VehicleConditionManager (IVehicleConditionService via IHubService)
-    // SWI133 / SWI68 / SWI165
-    // -------------------------------------------------------------------------
-
-    private fun initKatman5(context: Context) {
-        if (sVcmCallbackRegistered) return
-
-        val launcherCtx = listOf(LAUNCHER68_PKG, LAUNCHER69_PKG).firstNotNullOfOrNull { pkg ->
-            try {
-                context.createPackageContext(
-                    pkg,
-                    android.content.Context.CONTEXT_INCLUDE_CODE or android.content.Context.CONTEXT_IGNORE_SECURITY
-                )
-            } catch (_: Exception) { null }
-        } ?: run {
-            AppLogger.w(TAG, "  Katman5: launcher package introuvable")
-            return
-        }
-
-        val vcmClass = try {
-            launcherCtx.classLoader.loadClass(VCM_CLASS)
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  Katman5: classe VCM non trouvée: ${e.message} — retry in 10s")
-            Handler(Looper.getMainLooper()).postDelayed({ initKatman5(context.applicationContext) }, 10_000)
-            return
-        }
-
-        // Tentative 1 : singleton déjà initialisé par le launcher
-        val existing = try {
-            val f = vcmClass.getDeclaredField("sVehicleConditionManager")
-            f.isAccessible = true
-            f.get(null)
-        } catch (_: Exception) { null }
-
-        if (existing != null) {
-            AppLogger.i(TAG, "  Katman5: singleton VCM déjà existant ✓")
-            sVcm = existing
-            setupVcmCallback(existing, launcherCtx)
-            return
-        }
-
-        // Tentative 2 : appeler init(Context, IVehicleServiceListener)
-        val initMethod = vcmClass.methods.firstOrNull { m ->
-            m.name == "init" && m.parameterCount == 2 &&
-            Context::class.java.isAssignableFrom(m.parameterTypes[0])
-        }
-
-        if (initMethod != null) {
-            val listenerType = initMethod.parameterTypes[1]
-            val listenerArg: Any? = if (listenerType.isInterface) {
-                try {
-                    java.lang.reflect.Proxy.newProxyInstance(
-                        listenerType.classLoader, arrayOf(listenerType)
-                    ) { _, method, args ->
-                        when (method.name) {
-                            "onServiceConnected" -> {
-                                AppLogger.i(TAG, "  Katman5: onServiceConnected ✓")
-                                val mgr = args?.getOrNull(0)
-                                    ?.takeIf { it.javaClass.name.contains("VehicleConditionManager") }
-                                val instance = mgr ?: try {
-                                    val f = vcmClass.getDeclaredField("sVehicleConditionManager")
-                                    f.isAccessible = true
-                                    f.get(null)
-                                } catch (_: Exception) { null }
-                                if (instance != null) {
-                                    sVcm = instance
-                                    setupVcmCallback(instance, launcherCtx)
-                                }
-                            }
-                            "onServiceDisconnected" -> {
-                                AppLogger.w(TAG, "  Katman5: onServiceDisconnected")
-                                sVcmCallbackRegistered = false
-                                sVcmListener = null
-                            }
-                        }
-                        null
-                    }
-                } catch (e: Exception) {
-                    AppLogger.d(TAG, "  Katman5: proxy init error: ${e.message}")
-                    null
-                }
-            } else null
-
-            try {
-                initMethod.invoke(null, context.applicationContext, listenerArg)
-                AppLogger.i(TAG, "  Katman5: VehicleConditionManager.init() called")
-            } catch (e: Exception) {
-                AppLogger.w(TAG, "  Katman5: init() error: ${e.message}")
-            }
-        } else {
-            AppLogger.w(TAG, "  Katman5: init(Context, listener) non trouvé")
-        }
-
-        // Retries — singleton disponible après connexion asynchrone
-        val h = Handler(Looper.getMainLooper())
-        listOf(2_000L, 5_000L, 10_000L, 20_000L, 30_000L, 60_000L).forEach { delay ->
-            h.postDelayed({
-                if (!sVcmCallbackRegistered) {
-                    val mgr = try {
-                        val f = vcmClass.getDeclaredField("sVehicleConditionManager")
-                        f.isAccessible = true
-                        f.get(null)
-                    } catch (_: Exception) { null }
-                    if (mgr != null && sVcm == null) {
-                        AppLogger.i(TAG, "  Katman5: singleton récupéré @${delay}ms")
-                        sVcm = mgr
-                        setupVcmCallback(mgr, launcherCtx)
-                    } else if (sVcm != null && !sVcmCallbackRegistered) {
-                        setupVcmCallback(sVcm!!, launcherCtx)
-                    }
-                }
-            }, delay)
-        }
-    }
-
-    private fun setupVcmCallback(vcm: Any, launcherCtx: Context) {
-        if (sVcmCallbackRegistered) return
-
-        val registerMethod = vcm.javaClass.methods.firstOrNull { m ->
-            m.name == "registerVehicleConditionCallback" && m.parameterCount == 1
-        } ?: vcm.javaClass.methods.firstOrNull { m ->
-            m.name.startsWith("register") && m.parameterCount == 1 &&
-            m.parameterTypes[0].isInterface &&
-            m.parameterTypes[0].methods.any { it.name.contains("ConditionChange", ignoreCase = true) }
-        } ?: run {
-            AppLogger.w(TAG, "  Katman5: registerVehicleConditionCallback non trouvé — méthodes: ${
-                vcm.javaClass.methods.filter { it.name.startsWith("register") }.joinToString { it.name }
-            }")
-            return
-        }
-
-        val callbackType = registerMethod.parameterTypes[0]
-        AppLogger.i(TAG, "  Katman5: callback type = ${callbackType.name}")
-
-        val proxy = try {
-            java.lang.reflect.Proxy.newProxyInstance(
-                callbackType.classLoader, arrayOf(callbackType)
-            ) { _, method, args ->
-                if (method.name.contains("ChangeEvent", ignoreCase = true) && args != null) {
-                    val bean = args[0] ?: return@newProxyInstance null
-                    try {
-                        val ignition = bean.javaClass.getMethod("getVehicleIgnition").invoke(bean) as? Int
-                        if (ignition != null) {
-                            AppLogger.i(TAG, "  Katman5 event: ignition=$ignition (${carIgnitionName(ignition)})")
-                            dispatchVehicleConditionIgnition(ignition)
-                        }
-                    } catch (e: Exception) {
-                        AppLogger.w(TAG, "  Katman5: onChangeEvent parse error: ${e.message}")
-                    }
-                }
-                null
-            }
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  Katman5: proxy creation error: ${e.message}")
-            return
-        }
-
-        try {
-            registerMethod.invoke(vcm, proxy)
-            sVcmListener = proxy
-            sVcmCallbackRegistered = true
-            AppLogger.i(TAG, "  Katman5: callback enregistré ✓")
-
-            val toNotify = katman5ReadyListeners.toList()
-            katman5ReadyListeners.clear()
-            Handler(Looper.getMainLooper()).post { toNotify.forEach { it() } }
-
-            // Lecture immédiate (le callback ne se déclenche que sur CHANGEMENT)
-            Handler(Looper.getMainLooper()).postDelayed({
-                val ignition = try {
-                    vcm.javaClass.getMethod("getVehicleIgnition").invoke(vcm) as? Int
-                } catch (_: Exception) { null }
-                if (ignition != null) {
-                    AppLogger.i(TAG, "  Katman5: état initial = $ignition (${carIgnitionName(ignition)})")
-                    dispatchVehicleConditionIgnition(ignition)
-                }
-            }, 500L)
-
-        } catch (e: Exception) {
-            AppLogger.w(TAG, "  Katman5: registerVehicleConditionCallback error: ${e.message}")
-        }
-    }
-
-    private fun dispatchVehicleConditionIgnition(state: Int) {
-        // Ne dispatcher que si l'état change réellement — évite les faux RUN répétés
-        // que VehicleConditionManager envoie à chaque changement de condition véhicule
-        // (changement de rapport D/N/R, etc.) alors que la voiture est déjà en RUN.
-        if (state == sLastVcmIgnitionState) return
-        sLastVcmIgnitionState = state
-        val toNotify = vehicleConditionCallbacks.toList()
-        if (toNotify.isEmpty()) return
-        Handler(Looper.getMainLooper()).post { toNotify.forEach { it(state) } }
-    }
-
-    private fun carIgnitionName(state: Int) = when (state) {
-        CarIgnitionItem.OFF       -> "OFF"
-        CarIgnitionItem.ACCESSORY -> "ACC"
-        CarIgnitionItem.RUN       -> "RUN/READY"
-        CarIgnitionItem.CRANK     -> "CRANK"
-        else                      -> "?(${state})"
-    }
-
-    // -------------------------------------------------------------------------
-    // Listener management
-    // -------------------------------------------------------------------------
-
-    fun setDriveModeListener(listener: DriveModeListener?) { sDriveModeListener = listener }
-    fun setHvacListener(listener: HvacListener?) { sHvacListener = listener }
-
-    // -------------------------------------------------------------------------
-    // Diagnostic
-    // -------------------------------------------------------------------------
-
-    /** Retourne true si le binder IVehicleSettingService est disponible. */
-    fun isVehicleBinderAvailable(): Boolean = sVehicleBinder != null
-
-    /**
-     * Génère un rapport de diagnostic complet :
-     * état des services, tests binder SWI132 en temps réel, dump AppLogger.
-     * À appeler sur Dispatchers.IO (les TX binder sont bloquants).
-     */
-    fun buildDiagnosticReport(appVersion: String): String {
-        val sb  = StringBuilder()
-        val gen = FirmwareInfo.getGeneration()
-        val sdf = java.text.SimpleDateFormat("HH:mm:ss", java.util.Locale.getDefault())
-        val now = sdf.format(java.util.Date())
-
-        sb.appendLine("══ MG4Control — Diagnostic ══")
-        sb.appendLine("Generated : $now")
-        sb.appendLine("App       : v$appVersion")
-        sb.appendLine("Firmware  : ${gen.name}")
-        sb.appendLine()
-
-        sb.appendLine("── Services ──")
-        sb.appendLine("Katman1 CPM  : ${if (sCarPropertyManager != null) "✓" else "✗"}")
-        sb.appendLine("Katman1 HVAC : ${if (sCarHvacManager    != null) "✓" else "✗"}")
-        sb.appendLine("Katman4 créé : ${if (isKatman4VpmCreated())      "✓" else "✗"}")
-        sb.appendLine("Katman4 prêt : ${if (isKatman4Ready())           "✓" else "✗"}")
-        sb.appendLine("Binder vsett : ${if (sVehicleBinder    != null) "✓ OK" else "✗ null"}")
-        val katman5Path = if (FirmwareInfo.isNewGenVsm() || gen == FirmwareInfo.Gen.SWI132)
-            "ICarGeneralService" else "VehicleConditionMgr"
-        sb.appendLine("Katman5 prêt : ${if (sVcmCallbackRegistered) "✓ ($katman5Path)" else "✗ ($katman5Path)"}")
-        sb.appendLine("Katman5 ign  : ${carIgnitionName(sLastVcmIgnitionState)} ($sLastVcmIgnitionState)")
-        sb.appendLine()
-
-        if (gen == FirmwareInfo.Gen.SWI132) {
-
-            // ── Binder IVehicleSettingService ─────────────────────────────
-            sb.appendLine("── SWI132 Binder (IVehicleSettingService) ──")
-            val binderOk = sVehicleBinder != null
-            sb.appendLine("Binder présent   : ${if (binderOk) "✓" else "✗ null → toutes alertes KO"}")
-            if (binderOk) {
-                val alive = try { sVehicleBinder!!.pingBinder() } catch (_: Exception) { false }
-                sb.appendLine("pingBinder       : ${if (alive) "✓ vivant" else "✗ mort"}")
-                val actualDesc = try { sVehicleBinder!!.interfaceDescriptor ?: "null" }
-                                 catch (_: Exception) { "exception" }
-                sb.appendLine("Descriptor attendu : $DESCRIPTOR_VSM132")
-                sb.appendLine("Descriptor réel    : $actualDesc${
-                    if (actualDesc == DESCRIPTOR_VSM132) " ✓" else " ← MISMATCH !"}")
-            }
-            sb.appendLine()
-
-            // ── Alertes — lecture brute + interprétation ──────────────────
-            fun fmtRaw(raw: Int, onVal: Int = 1): String = when {
-                raw < 0  -> "$raw ← ERREUR (SELinux ? binder mort ?)"
-                raw == onVal -> "$raw → ON ✓"
-                raw == 0 -> "$raw → OFF"
-                else     -> "$raw → ?"
-            }
-
-            sb.appendLine("── SWI132 Alertes (GET) ──")
-            val rawOverspeed  = swi132BinderGet(VSM132_TX_GET_OVERSPEED)
-            val rawSlif       = swi132BinderGet(VSM132_TX_GET_SLIF)
-            val rawSpeedLimit = swi132BinderGet(VSM132_TX_GET_SPEED_LIMIT)
-            sb.appendLine("getOverSpeedSoundMode  (0x129) : ${fmtRaw(rawOverspeed)}")
-            sb.appendLine("getSLIFWarningState    (0x058) : ${fmtRaw(rawSlif)}")
-            sb.appendLine("getSpeedLimitSoundMode (0x12b) : ${fmtRaw(rawSpeedLimit)}")
-            sb.appendLine()
-
-            // ── Alertes — test SET aller-retour (écrit la valeur courante) ─
-            // Si la valeur brute est lisible (≥ 0), on réécrit la même valeur pour tester
-            // que le SET passe (sans modifier l'état réel de la voiture).
-            sb.appendLine("── SWI132 Alertes (SET round-trip) ──")
-            if (rawOverspeed >= 0) {
-                val setOk = swi132BinderSet(VSM132_TX_OVERSPEED_SOUND, rawOverspeed)
-                val verify = swi132BinderGet(VSM132_TX_GET_OVERSPEED)
-                sb.appendLine("setOverSpeedSoundMode  (0x128) : ${if (setOk) "✓ écrit" else "✗ échec"}" +
-                    " → relecture : ${fmtRaw(verify)}")
-            } else {
-                sb.appendLine("setOverSpeedSoundMode  (0x128) : skip (GET KO)")
-            }
-            if (rawSpeedLimit >= 0) {
-                val setOk = swi132BinderSet(VSM132_TX_SPEED_LIMIT, rawSpeedLimit)
-                val verify = swi132BinderGet(VSM132_TX_GET_SPEED_LIMIT)
-                sb.appendLine("setSpeedLimitSoundMode (0x12a) : ${if (setOk) "✓ écrit" else "✗ échec"}" +
-                    " → relecture : ${fmtRaw(verify)}")
-            } else {
-                sb.appendLine("setSpeedLimitSoundMode (0x12a) : skip (GET KO)")
-            }
-            if (rawSlif >= 0) {
-                val setOk = swi132BinderSet(VSM132_TX_SLIF_WARNING, rawSlif)
-                val verify = swi132BinderGet(VSM132_TX_GET_SLIF)
-                sb.appendLine("setSLIFWarningState    (0x057) : ${if (setOk) "✓ écrit" else "✗ échec"}" +
-                    " → relecture : ${fmtRaw(verify)}")
-            } else {
-                sb.appendLine("setSLIFWarningState    (0x057) : skip (GET KO)")
-            }
-            sb.appendLine()
-
-            // ── CarVehicleSettingClient (Katman4) ─────────────────────────
-            sb.appendLine("── SWI132 CarVehicleSettingClient (sVsm=${if (sVsm != null) "✓" else "✗ null"}) ──")
-            fun vsmGet(method: String): Int = try {
-                (callVsm(method) as? Int) ?: -1
-            } catch (_: Exception) { -1 }
-            fun fmtVsm(v: Int, ok: String) = if (v >= 0) "$v → $ok" else "-1 ← ERREUR (méthode absente ou sVsm null)"
-
-            // ACC/TJA
-            val accTjaRaw = getAccTjaMode()
-            sb.appendLine("getAccTjaState   : ${when (accTjaRaw) {
-                Swi68Mode.OFF -> "4 → OFF"
-                Swi68Mode.ACC -> "1 → ACC"
-                Swi68Mode.TJA -> "2 → TJA"
-                -1            -> "-1 ← ERREUR"
-                else          -> "$accTjaRaw → ?"
-            }}")
-
-            // AEB
-            val fcwRaw = vsmGet("getFcwState")
-            sb.appendLine("getFcwState      : ${when (fcwRaw) {
-                2 -> "2 → AEB ON" ; 1 -> "1 → AEB OFF" ; -1 -> "-1 ← ERREUR" ; else -> "$fcwRaw → ?"
-            }}")
-            val fcwModeRaw = vsmGet("getFcwAutoBrakeMode")
-            sb.appendLine("getFcwAutoBreak  : ${when (fcwModeRaw) {
-                1 -> "1 → Alerte" ; 2 -> "2 → Al.+Frein" ; -1 -> "-1 ← ERREUR" ; else -> "$fcwModeRaw → ?"
-            }}")
-            val fcwSenRaw = vsmGet("getFcwSensitivity")
-            sb.appendLine("getFcwSensitiv.  : ${when (fcwSenRaw) {
-                1 -> "1 → Faible" ; 2 -> "2 → Standard" ; 3 -> "3 → Élevé" ; -1 -> "-1 ← ERREUR" ; else -> "$fcwSenRaw → ?"
-            }}")
-
-            // ELK
-            val lasRaw = vsmGet("getLasMode")
-            sb.appendLine("getLasMode (ELK) : ${when (lasRaw) {
-                1 -> "1 → OFF" ; 2 -> "2 → Alerte" ; 3 -> "3 → Assist" ; 5 -> "5 → Urgence"
-                -1 -> "-1 ← ERREUR" ; else -> "$lasRaw → ?"
-            }}")
-
-            // ── ALERTES via VSM (nouveau path — confirmé dans smali SWI132) ─
-            sb.appendLine()
-            sb.appendLine("── SWI132 Alertes via VSM (ICarVehicleSettingService) ──")
-            val vsmOverspeed = vsmGet("getOverSpeedSoundMode")
-            sb.appendLine("getOverSpeedSoundMode  : ${when {
-                vsmOverspeed < 0  -> "-1 ← ERREUR (méthode absente ?)"
-                vsmOverspeed == 0 -> "0 → OFF"
-                else              -> "$vsmOverspeed → ON"
-            }}")
-            val vsmSpeedLimit = vsmGet("getSpeedLimitSoundMode")
-            sb.appendLine("getSpeedLimitSoundMode : ${when {
-                vsmSpeedLimit < 0  -> "-1 ← ERREUR (méthode absente ?)"
-                vsmSpeedLimit == 0 -> "0 → OFF"
-                else               -> "$vsmSpeedLimit → ON"
-            }}")
-
-            // TSR / SLIF
-            val vsmSlif = vsmGet("getSLIFWarningState")
-            sb.appendLine("getSLIFWarningState    : ${when {
-                vsmSlif < 0 -> "-1 ← ERREUR (méthode absente ?)"
-                vsmSlif == 0 -> "0 → TSR ON (convention SWI69)"
-                vsmSlif == 1 -> "1 → TSR OFF (convention SWI69)"
-                else -> "$vsmSlif → ?"
-            }}")
-
-            // Son d'alerte de voie (LAS)
-            val vsmLasSound = vsmGet("getLasWarningSound")
-            sb.appendLine("getLasWarningSound     : ${when {
-                vsmLasSound < 0 -> "-1 ← ERREUR (méthode absente ?)"
-                vsmLasSound == 2 -> "2 → ON"
-                vsmLasSound == 1 -> "1 → OFF"
-                else -> "$vsmLasSound → ?"
-            }}")
-
-            // Test SET round-trip via VSM (sans modifier l'état réel : on réécrit la valeur courante)
-            sb.appendLine()
-            sb.appendLine("── SWI132 SET round-trip via VSM ──")
-            if (vsmOverspeed >= 0) {
-                val setOk = callVsmVoid("setOverSpeedSoundMode", vsmOverspeed)
-                val verify = vsmGet("getOverSpeedSoundMode")
-                sb.appendLine("setOverSpeedSoundMode  : ${if (setOk) "✓" else "✗"} → relecture : $verify${
-                    if (setOk && verify == vsmOverspeed) " ✓ cohérent" else if (setOk) " ← valeur changée !" else ""}")
-            } else {
-                sb.appendLine("setOverSpeedSoundMode  : skip (GET KO)")
-            }
-            if (vsmSpeedLimit >= 0) {
-                val setOk = callVsmVoid("setSpeedLimitSoundMode", vsmSpeedLimit)
-                val verify = vsmGet("getSpeedLimitSoundMode")
-                sb.appendLine("setSpeedLimitSoundMode : ${if (setOk) "✓" else "✗"} → relecture : $verify${
-                    if (setOk && verify == vsmSpeedLimit) " ✓ cohérent" else if (setOk) " ← valeur changée !" else ""}")
-            } else {
-                sb.appendLine("setSpeedLimitSoundMode : skip (GET KO)")
-            }
-            if (vsmSlif >= 0) {
-                val setOk = callVsmVoid("setSLIFWarningState", vsmSlif)
-                val verify = vsmGet("getSLIFWarningState")
-                sb.appendLine("setSLIFWarningState    : ${if (setOk) "✓" else "✗"} → relecture : $verify${
-                    if (setOk && verify == vsmSlif) " ✓ cohérent" else if (setOk) " ← valeur changée !" else ""}")
-            } else {
-                sb.appendLine("setSLIFWarningState    : skip (GET KO)")
-            }
-
-            // Éco
-            val enduranceRaw = vsmGet("getEnduranceMode")
-            sb.appendLine()
-            sb.appendLine("getEnduranceMode : ${when (enduranceRaw) {
-                1 -> "1 → Éco ON" ; 0 -> "0 → Éco OFF" ; -1 -> "-1 ← ERREUR" ; else -> "$enduranceRaw → ?"
-            }}")
-            sb.appendLine()
-        }
-
-        sb.appendLine("── AppLogger (${AppLogger.entries.size} entrées) ──")
-        AppLogger.entries.forEach { e ->
-            sb.appendLine("[${e.time}] ${e.tag}: ${e.msg}")
-        }
-
-        return sb.toString()
-    }
-
-    // ── Contrôle audio (CarAdapterService vendor SAIC) — A9 uniquement ──────────
-    //
-    // Le service vendor `com.saicmotor.caradapter` (descripteur ICarAudioService)
-    // n'existe QUE sur la famille A9 (SWI69/131/132). Sur old-SDK (SWI133/68/165)
-    // il est absent → on ne tente même pas le bind (cf. hasAudioControl / initAudio).
-    // Codes de transaction vérifiés identiques sur les 3 A9 (ICarAudioService$Stub).
-
-    /** A9 (SWI69/131/132) : loudness via le service vendor caradapter (ICarAudioService). */
-    private fun isA9Sound(): Boolean =
-        FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132
-
-    /** Ancien SDK (SWI133/68/165) : loudness via SmartSoundManager (SDK systemsettings). */
-    private fun isOldSdkSound(): Boolean {
-        val gen = FirmwareInfo.getGeneration()
-        return gen == FirmwareInfo.Gen.SWI133 || gen == FirmwareInfo.Gen.SWI68 || gen == FirmwareInfo.Gen.SWI165
-    }
-
-    /** Onglet Audio (baisse volume à l'ouverture de porte) : uniquement là où c'est fonctionnel. */
-    fun hasAudioControl(): Boolean = hasDoorVolumeFeature()
-
-    private const val DESCRIPTOR_CARADAPTER = "com.saicmotor.carapi.ICarAdapterService"
-    private const val TX_QUERY_AUDIO_CLIENT = 1
-    private const val HELPER_AUDIO_CODE     = 10
-
-    private const val AUDIO_SET_FADER_FRONT   = 12
-    private const val AUDIO_SET_BALANCE_RIGHT = 13
-    private const val AUDIO_SET_SPEED_VOL     = 17
-    private const val AUDIO_GET_SPEED_VOL     = 18
-    private const val AUDIO_SET_3D_EFFECT     = 26
-    private const val AUDIO_GET_3D_EFFECT     = 27
-    private const val AUDIO_SET_SOUND_FIELD   = 30
-    private const val AUDIO_GET_BALANCE       = 31
-    private const val AUDIO_GET_FADER         = 32
-    private const val AUDIO_SET_BOSE_SOUND    = 36
-    private const val AUDIO_GET_BOSE_SOUND    = 37
-    private const val AUDIO_SET_TONE          = 40
-    private const val AUDIO_GET_TONE          = 41
-
-    @Volatile private var sCarAdapterBinder: IBinder? = null
-    @Volatile private var sAudioHelper: IBinder? = null
-    @Volatile private var sAudioDescriptor: String = ""
-    @Volatile private var sAudioServiceConn: ServiceConnection? = null
-
-    val isAudioAvailable: Boolean get() = sAudioHelper?.isBinderAlive == true
-
-    fun initAudio(context: Context) {
-        // Le bind caradapter ne concerne que l'A9. Sur old-SDK, le loudness passe par
-        // SmartSoundManager (initialisé dans le flux Katman4), donc rien à binder ici.
-        if (!isA9Sound()) return
-        if (sAudioHelper?.isBinderAlive == true) return
-        if (sAudioServiceConn != null) return
-        val intent = Intent().apply {
-            setClassName("com.saicmotor.caradapter", "com.saicmotor.caradapter.service.CarAdapterService")
-        }
-        val conn = object : ServiceConnection {
-            override fun onServiceConnected(name: ComponentName?, binder: IBinder?) {
-                sCarAdapterBinder = binder
-                AppLogger.i(TAG, "  Audio: CarAdapterService connecté ✓")
-                CoroutineScope(Dispatchers.IO).launch { tryGetAudioHelper() }
-            }
-            override fun onServiceDisconnected(name: ComponentName?) {
-                sCarAdapterBinder = null; sAudioHelper = null
-            }
-        }
-        sAudioServiceConn = conn
-        try {
-            val bound = context.applicationContext.bindService(intent, conn, Context.BIND_AUTO_CREATE)
-            if (!bound) {
-                sAudioServiceConn = null
-                Handler(Looper.getMainLooper()).postDelayed({ if (sAudioHelper == null) initAudio(context.applicationContext) }, 10_000L)
-            }
-        } catch (e: Exception) { sAudioServiceConn = null; AppLogger.w(TAG, "  Audio: bindService error: ${e.message}") }
-    }
-
-    private fun tryGetAudioHelper() {
-        val svc = sCarAdapterBinder ?: return
-        val data = Parcel.obtain(); val reply = Parcel.obtain()
-        try {
-            data.writeInterfaceToken(DESCRIPTOR_CARADAPTER)
-            data.writeInt(HELPER_AUDIO_CODE)
-            if (svc.transact(TX_QUERY_AUDIO_CLIENT, data, reply, 0)) {
-                reply.readException()
-                val helper = reply.readStrongBinder()
-                if (helper != null && helper.isBinderAlive) {
-                    sAudioHelper = helper; sAudioDescriptor = helper.interfaceDescriptor ?: ""
-                    AppLogger.i(TAG, "  Audio: helper OK descriptor='$sAudioDescriptor'")
-                } else {
-                    Handler(Looper.getMainLooper()).postDelayed({ CoroutineScope(Dispatchers.IO).launch { tryGetAudioHelper() } }, 5_000)
-                }
-            }
-        } finally { data.recycle(); reply.recycle() }
-    }
-
-    private fun audioGet(txCode: Int): Int {
-        val h = sAudioHelper ?: return -1
-        if (!h.isBinderAlive) { sAudioHelper = null; return -1 }
-        val data = Parcel.obtain(); val reply = Parcel.obtain()
-        return try {
-            data.writeInterfaceToken(sAudioDescriptor)
-            if (h.transact(txCode, data, reply, 0)) { reply.readException(); reply.readInt() } else -1
-        } catch (_: Exception) { -1 } finally { data.recycle(); reply.recycle() }
-    }
-
-    private fun audioSet(txCode: Int, value: Int): Boolean {
-        val h = sAudioHelper ?: return false
-        if (!h.isBinderAlive) { sAudioHelper = null; return false }
-        val data = Parcel.obtain(); val reply = Parcel.obtain()
-        return try {
-            data.writeInterfaceToken(sAudioDescriptor)
-            data.writeInt(value)
-            h.transact(txCode, data, reply, 0).also { if (it) reply.readException() }
-        } catch (_: Exception) { false } finally { data.recycle(); reply.recycle() }
-    }
-
-    private const val AUDIO_TYPE_MIN  = 0
-    private const val AUDIO_TYPE_MAX  = 3
-    private const val AUDIO_LEVEL_MIN = -9
-    private const val AUDIO_LEVEL_MAX =  9
-
-    fun getBoseSoundType(): Int              = audioGet(AUDIO_GET_BOSE_SOUND)
-    fun setBoseSoundType(t: Int): Boolean    = audioSet(AUDIO_SET_BOSE_SOUND, t.coerceIn(AUDIO_TYPE_MIN, AUDIO_TYPE_MAX))
-    fun getAudioBalance(): Int               = audioGet(AUDIO_GET_BALANCE)
-    fun setAudioBalance(v: Int): Boolean     = audioSet(AUDIO_SET_BALANCE_RIGHT, v.coerceIn(AUDIO_LEVEL_MIN, AUDIO_LEVEL_MAX))
-    fun getAudioFader(): Int                 = audioGet(AUDIO_GET_FADER)
-    fun setAudioFader(v: Int): Boolean       = audioSet(AUDIO_SET_FADER_FRONT, v.coerceIn(AUDIO_LEVEL_MIN, AUDIO_LEVEL_MAX))
-    // ── Volume média — VOL_TYPE_MEDIA=0 ────────────────────────────────────────
-    // Routage par firmware : old-SDK (133/68/165) → SmartSoundManager (reflection) ;
-    // A9 (69/131/132) → ICarAudioService via binder caradapter (tx getMax=0x5 / getVol=0x6 / setVol=0x7).
-    private const val VOL_TYPE_MEDIA    = 0
-    private const val AUDIO_GET_MAX_VOL = 0x5
-    private const val AUDIO_GET_VOLUME  = 0x6
-    private const val AUDIO_SET_VOLUME  = 0x7
-
-    private const val VOL_TAG = "MG4_VOL"
-
-    /** Max du volume média (borne le slider). -1 si indisponible. */
-    fun getMediaVolumeMax(): Int {
-        val v = when {
-            isOldSdkSound() -> smartSoundGetInt("getMaxVolume", VOL_TYPE_MEDIA)
-            isA9Sound()     -> audioGetArg(AUDIO_GET_MAX_VOL, VOL_TYPE_MEDIA)
-            else            -> -1
-        }
-        AppLogger.i(VOL_TAG, "getMediaVolumeMax = $v  [oldSdk=${isOldSdkSound()} a9=${isA9Sound()} smartSound=${sSmartSound != null} audioHelper=${sAudioHelper != null}]")
-        logMediaVolumeDiag()   // A9 : compare type-0 vs group-id (no-op ailleurs)
-        return v
-    }
-
-    /** Volume média courant. -1 si indisponible. */
-    fun getMediaVolume(): Int {
-        val v = when {
-            isOldSdkSound() -> smartSoundGetInt("getVolume", VOL_TYPE_MEDIA)
-            isA9Sound()     -> audioGetArg(AUDIO_GET_VOLUME, VOL_TYPE_MEDIA)
-            else            -> -1
-        }
-        AppLogger.i(VOL_TAG, "getMediaVolume = $v")
-        return v
-    }
-
-    /** Fixe le volume média. setVolume(type, niveau, flags=0). */
-    fun setMediaVolume(level: Int): Boolean {
-        val ok = when {
-            isOldSdkSound() -> smartSoundSetVolume(level)
-            isA9Sound()     -> audioSet3(AUDIO_SET_VOLUME, VOL_TYPE_MEDIA, level, 0)
-            else            -> false
-        }
-        AppLogger.i(VOL_TAG, "setMediaVolume($level) = $ok")
-        return ok
-    }
-
-    // old-SDK : SmartSoundManager (reflection)
-    private fun smartSoundGetInt(method: String, arg: Int): Int {
-        val m = sSmartSound ?: return -1
-        return try { m.javaClass.getMethod(method, Int::class.javaPrimitiveType).invoke(m, arg) as? Int ?: -1 }
-        catch (_: Exception) { -1 }
-    }
-    private fun smartSoundSetVolume(level: Int): Boolean {
-        val m = sSmartSound ?: return false
-        return try {
-            m.javaClass.getMethod("setVolume", Int::class.javaPrimitiveType, Int::class.javaPrimitiveType, Int::class.javaPrimitiveType)
-                .invoke(m, VOL_TYPE_MEDIA, level, 0); true
-        } catch (e: Exception) { AppLogger.w(TAG, "setMediaVolume oldSdk exc: ${e.message}"); false }
-    }
-
-    // A9 : ICarAudioService via binder. getVolume(usage)/getMaxVolume(usage) = 1 arg ; setVolume(usage,val,flags) = 3 args.
-    private fun audioGetArg(txCode: Int, arg: Int): Int {
-        val h = sAudioHelper ?: return -1
-        if (!h.isBinderAlive) { sAudioHelper = null; return -1 }
-        val data = Parcel.obtain(); val reply = Parcel.obtain()
-        return try {
-            data.writeInterfaceToken(sAudioDescriptor); data.writeInt(arg)
-            if (h.transact(txCode, data, reply, 0)) { reply.readException(); reply.readInt() } else -1
-        } catch (_: Exception) { -1 } finally { data.recycle(); reply.recycle() }
-    }
-    private fun audioSet3(txCode: Int, a: Int, b: Int, c: Int): Boolean {
-        val h = sAudioHelper ?: return false
-        if (!h.isBinderAlive) { sAudioHelper = null; return false }
-        val data = Parcel.obtain(); val reply = Parcel.obtain()
-        return try {
-            data.writeInterfaceToken(sAudioDescriptor); data.writeInt(a); data.writeInt(b); data.writeInt(c)
-            h.transact(txCode, data, reply, 0).also { if (it) reply.readException() }
-        } catch (_: Exception) { false } finally { data.recycle(); reply.recycle() }
-    }
-
-    // Diagnostic A9 : le param de getVolume/getMaxVolume est-il un "type" (0=media) ou un
-    // "group id" (AAOS) ? On logge les deux pour comparer au max réel de la voiture.
-    private const val AUDIO_GET_GROUP_FOR_USAGE = 0xe   // getVolumeGroupIdForUsage(usage)
-    private const val USAGE_MEDIA_AAOS = 1              // AudioAttributes.USAGE_MEDIA
-    fun logMediaVolumeDiag() {
-        if (!isA9Sound()) return
-        val maxT = audioGetArg(AUDIO_GET_MAX_VOL, VOL_TYPE_MEDIA)
-        val volT = audioGetArg(AUDIO_GET_VOLUME,  VOL_TYPE_MEDIA)
-        val grp  = audioGetArg(AUDIO_GET_GROUP_FOR_USAGE, USAGE_MEDIA_AAOS)
-        val maxG = if (grp in 0..64) audioGetArg(AUDIO_GET_MAX_VOL, grp) else -1
-        val volG = if (grp in 0..64) audioGetArg(AUDIO_GET_VOLUME,  grp) else -1
-        AppLogger.i(VOL_TAG, "A9 diag: parType0[max=$maxT vol=$volT]  groupForUsage(MEDIA)=$grp  parGroup[max=$maxG vol=$volG]")
-    }
-
-    // ── Baisse du volume à l'ouverture d'une porte avant (v1 : SWI133) ──────────
-    // Détection via l'API Car AOSP **CarPropertyManager** (service "property") + permission
-    // CAR_VENDOR_EXTENSION (déjà déclarée). IDs portes AVANT confirmés par un utilisateur :
-    // FL/FR "ratio" (taux d'ouverture, >0 = ouverte) + "mode". Le SDK SAIC (getIntProperty)
-    // ne les lisait pas. Poll ~700ms, change-only (log MG4_DOOR), baisse à l'ouverture.
-    // Pas de restauration. Connexion Car async (createCar + ServiceConnection).
-
-    private const val DOORWATCH_TAG = "MG4_DOOR"
-    // Signal d'ouverture confirmé sur SWI133 : DLOCK_DOOR_OPEN_STS (propriété de zone PORTE),
-    // areaId 0x1 = porte AV-gauche, 0x4 = AV-droite ; valeur 1 = ouverte, 0 = fermée.
-    private const val DOOR_OPEN_PROP = 0x2640c623
-    private val DOOR_FRONT_AREAS = intArrayOf(0x1, 0x4)
-    private val sDoorReadLast = HashMap<Int, Int>()
-    @Volatile private var sDoorSubProperty = false   // voie A : property.registerListener attachée
-    @Volatile private var sDoorSubDoorlock = false   // voie B : doorlock.registerCallback attachée
-    @Volatile private var sDoorWatcherOn = false
-    @Volatile private var sCarInstance: Any? = null
-    @Volatile private var sCarPropMgr: Any? = null   // CarPropertyManager (service "property")
-    @Volatile private var sCarDoorMgr: Any? = null   // CarDoorLockManager (service "doorlock")
-    @Volatile private var sDoorConnecting = false
-    @Volatile private var sAnyFrontOpenPrev = false
-    @Volatile private var sVolumeBeforeDrop = -1     // volume mémorisé à l'ouverture (pour restauration)
-
-    /** Baisse du volume à l'ouverture de porte : détection DLOCK_DOOR_OPEN_STS via CarPropertyManager.
-     *  Lisible/fonctionnel uniquement sur SWI132 et SWI133 ; ailleurs le prop n'est pas exposé à l'app. */
-    fun hasDoorVolumeFeature(): Boolean {
-        val gen = FirmwareInfo.getGeneration()
-        return gen == FirmwareInfo.Gen.SWI132 || gen == FirmwareInfo.Gen.SWI133
-    }
-
-    private fun doorVolumeEnabled(): Boolean =
-        sAppContext?.getSharedPreferences("mg4_settings", 0)?.getBoolean("door_volume_enabled", false) ?: false
-
-    private fun doorVolumeLevel(): Int =
-        sAppContext?.getSharedPreferences("mg4_settings", 0)?.getInt("door_volume_level", 0) ?: 0
-
-    private fun doorRestoreEnabled(): Boolean =
-        sAppContext?.getSharedPreferences("mg4_settings", 0)?.getBoolean("door_volume_restore", false) ?: false
-
-    /** areaIds des portes choisies par l'utilisateur (gauche=0x1, droite=0x4). */
-    private fun doorTriggerAreas(): IntArray {
-        val p = sAppContext?.getSharedPreferences("mg4_settings", 0) ?: return DOOR_FRONT_AREAS
-        val list = ArrayList<Int>(2)
-        if (p.getBoolean("door_volume_left", true)) list += 0x1
-        if (p.getBoolean("door_volume_right", true)) list += 0x4
-        return list.toIntArray()
-    }
-
-    /** Démarrage auto au boot (appelé par init) : ne lance le watcher que si la feature est activée. */
-    fun startDoorWatcherIfEnabled() {
-        if (hasDoorVolumeFeature() && doorVolumeEnabled()) startDoorVolumeWatcher()
-    }
-
-    fun startDoorVolumeWatcher() {
-        if (!hasDoorVolumeFeature()) return
-        sDoorWatcherOn = true
-        connectCarProperty()
-    }
-
-    fun stopDoorVolumeWatcher() {
-        sDoorWatcherOn = false           // poll conservé ; on ne déclenche plus la baisse
-        AppLogger.i(TAG, "  DoorVolumeWatcher: déclenchement désactivé")
-    }
-
-    /** Sonde du bouton Diagnostic : logge le volume + l'état des portes à l'instant du clic. */
-    fun runDoorVolumeDiag() {
-        AppLogger.i(VOL_TAG, "── DIAG (bouton Diagnostic) ──")
-        getMediaVolumeMax()
-        getMediaVolume()
-        connectCarProperty()   // idempotent ; normalement déjà connecté depuis l'init
-        registerDoorCallback() // re-tente la souscription si pas encore posée
-        probeDoorSnapshot()
-    }
-
-    private fun probeDoorSnapshot() {
-        if (sCarPropMgr == null && sCarDoorMgr == null) {
-            AppLogger.w(DOORWATCH_TAG, "DIAG porte: aucun manager Car (createCar échec ?)")
-            return
-        }
-        AppLogger.i(DOORWATCH_TAG, "DIAG porte: property=${sCarPropMgr != null} doorlock=${sCarDoorMgr != null}")
-        for (area in DOOR_FRONT_AREAS) {
-            val v = readDoorOpen(area)
-            AppLogger.i(DOORWATCH_TAG, "DIAG area=0x${area.toString(16)} = ${v ?: "illisible"}")
-        }
-        AppLogger.i(DOORWATCH_TAG, "DIAG souscription: property=$sDoorSubProperty doorlock=$sDoorSubDoorlock état=" +
-            if (sDoorReadLast.isEmpty()) "(aucun event reçu)"
-            else sDoorReadLast.entries.joinToString { "0x${it.key.toString(16)}=${it.value}" })
-    }
-
-    /** Connexion (async) à l'API Car AOSP → CarPropertyManager ("property") ET CarDoorLockManager
-     *  ("doorlock"). Selon le firmware, la porte est exposée par l'un ou l'autre → on lit via les deux. */
-    private fun connectCarProperty() {
-        if (sCarPropMgr != null || sCarDoorMgr != null || sDoorConnecting) return
-        val ctx = sAppContext ?: return
-        sDoorConnecting = true
-        try {
-            val carCls = ctx.classLoader.loadClass("android.car.Car")
-            val conn = object : ServiceConnection {
-                override fun onServiceConnected(name: ComponentName?, binder: IBinder?) {
-                    try {
-                        val car = sCarInstance ?: return
-                        val getMgr = carCls.getMethod("getCarManager", String::class.java)
-                        sCarPropMgr = try { getMgr.invoke(car, "property") } catch (_: Exception) { null }
-                        sCarDoorMgr = try { getMgr.invoke(car, "doorlock") } catch (_: Exception) { null }
-                        AppLogger.i(DOORWATCH_TAG, "managers: property=${sCarPropMgr != null} doorlock=${sCarDoorMgr != null}")
-                        if (sCarPropMgr != null || sCarDoorMgr != null) startDoorPolling()
-                        else AppLogger.w(DOORWATCH_TAG, "aucun manager porte disponible")
-                    } catch (e: Exception) { AppLogger.w(DOORWATCH_TAG, "getCarManager échec: ${e.message}") }
-                }
-                override fun onServiceDisconnected(name: ComponentName?) { sCarPropMgr = null; sCarDoorMgr = null; sDoorSubProperty = false; sDoorSubDoorlock = false }
-            }
-            val car = carCls.getMethod("createCar", Context::class.java, ServiceConnection::class.java)
-                .invoke(null, ctx, conn)
-            sCarInstance = car
-            try { carCls.getMethod("connect").invoke(car) } catch (_: Exception) {}
-            AppLogger.i(DOORWATCH_TAG, "connexion Car (property + doorlock)…")
-        } catch (e: Exception) {
-            sDoorConnecting = false
-            AppLogger.w(DOORWATCH_TAG, "Car createCar échec: ${e.message}")
-        }
-    }
-
-    // Lit DLOCK_DOOR_OPEN_STS(areaId) via CarPropertyManager.getIntProperty puis, en repli,
-    // via CarDoorLockManager.getProperty(Integer, propId, areaId).getValue(). null si aucun.
-    private fun readDoorOpen(area: Int): Int? {
-        sCarPropMgr?.let { m ->
-            try {
-                return m.javaClass.getMethod("getIntProperty", Int::class.javaPrimitiveType, Int::class.javaPrimitiveType)
-                    .invoke(m, DOOR_OPEN_PROP, area) as? Int
-            } catch (_: Exception) {}
-        }
-        sCarDoorMgr?.let { m ->
-            try {
-                val cpv = m.javaClass.getMethod("getProperty", Class::class.java, Int::class.javaPrimitiveType, Int::class.javaPrimitiveType)
-                    .invoke(m, Integer::class.java, DOOR_OPEN_PROP, area) ?: return null
-                return cpv.javaClass.getMethod("getValue").invoke(cpv) as? Int
-            } catch (_: Exception) {}
-        }
-        return null
-    }
-
-    private fun startDoorPolling() {
-        registerDoorCallback()   // souscription ON_CHANGE (complète le poll)
-        AppLogger.i(DOORWATCH_TAG, "watcher porte actif (property=${sCarPropMgr != null} doorlock=${sCarDoorMgr != null})")
-        val h = Handler(Looper.getMainLooper())
-        val poll = object : Runnable {
-            override fun run() {
-                if (sCarPropMgr == null && sCarDoorMgr == null) return
-                // DLOCK_DOOR_OPEN_STS sur les portes avant (0x1 gauche / 0x4 droite).
-                for (area in DOOR_FRONT_AREAS) {
-                    val v = readDoorOpen(area) ?: continue
-                    onDoorAreaValue(area, v)
-                }
-                h.postDelayed(this, 500L)
-            }
-        }
-        h.post(poll)
-    }
-
-    /** Point d'entrée unique pour une valeur porte (poll OU événement de souscription).
-     *  Met à jour l'état, log en change-only, puis réévalue le déclenchement volume. */
-    @Synchronized
-    private fun onDoorAreaValue(area: Int, v: Int) {
-        val prev = sDoorReadLast[area]
-        if (prev == null || prev != v) {
-            sDoorReadLast[area] = v
-            AppLogger.i(DOORWATCH_TAG, "area=0x${area.toString(16)} ${prev ?: "?"} → $v")
-        }
-        evaluateDoorTrigger()
-    }
-
-    /** Recalcule "au moins une porte choisie ouverte" à partir de l'état accumulé et applique
-     *  la baisse (front d'ouverture) / la restauration (front de fermeture). Idempotent. */
-    private fun evaluateDoorTrigger() {
-        if (!(sDoorWatcherOn && doorVolumeEnabled())) return
-        val triggerAreas = doorTriggerAreas()
-        val anyOpen = triggerAreas.any { sDoorReadLast[it] == 1 }
-        if (anyOpen && !sAnyFrontOpenPrev) {
-            val level = doorVolumeLevel()
-            CoroutineScope(Dispatchers.IO).launch {
-                sVolumeBeforeDrop = getMediaVolume()
-                val ok = setMediaVolume(level)
-                AppLogger.i(DOORWATCH_TAG, "porte ouverte → vol $sVolumeBeforeDrop→$level = $ok")
-            }
-        } else if (!anyOpen && sAnyFrontOpenPrev) {
-            val restore = sVolumeBeforeDrop
-            sVolumeBeforeDrop = -1
-            if (doorRestoreEnabled() && restore >= 0) {
-                CoroutineScope(Dispatchers.IO).launch {
-                    val ok = setMediaVolume(restore)
-                    AppLogger.i(DOORWATCH_TAG, "porte fermée → restauration vol $restore = $ok")
-                }
-            }
-        }
-        sAnyFrontOpenPrev = anyOpen
-    }
-
-    /** InvocationHandler commun aux deux interfaces de callback (onChangeEvent/onErrorEvent).
-     *  Filtre DLOCK_DOOR_OPEN_STS et alimente onDoorAreaValue. Gère aussi les méthodes Object. */
-    private fun doorEventHandler(src: String) = InvocationHandler { proxy, method, args ->
-        when (method.name) {
-            "onChangeEvent" -> {
-                try {
-                    val cpv = args?.getOrNull(0)
-                    if (cpv != null) {
-                        val pid = cpv.javaClass.getMethod("getPropertyId").invoke(cpv) as? Int
-                        val area = cpv.javaClass.getMethod("getAreaId").invoke(cpv) as? Int ?: 0
-                        val raw = cpv.javaClass.getMethod("getValue").invoke(cpv)
-                        val v = when (raw) {
-                            is Boolean -> if (raw) 1 else 0
-                            is Number  -> raw.toInt()
-                            else       -> null
-                        }
-                        if (pid == DOOR_OPEN_PROP && v != null) {
-                            AppLogger.i(DOORWATCH_TAG, "EVENT[$src] area=0x${area.toString(16)} = $v")
-                            onDoorAreaValue(area, v)
-                        }
-                    }
-                } catch (e: Exception) { AppLogger.w(DOORWATCH_TAG, "onChangeEvent: ${e.message}") }
-                null
-            }
-            "onErrorEvent" -> { AppLogger.w(DOORWATCH_TAG, "EVENT erreur porte"); null }
-            "hashCode"     -> System.identityHashCode(proxy)
-            "equals"       -> proxy === args?.getOrNull(0)
-            "toString"     -> "MG4DoorListener@" + Integer.toHexString(System.identityHashCode(proxy))
-            else           -> null
-        }
-    }
-
-    /**
-     * S'abonne aux changements de DLOCK_DOOR_OPEN_STS. Nécessaire sur SWI69/131/68/165 où le prop
-     * n'est PAS lisible à la demande (getProperty lève IllegalArgumentException "Failed to get value")
-     * mais poussé en ON_CHANGE. IMPORTANT : le Proxy doit être défini par le classloader de l'APP
-     * (android.car est en BootClassLoader → Proxy.newProxyInstance y échoue). On tente DEUX voies :
-     *   A) CarPropertyManager.registerListener (service "property")
-     *   B) CarDoorLockManager.registerCallback   (service "doorlock", comme la SystemUI d'origine)
-     */
-    private fun registerDoorCallback() {
-        val cl = sAppContext?.classLoader ?: return
-
-        // Voie A — CarPropertyManager.registerListener(CarPropertyEventListener, propId, rate).
-        // rate=5f (et non 0f) : si le VHAL déclare la prop CONTINUOUS, un rate 0 = aucune mise à jour.
-        if (!sDoorSubProperty) sCarPropMgr?.let { m ->
-            try {
-                val iface = cl.loadClass("android.car.hardware.property.CarPropertyManager\$CarPropertyEventListener")
-                val proxy = Proxy.newProxyInstance(cl, arrayOf(iface), doorEventHandler("property"))
-                val ok = m.javaClass.getMethod("registerListener", iface,
-                    Int::class.javaPrimitiveType, Float::class.javaPrimitiveType)
-                    .invoke(m, proxy, DOOR_OPEN_PROP, 5f)
-                sDoorSubProperty = true
-                AppLogger.i(DOORWATCH_TAG, "souscription porte (property.registerListener rate=5) OK=$ok")
-            } catch (e: Exception) {
-                val c = e.cause ?: e
-                AppLogger.w(DOORWATCH_TAG, "property.registerListener échec: ${c.javaClass.simpleName}: ${c.message}")
-            }
-        }
-
-        // Voie B — CarDoorLockManager.registerCallback(CarDoorLockEventCallback) — voie de l'OEM
-        if (!sDoorSubDoorlock) sCarDoorMgr?.let { m ->
-            try {
-                val iface = cl.loadClass("android.car.hardware.doorlock.CarDoorLockManager\$CarDoorLockEventCallback")
-                val proxy = Proxy.newProxyInstance(cl, arrayOf(iface), doorEventHandler("doorlock"))
-                m.javaClass.getMethod("registerCallback", iface).invoke(m, proxy)
-                sDoorSubDoorlock = true
-                AppLogger.i(DOORWATCH_TAG, "souscription porte (doorlock.registerCallback) OK")
-            } catch (e: Exception) {
-                val c = e.cause ?: e
-                AppLogger.w(DOORWATCH_TAG, "doorlock.registerCallback échec: ${c.javaClass.simpleName}: ${c.message}")
-            }
-        }
-    }
-
-    fun getSpeedVolumeLevel(): Int           = audioGet(AUDIO_GET_SPEED_VOL)
-    fun setSpeedVolumeLevel(l: Int): Boolean = audioSet(AUDIO_SET_SPEED_VOL, l.coerceIn(AUDIO_TYPE_MIN, AUDIO_TYPE_MAX))
-    fun getSoundFieldType(): Int             = -1
-    fun setSoundFieldType(t: Int): Boolean   = audioSet(AUDIO_SET_SOUND_FIELD, t)
-    fun get3dEffectType(): Int               = audioGet(AUDIO_GET_3D_EFFECT)
-    fun set3dEffectType(t: Int): Boolean     = audioSet(AUDIO_SET_3D_EFFECT, t.coerceIn(AUDIO_TYPE_MIN, AUDIO_TYPE_MAX))
-    fun getToneControl(): Int                = audioGet(AUDIO_GET_TONE)
-    fun setToneControl(v: Int): Boolean      = audioSet(AUDIO_SET_TONE, v.coerceIn(AUDIO_LEVEL_MIN, AUDIO_LEVEL_MAX))
-}
diff --git a/app/src/main/java/com/mg4/control/hardware/VehicleWriteGate.kt b/app/src/main/java/com/mg4/control/hardware/VehicleWriteGate.kt
deleted file mode 100644
index e4eff95..0000000
--- a/app/src/main/java/com/mg4/control/hardware/VehicleWriteGate.kt
+++ /dev/null
@@ -1,81 +0,0 @@
-package com.mg4.control.hardware
-
-import android.content.Context
-import android.os.Handler
-import android.os.Looper
-import android.widget.Toast
-import com.mg4.control.R
-import com.mg4.control.debug.AppLogger
-
-/**
- * [T-904] Politique décidée : une écriture de réglage véhicule n'est autorisée QU'À L'ARRÊT.
- *
- * Changer l'AEB, l'ELK, l'ACC/TJA ou le mode de conduite en roulant modifie le comportement
- * du véhicule sous le conducteur. La règle est donc : 0 km/h, sinon refus — et refus AUSSI
- * quand la vitesse est illisible (fail closed), parce qu'une vitesse inconnue peut être
- * n'importe quelle vitesse.
- *
- * Le confort (sièges/volant chauffants, via CarHvacManager) n'est PAS concerné : ces
- * écritures ne changent pas le comportement routier.
- */
-object VehicleWriteGate {
-
-    private const val TAG = "MG4_GATE"
-
-    /** Anti-spam sur le message utilisateur : un refus par seconde au plus. */
-    private const val TOAST_THROTTLE_MS = 1_000L
-
-    @Volatile
-    private var lastToastMs = 0L
-
-    enum class Decision {
-        /** Véhicule à l'arrêt — écriture autorisée. */
-        ALLOWED,
-        /** Véhicule en mouvement — écriture refusée. */
-        REFUSED_MOVING,
-        /** Vitesse illisible — écriture refusée (fail closed). */
-        REFUSED_UNKNOWN_SPEED
-    }
-
-    /**
-     * Décision pure à partir d'une vitesse en km/h, [speedKmh] à null si illisible.
-     *
-     * Une vitesse négative est traitée comme illisible : le VHAL ne produit pas de vitesse
-     * négative en marche avant, et une valeur aberrante ne doit jamais ouvrir la porte.
-     */
-    fun decide(speedKmh: Float?): Decision = when {
-        speedKmh == null || speedKmh.isNaN() -> Decision.REFUSED_UNKNOWN_SPEED
-        speedKmh < 0f                        -> Decision.REFUSED_UNKNOWN_SPEED
-        speedKmh == 0f                       -> Decision.ALLOWED
-        else                                 -> Decision.REFUSED_MOVING
-    }
-
-    /**
-     * Vrai si l'écriture [operation] est permise maintenant. En cas de refus, journalise et
-     * prévient l'utilisateur — un refus silencieux ferait croire que le réglage a été pris.
-     */
-    fun allow(operation: String): Boolean {
-        val decision = decide(MG4Hardware.getVehicleSpeedKmh())
-        if (decision == Decision.ALLOWED) return true
-
-        AppLogger.w(TAG, "Écriture refusée ($operation) : $decision")
-        notifyUser(decision)
-        return false
-    }
-
-    private fun notifyUser(decision: Decision) {
-        val context: Context = MG4Hardware.appContext() ?: return
-        val now = System.currentTimeMillis()
-        if (now - lastToastMs < TOAST_THROTTLE_MS) return
-        lastToastMs = now
-
-        val message = when (decision) {
-            Decision.REFUSED_MOVING        -> R.string.write_refused_moving
-            Decision.REFUSED_UNKNOWN_SPEED -> R.string.write_refused_unknown_speed
-            Decision.ALLOWED               -> return
-        }
-        Handler(Looper.getMainLooper()).post {
-            runCatching { Toast.makeText(context, message, Toast.LENGTH_SHORT).show() }
-        }
-    }
-}
diff --git a/app/src/main/java/com/mg4/control/model/DriveMode.kt b/app/src/main/java/com/mg4/control/model/DriveMode.kt
deleted file mode 100644
index 5be396e..0000000
--- a/app/src/main/java/com/mg4/control/model/DriveMode.kt
+++ /dev/null
@@ -1,13 +0,0 @@
-package com.mg4.control.model
-
-enum class DriveMode(val value: Int, val label: String) {
-    ECO(2, "Eco"),
-    NORMAL(3, "Normal"),
-    SPORT(4, "Sport"),
-    SNOW(6, "Snow"),
-    CUSTOM(7, "Custom");
-
-    companion object {
-        fun fromValue(v: Int): DriveMode = values().firstOrNull { it.value == v } ?: NORMAL
-    }
-}
diff --git a/app/src/main/java/com/mg4/control/model/DrivingProfile.kt b/app/src/main/java/com/mg4/control/model/DrivingProfile.kt
deleted file mode 100644
index f6693c8..0000000
--- a/app/src/main/java/com/mg4/control/model/DrivingProfile.kt
+++ /dev/null
@@ -1,41 +0,0 @@
-package com.mg4.control.model
-
-import java.util.UUID
-
-data class DrivingProfile(
-    val id: String = UUID.randomUUID().toString(),
-    val name: String,
-    val driveMode: DriveMode,
-    val regenLevel: RegenLevel,
-    val steeringHeat: Boolean = false,
-    val seatHeatLeft: Int = 0,        // 0=off, 1, 2, 3
-    val seatHeatRight: Int = 0,
-    // ADAS SWI133 (Katman4) — valeurs par défaut OFF pour compatibilité profils existants
-    val overspeedAlarm: Boolean = false,
-    val speedLimitTone: Boolean = false,
-    val adasMode: Int = 0,            // 0=Off, 1=Limiteur, 2=Auto, 3=ACC, 4=ICA
-    // ADAS SWI68 — champs distincts pour isoler les configurations par firmware
-    val soundWarning: Boolean = false,
-    val swi68AdasMode: Int = 0x4,     // Mode ACC/TJA (CarAccTja) : 0x4=Off, 0x1=ACC, 0x2=TJA/ICA
-    // Limiteur de vitesse (SAS) — réglage INDÉPENDANT du mode ACC/TJA (SWI132).
-    // swi132LimiterConfigured=false (défaut + profils créés avant cette fonction) → le limiteur
-    // n'est PAS touché lors de l'application du profil (aucune régression sur l'état voiture).
-    val swi132LimiterConfigured: Boolean = false,
-    val swi132SasMode: Int = 0,       // SAS : 0=Désactivé, 2=Manuel, 3=Intelligent
-    // AEB — Système anti-collision avant (commun SWI133 + SWI68)
-    val aebEnabled: Boolean = false,   // false=OFF, true=ON
-    val aebMode: Int = 1,              // 1=Alerte seule, 2=Alerte+Freinage auto
-    val aebSensitivity: Int = 0,       // 0=non configuré, 1=Faible, 2=Standard, 3=Élevé (SWI133)
-    // ELK — Assistant de sortie de voie
-    val elkMode: Int = 0,              // 0=non configuré, 1=OFF, 2=Alerte(LDW), 3=Aider(LDP), 5=ELK
-    val elkSensitivity: Int = 0,       // 0=non configuré, 1=Faible, 2=Standard, 3=Élevé
-    // ELK SWI132 — Alerte sonore + Vibration (spécifique SWI132)
-    val lasAudibleWarning: Boolean = true,    // true=ON (défaut ON dans la voiture)
-    val lasVibrationReminder: Boolean = true, // true=ON (défaut ON dans la voiture)
-    // Économie d'énergie + TSR
-    val energySaving: Boolean = false,
-    val tsrEnabled: Boolean = false,
-    val isDefault: Boolean = false,
-    // [BT-PROFILES] MAC de l'appareil Bluetooth associé à ce profil (null = aucun)
-    val btDeviceMac: String? = null
-)
diff --git a/app/src/main/java/com/mg4/control/model/ProfileBackup.kt b/app/src/main/java/com/mg4/control/model/ProfileBackup.kt
deleted file mode 100644
index 11b1edd..0000000
--- a/app/src/main/java/com/mg4/control/model/ProfileBackup.kt
+++ /dev/null
@@ -1,17 +0,0 @@
-package com.mg4.control.model
-
-/**
- * Format sérialisé de la sauvegarde des profils (fichier dans la mémoire de la voiture).
- *
- * [schemaVersion] permet de faire évoluer le format sans casser d'anciennes sauvegardes
- * (Gson ignore les champs inconnus et applique les valeurs par défaut des champs manquants).
- */
-data class ProfileBackup(
-    val schemaVersion: Int = CURRENT_SCHEMA_VERSION,
-    val defaultId: String? = null,
-    val profiles: List<DrivingProfile> = emptyList()
-) {
-    companion object {
-        const val CURRENT_SCHEMA_VERSION = 1
-    }
-}
diff --git a/app/src/main/java/com/mg4/control/model/RegenLevel.kt b/app/src/main/java/com/mg4/control/model/RegenLevel.kt
deleted file mode 100644
index ee5b360..0000000
--- a/app/src/main/java/com/mg4/control/model/RegenLevel.kt
+++ /dev/null
@@ -1,14 +0,0 @@
-package com.mg4.control.model
-
-enum class RegenLevel(val value: Int, val label: String) {
-    LOW(0, "Low"),
-    MEDIUM(1, "Medium"),
-    HIGH(2, "High"),
-    ADAPTIVE(3, "Adaptive"),
-    OFF(5, "Off"),
-    ONE_PEDAL(6, "One Pedal");
-
-    companion object {
-        fun fromValue(v: Int): RegenLevel = values().firstOrNull { it.value == v } ?: MEDIUM
-    }
-}
diff --git a/app/src/main/java/com/mg4/control/profile/ProfileApplier.kt b/app/src/main/java/com/mg4/control/profile/ProfileApplier.kt
index 7d3bafb..e17ce8f 100644
--- a/app/src/main/java/com/mg4/control/profile/ProfileApplier.kt
+++ b/app/src/main/java/com/mg4/control/profile/ProfileApplier.kt
@@ -1,10 +1,10 @@
 package com.mg4.control.profile
 
-import com.mg4.control.debug.AppLogger
-import com.mg4.control.hardware.MG4Hardware
-import com.mg4.control.hardware.MG4Hardware.Swi68Mode
-import com.mg4.control.model.DrivingProfile
-import com.mg4.control.util.FirmwareInfo
+import com.mg4.hardware.AppLogger
+import com.mg4.hardware.MG4Hardware
+import com.mg4.hardware.MG4Hardware.Swi68Mode
+import com.mg4.hardware.model.DrivingProfile
+import com.mg4.hardware.FirmwareInfo
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
diff --git a/app/src/main/java/com/mg4/control/profile/ProfileBackupManager.kt b/app/src/main/java/com/mg4/control/profile/ProfileBackupManager.kt
index 69930dd..8734768 100644
--- a/app/src/main/java/com/mg4/control/profile/ProfileBackupManager.kt
+++ b/app/src/main/java/com/mg4/control/profile/ProfileBackupManager.kt
@@ -2,9 +2,9 @@ package com.mg4.control.profile
 
 import android.os.Environment
 import com.google.gson.Gson
-import com.mg4.control.debug.AppLogger
-import com.mg4.control.model.DrivingProfile
-import com.mg4.control.model.ProfileBackup
+import com.mg4.hardware.AppLogger
+import com.mg4.hardware.model.DrivingProfile
+import com.mg4.hardware.model.ProfileBackup
 import java.io.File
 import java.nio.file.Files
 import java.nio.file.StandardCopyOption
diff --git a/app/src/main/java/com/mg4/control/profile/ProfileManager.kt b/app/src/main/java/com/mg4/control/profile/ProfileManager.kt
index f9ad2b2..e87eed0 100644
--- a/app/src/main/java/com/mg4/control/profile/ProfileManager.kt
+++ b/app/src/main/java/com/mg4/control/profile/ProfileManager.kt
@@ -3,7 +3,7 @@ package com.mg4.control.profile
 import android.content.Context
 import com.google.gson.Gson
 import com.google.gson.reflect.TypeToken
-import com.mg4.control.model.DrivingProfile
+import com.mg4.hardware.model.DrivingProfile
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@@ -116,7 +116,7 @@ class ProfileManager(private val context: Context) {
      * de la sauvegarde (plafonné à [MAX_PROFILES]) et applique le profil par défaut.
      * Retourne le nombre de profils restaurés.
      */
-    fun restoreFrom(backup: com.mg4.control.model.ProfileBackup): Int {
+    fun restoreFrom(backup: com.mg4.hardware.model.ProfileBackup): Int {
         val restored = backup.profiles.take(MAX_PROFILES)
         synchronized(MUTATION_LOCK) {
             persist(restored)
diff --git a/app/src/main/java/com/mg4/control/receiver/BootReceiver.kt b/app/src/main/java/com/mg4/control/receiver/BootReceiver.kt
index b372b61..e24c947 100644
--- a/app/src/main/java/com/mg4/control/receiver/BootReceiver.kt
+++ b/app/src/main/java/com/mg4/control/receiver/BootReceiver.kt
@@ -3,7 +3,7 @@ package com.mg4.control.receiver
 import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
-import com.mg4.control.debug.AppLogger
+import com.mg4.hardware.AppLogger
 import com.mg4.control.service.MG4ControlService
 
 class BootReceiver : BroadcastReceiver() {
diff --git a/app/src/main/java/com/mg4/control/service/MG4ControlService.kt b/app/src/main/java/com/mg4/control/service/MG4ControlService.kt
index 5aeb55c..1d5e8cf 100644
--- a/app/src/main/java/com/mg4/control/service/MG4ControlService.kt
+++ b/app/src/main/java/com/mg4/control/service/MG4ControlService.kt
@@ -21,16 +21,17 @@ import android.widget.Toast
 import com.mg4.control.util.LocaleHelper
 import com.mg4.control.R
 import com.mg4.control.bluetooth.BluetoothProfileManager
-import com.mg4.control.debug.AppLogger
-import com.mg4.control.hardware.MG4Hardware
-import com.mg4.control.hardware.MG4Hardware.AebMode
-import com.mg4.control.hardware.MG4Hardware.Swi68Mode
-import com.mg4.control.model.RegenLevel
+import com.mg4.hardware.AppLogger
+import com.mg4.hardware.MG4Hardware
+import com.mg4.hardware.MG4Hardware.AebMode
+import com.mg4.hardware.MG4Hardware.Swi68Mode
+import com.mg4.hardware.model.RegenLevel
 import com.mg4.control.profile.ProfileApplier
 import com.mg4.control.profile.ProfileManager
 import com.mg4.control.shortcut.ShortcutAction
 import com.mg4.control.tasker.TaskerBridgeService
-import com.mg4.control.util.FirmwareInfo
+import com.mg4.hardware.FirmwareInfo
+import com.mg4.hardware.VehicleWriteGate
 import com.mg4.control.util.ThemeHelper
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -99,6 +100,15 @@ class MG4ControlService : Service() {
         super.onCreate()
         AppLogger.i(TAG, "onCreate")
         startForeground(NOTIF_ID, buildNotification())
+        // Feed the shared gate MG4Control's localized refusal strings (mg4-hardware itself
+        // has no app resources; the module falls back to English when no provider is set).
+        VehicleWriteGate.messageProvider = { decision ->
+            when (decision) {
+                VehicleWriteGate.Decision.REFUSED_MOVING        -> getString(R.string.write_refused_moving)
+                VehicleWriteGate.Decision.REFUSED_UNKNOWN_SPEED -> getString(R.string.write_refused_unknown_speed)
+                VehicleWriteGate.Decision.ALLOWED               -> null
+            }
+        }
         MG4Hardware.init(applicationContext)
         registerHardkeyReceiver()
         registerBtAclReceiver()        // [BT-PROFILES]
diff --git a/app/src/main/java/com/mg4/control/service/ProfilePickerOverlay.kt b/app/src/main/java/com/mg4/control/service/ProfilePickerOverlay.kt
index 6de02ea..cb7893d 100644
--- a/app/src/main/java/com/mg4/control/service/ProfilePickerOverlay.kt
+++ b/app/src/main/java/com/mg4/control/service/ProfilePickerOverlay.kt
@@ -13,15 +13,15 @@ import android.view.Gravity
 import android.view.LayoutInflater
 import android.view.View
 import android.view.WindowManager
-import com.mg4.control.hardware.VehicleWriteGate
+import com.mg4.hardware.VehicleWriteGate
 import android.widget.LinearLayout
 import android.widget.TextView
 import com.google.android.material.button.MaterialButton
 import com.google.android.material.slider.Slider
 import com.mg4.control.R
-import com.mg4.control.debug.AppLogger
-import com.mg4.control.hardware.MG4Hardware
-import com.mg4.control.model.DrivingProfile
+import com.mg4.hardware.AppLogger
+import com.mg4.hardware.MG4Hardware
+import com.mg4.hardware.model.DrivingProfile
 import com.mg4.control.profile.ProfileApplier
 import com.mg4.control.profile.ProfileManager
 import com.mg4.control.util.LocaleHelper
@@ -127,7 +127,7 @@ object ProfilePickerOverlay {
 
         fun dp(value: Float) = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, value, dm).toInt()
 
-        fun makeProfileButton(profile: com.mg4.control.model.DrivingProfile) =
+        fun makeProfileButton(profile: com.mg4.hardware.model.DrivingProfile) =
             MaterialButton(themedContext).apply {
                 text      = profile.name
                 textSize  = 19f
diff --git a/app/src/main/java/com/mg4/control/tasker/TaskerBridgeService.kt b/app/src/main/java/com/mg4/control/tasker/TaskerBridgeService.kt
index 1afb299..e48eeeb 100644
--- a/app/src/main/java/com/mg4/control/tasker/TaskerBridgeService.kt
+++ b/app/src/main/java/com/mg4/control/tasker/TaskerBridgeService.kt
@@ -4,14 +4,14 @@ import android.app.Service
 import android.content.Intent
 import android.os.Bundle
 import android.os.IBinder
-import com.mg4.control.debug.AppLogger
-import com.mg4.control.hardware.MG4Hardware
-import com.mg4.control.hardware.VehicleWriteGate
-import com.mg4.control.model.DriveMode
-import com.mg4.control.model.RegenLevel
+import com.mg4.hardware.AppLogger
+import com.mg4.hardware.MG4Hardware
+import com.mg4.hardware.VehicleWriteGate
+import com.mg4.hardware.model.DriveMode
+import com.mg4.hardware.model.RegenLevel
 import com.mg4.control.profile.ProfileApplier
 import com.mg4.control.profile.ProfileManager
-import com.mg4.control.util.FirmwareInfo
+import com.mg4.hardware.FirmwareInfo
 import com.mg4.control.bluetooth.BluetoothProfileManager
 
 /**
diff --git a/app/src/main/java/com/mg4/control/ui/AdasFragment.kt b/app/src/main/java/com/mg4/control/ui/AdasFragment.kt
index 10c1a77..c11733d 100644
--- a/app/src/main/java/com/mg4/control/ui/AdasFragment.kt
+++ b/app/src/main/java/com/mg4/control/ui/AdasFragment.kt
@@ -9,10 +9,10 @@ import android.widget.Button
 import android.widget.Switch
 import androidx.fragment.app.Fragment
 import com.mg4.control.R
-import com.mg4.control.hardware.MG4Hardware
-import com.mg4.control.hardware.MG4Hardware.AebMode
-import com.mg4.control.hardware.MG4Hardware.Swi68Mode
-import com.mg4.control.util.FirmwareInfo
+import com.mg4.hardware.MG4Hardware
+import com.mg4.hardware.MG4Hardware.AebMode
+import com.mg4.hardware.MG4Hardware.Swi68Mode
+import com.mg4.hardware.FirmwareInfo
 import kotlinx.coroutines.*
 
 class AdasFragment : Fragment() {
diff --git a/app/src/main/java/com/mg4/control/ui/AudioFragment.kt b/app/src/main/java/com/mg4/control/ui/AudioFragment.kt
index 7d45d5e..e8573d3 100644
--- a/app/src/main/java/com/mg4/control/ui/AudioFragment.kt
+++ b/app/src/main/java/com/mg4/control/ui/AudioFragment.kt
@@ -11,7 +11,7 @@ import androidx.fragment.app.Fragment
 import androidx.lifecycle.lifecycleScope
 import com.google.android.material.slider.Slider
 import com.mg4.control.R
-import com.mg4.control.hardware.MG4Hardware
+import com.mg4.hardware.MG4Hardware
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
diff --git a/app/src/main/java/com/mg4/control/ui/ClimateFragment.kt b/app/src/main/java/com/mg4/control/ui/ClimateFragment.kt
index 6daa3b2..71404ba 100644
--- a/app/src/main/java/com/mg4/control/ui/ClimateFragment.kt
+++ b/app/src/main/java/com/mg4/control/ui/ClimateFragment.kt
@@ -9,7 +9,7 @@ import android.widget.Button
 import android.widget.Switch
 import androidx.fragment.app.Fragment
 import com.mg4.control.R
-import com.mg4.control.hardware.MG4Hardware
+import com.mg4.hardware.MG4Hardware
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
diff --git a/app/src/main/java/com/mg4/control/ui/ConsoleFragment.kt b/app/src/main/java/com/mg4/control/ui/ConsoleFragment.kt
index d9adf33..40918fa 100644
--- a/app/src/main/java/com/mg4/control/ui/ConsoleFragment.kt
+++ b/app/src/main/java/com/mg4/control/ui/ConsoleFragment.kt
@@ -14,8 +14,8 @@ import android.widget.ScrollView
 import android.widget.TextView
 import androidx.fragment.app.Fragment
 import com.mg4.control.R
-import com.mg4.control.debug.AppLogger
-import com.mg4.control.hardware.MG4Hardware
+import com.mg4.hardware.AppLogger
+import com.mg4.hardware.MG4Hardware
 
 class ConsoleFragment : Fragment() {
 
diff --git a/app/src/main/java/com/mg4/control/ui/DashboardFragment.kt b/app/src/main/java/com/mg4/control/ui/DashboardFragment.kt
index 025734c..c3a6d4f 100644
--- a/app/src/main/java/com/mg4/control/ui/DashboardFragment.kt
+++ b/app/src/main/java/com/mg4/control/ui/DashboardFragment.kt
@@ -12,15 +12,15 @@ import androidx.fragment.app.Fragment
 import androidx.recyclerview.widget.RecyclerView
 import androidx.viewpager2.widget.ViewPager2
 import com.mg4.control.R
-import com.mg4.control.hardware.MG4Hardware
-import com.mg4.control.hardware.MG4Hardware.AebMode
-import com.mg4.control.hardware.MG4Hardware.AebSensitivity
-import com.mg4.control.hardware.MG4Hardware.ElkMode
-import com.mg4.control.hardware.MG4Hardware.ElkSensitivity
-import com.mg4.control.hardware.MG4Hardware.Swi68Mode
-import com.mg4.control.model.DriveMode
-import com.mg4.control.model.RegenLevel
-import com.mg4.control.util.FirmwareInfo
+import com.mg4.hardware.MG4Hardware
+import com.mg4.hardware.MG4Hardware.AebMode
+import com.mg4.hardware.MG4Hardware.AebSensitivity
+import com.mg4.hardware.MG4Hardware.ElkMode
+import com.mg4.hardware.MG4Hardware.ElkSensitivity
+import com.mg4.hardware.MG4Hardware.Swi68Mode
+import com.mg4.hardware.model.DriveMode
+import com.mg4.hardware.model.RegenLevel
+import com.mg4.hardware.FirmwareInfo
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
diff --git a/app/src/main/java/com/mg4/control/ui/DriveRegenFragment.kt b/app/src/main/java/com/mg4/control/ui/DriveRegenFragment.kt
index ac402ad..fb2c45a 100644
--- a/app/src/main/java/com/mg4/control/ui/DriveRegenFragment.kt
+++ b/app/src/main/java/com/mg4/control/ui/DriveRegenFragment.kt
@@ -8,9 +8,9 @@ import android.widget.Button
 import android.widget.Toast
 import androidx.fragment.app.Fragment
 import com.mg4.control.R
-import com.mg4.control.hardware.MG4Hardware
-import com.mg4.control.model.DriveMode
-import com.mg4.control.model.RegenLevel
+import com.mg4.hardware.MG4Hardware
+import com.mg4.hardware.model.DriveMode
+import com.mg4.hardware.model.RegenLevel
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
diff --git a/app/src/main/java/com/mg4/control/ui/ProfileAdapter.kt b/app/src/main/java/com/mg4/control/ui/ProfileAdapter.kt
index ff75301..05d2805 100644
--- a/app/src/main/java/com/mg4/control/ui/ProfileAdapter.kt
+++ b/app/src/main/java/com/mg4/control/ui/ProfileAdapter.kt
@@ -7,9 +7,9 @@ import android.widget.Button
 import android.widget.TextView
 import androidx.recyclerview.widget.RecyclerView
 import com.mg4.control.R
-import com.mg4.control.hardware.MG4Hardware.Swi68Mode
-import com.mg4.control.model.DrivingProfile
-import com.mg4.control.util.FirmwareInfo
+import com.mg4.hardware.MG4Hardware.Swi68Mode
+import com.mg4.hardware.model.DrivingProfile
+import com.mg4.hardware.FirmwareInfo
 
 class ProfileAdapter(
     private var profiles: MutableList<DrivingProfile>,
diff --git a/app/src/main/java/com/mg4/control/ui/ProfileFragment.kt b/app/src/main/java/com/mg4/control/ui/ProfileFragment.kt
index 3df827a..121f73b 100644
--- a/app/src/main/java/com/mg4/control/ui/ProfileFragment.kt
+++ b/app/src/main/java/com/mg4/control/ui/ProfileFragment.kt
@@ -16,18 +16,18 @@ import androidx.recyclerview.widget.RecyclerView
 import com.google.android.material.button.MaterialButton
 import com.mg4.control.R
 import com.mg4.control.bluetooth.BluetoothProfileManager
-import com.mg4.control.hardware.MG4Hardware
-import com.mg4.control.hardware.MG4Hardware.AebMode
-import com.mg4.control.hardware.MG4Hardware.AebSensitivity
-import com.mg4.control.hardware.MG4Hardware.ElkMode
-import com.mg4.control.hardware.MG4Hardware.ElkSensitivity
-import com.mg4.control.hardware.MG4Hardware.Swi68Mode
-import com.mg4.control.model.DriveMode
-import com.mg4.control.model.DrivingProfile
-import com.mg4.control.model.RegenLevel
+import com.mg4.hardware.MG4Hardware
+import com.mg4.hardware.MG4Hardware.AebMode
+import com.mg4.hardware.MG4Hardware.AebSensitivity
+import com.mg4.hardware.MG4Hardware.ElkMode
+import com.mg4.hardware.MG4Hardware.ElkSensitivity
+import com.mg4.hardware.MG4Hardware.Swi68Mode
+import com.mg4.hardware.model.DriveMode
+import com.mg4.hardware.model.DrivingProfile
+import com.mg4.hardware.model.RegenLevel
 import com.mg4.control.profile.ProfileApplier
 import com.mg4.control.profile.ProfileManager
-import com.mg4.control.util.FirmwareInfo
+import com.mg4.hardware.FirmwareInfo
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
diff --git a/app/src/main/java/com/mg4/control/ui/SettingsFragment.kt b/app/src/main/java/com/mg4/control/ui/SettingsFragment.kt
index fca6019..bb1d68c 100644
--- a/app/src/main/java/com/mg4/control/ui/SettingsFragment.kt
+++ b/app/src/main/java/com/mg4/control/ui/SettingsFragment.kt
@@ -32,9 +32,9 @@ import com.google.android.material.button.MaterialButton
 import com.mg4.control.BuildConfig
 import com.mg4.control.R
 import com.mg4.control.util.QrCode
-import com.mg4.control.debug.AppLogger
+import com.mg4.hardware.AppLogger
 import com.mg4.control.debug.CrashLogger
-import com.mg4.control.hardware.MG4Hardware
+import com.mg4.hardware.MG4Hardware
 import com.mg4.control.update.ApkCleanup
 import com.mg4.control.update.UpdateChecker
 import com.mg4.control.update.UpdateDialogManager
diff --git a/app/src/main/java/com/mg4/control/ui/ShortcutsFragment.kt b/app/src/main/java/com/mg4/control/ui/ShortcutsFragment.kt
index 4283c21..bedb671 100644
--- a/app/src/main/java/com/mg4/control/ui/ShortcutsFragment.kt
+++ b/app/src/main/java/com/mg4/control/ui/ShortcutsFragment.kt
@@ -18,11 +18,11 @@ import androidx.fragment.app.Fragment
 import androidx.navigation.fragment.findNavController
 import com.google.android.material.button.MaterialButton
 import com.mg4.control.R
-import com.mg4.control.model.RegenLevel
+import com.mg4.hardware.model.RegenLevel
 import com.mg4.control.profile.ProfileManager
 import com.mg4.control.shortcut.ShortcutAction
-import com.mg4.control.hardware.MG4Hardware
-import com.mg4.control.util.FirmwareInfo
+import com.mg4.hardware.MG4Hardware
+import com.mg4.hardware.FirmwareInfo
 
 class ShortcutsFragment : Fragment() {
 
diff --git a/app/src/main/java/com/mg4/control/update/ApkSecurity.kt b/app/src/main/java/com/mg4/control/update/ApkSecurity.kt
index 04da2b8..dca82ae 100644
--- a/app/src/main/java/com/mg4/control/update/ApkSecurity.kt
+++ b/app/src/main/java/com/mg4/control/update/ApkSecurity.kt
@@ -3,7 +3,7 @@ package com.mg4.control.update
 import android.content.Context
 import android.content.pm.PackageManager
 import android.os.Build
-import com.mg4.control.debug.AppLogger
+import com.mg4.hardware.AppLogger
 import java.io.File
 import java.net.URI
 import java.security.MessageDigest
diff --git a/app/src/main/java/com/mg4/control/update/UpdateChecker.kt b/app/src/main/java/com/mg4/control/update/UpdateChecker.kt
index 44f2566..a31f5e8 100644
--- a/app/src/main/java/com/mg4/control/update/UpdateChecker.kt
+++ b/app/src/main/java/com/mg4/control/update/UpdateChecker.kt
@@ -2,7 +2,7 @@ package com.mg4.control.update
 
 import android.content.Context
 import androidx.annotation.VisibleForTesting
-import com.mg4.control.debug.AppLogger
+import com.mg4.hardware.AppLogger
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
diff --git a/app/src/main/java/com/mg4/control/util/FirmwareHelper.kt b/app/src/main/java/com/mg4/control/util/FirmwareHelper.kt
index 7de87b7..35be1ca 100644
--- a/app/src/main/java/com/mg4/control/util/FirmwareHelper.kt
+++ b/app/src/main/java/com/mg4/control/util/FirmwareHelper.kt
@@ -1,7 +1,7 @@
 package com.mg4.control.util
 
 import android.content.Context
-import com.mg4.control.debug.AppLogger
+import com.mg4.hardware.AppLogger
 
 /**
  * Lit la version firmware du système d'infodivertissement.
diff --git a/app/src/main/java/com/mg4/control/util/FirmwareInfo.kt b/app/src/main/java/com/mg4/control/util/FirmwareInfo.kt
deleted file mode 100644
index 42a4e69..0000000
--- a/app/src/main/java/com/mg4/control/util/FirmwareInfo.kt
+++ /dev/null
@@ -1,129 +0,0 @@
-package com.mg4.control.util
-
-import android.content.Context
-
-/**
- * Détecte la génération de firmware à partir de ro.build.mt2712.version.
- *
- * SWI133 : "SWI133-xxxxx" — ADAS via getMixProperty(0x32), 5 modes, 2 alertes, sièges+volant chauffants
- * SWI132 : "SWI132-xxxxx" — ADAS via CarVehicleSettingClient (acc/tja getAccTjaState), alertes via binder
- *                            direct IVehicleSettingService (TX 0x128/0x12a), même section UI que SWI68
- * SWI68  : "SWI68-xxxxx"  — ADAS via VehicleSettingManager (acc/tja), sièges+volant chauffants
- * SWI69  : "SWI69-xxxxx"  — ADAS via VehicleSettingManager "nouvelle gen", sans sièges/volant chauffants
- * SWI131 : "SWI131-xxxxx" — Identique SWI69 (même package, même API), sans sièges/volant chauffants
- * SWI165 : "SWI165-xxxxx" — ADAS via VehicleSettingManager (même SDK que SWI68), AEB via setFcwAlarmMode
- *                            sièges+volant chauffants disponibles
- * UNKNOWN : firmware non reconnu — l'utilisateur peut forcer un mode de compatibilité
- */
-object FirmwareInfo {
-
-    enum class Gen { SWI133, SWI132, SWI68, SWI69, SWI131, SWI165, UNKNOWN }
-
-    private const val PREF_NAME       = "mg4_settings"
-    private const val PREF_FORCED_GEN = "forced_firmware_gen"
-
-    @Volatile private var cached:         Gen?    = null
-    @Volatile private var detectedString: String? = null
-
-    /**
-     * À appeler en premier dans MainActivity.onCreate(), avant toute inflation de fragment.
-     * Lit le choix forcé éventuel depuis les SharedPreferences et l'applique au cache.
-     */
-    fun initWithContext(context: Context) {
-        val forced = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE)
-            .getString(PREF_FORCED_GEN, null) ?: return
-        cached = runCatching { Gen.valueOf(forced) }.getOrDefault(Gen.UNKNOWN)
-    }
-
-    /** Retourne la génération active (forcée ou détectée automatiquement). */
-    fun getGeneration(): Gen {
-        cached?.let { return it }
-        val version = readProp("ro.build.mt2712.version")
-            ?: readProp("ro.build.version.incremental")
-        detectedString = version
-        val gen = when {
-            version == null               -> Gen.UNKNOWN
-            version.startsWith("SWI165")  -> Gen.SWI165
-            version.startsWith("SWI133")  -> Gen.SWI133
-            version.startsWith("SWI132")  -> Gen.SWI132   // avant SWI131 — startsWith("SWI13") serait ambigu
-            version.startsWith("SWI131")  -> Gen.SWI131
-            version.startsWith("SWI68")   -> Gen.SWI68
-            version.startsWith("SWI69")   -> Gen.SWI69
-            else                          -> Gen.UNKNOWN
-        }
-        cached = gen
-        return gen
-    }
-
-    /**
-     * Chaîne brute lue depuis les propriétés système (ex: "SWI131-12345-xxx").
-     * Utile pour afficher la version exacte à l'utilisateur dans le dialog de warning.
-     */
-    fun getDetectedString(): String {
-        if (detectedString == null) getGeneration()
-        return detectedString ?: "?"
-    }
-
-    /**
-     * Force le mode de compatibilité manuellement.
-     * Le choix est persisté dans les SharedPreferences et survit aux redémarrages.
-     */
-    fun forceGeneration(context: Context, gen: Gen) {
-        cached = gen
-        context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE)
-            .edit().putString(PREF_FORCED_GEN, gen.name).apply()
-    }
-
-    /**
-     * Retourne true si le mode de compatibilité a été forcé manuellement
-     * (par opposition à une détection automatique réussie).
-     */
-    fun isForced(context: Context): Boolean =
-        context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE)
-            .contains(PREF_FORCED_GEN)
-
-    // ── Helpers de capacités ─────────────────────────────────────────────────
-
-    /**
-     * SWI69 et SWI131 utilisent la même API "nouvelle génération" VSM :
-     *   package com.saicmotor.vehiclesetting.service
-     *   constructeur IBinder-direct
-     *   méthodes : setAccTjaState, setFcwState, setLasWarningSound…
-     */
-    fun isNewGenVsm(): Boolean {
-        val gen = getGeneration()
-        return gen == Gen.SWI69 || gen == Gen.SWI131
-    }
-
-    /**
-     * SWI68, SWI69, SWI131 et SWI165 utilisent tous le VehicleSettingManager SAIC
-     * pour l'ADAS (ACC/TJA) et les alertes sonores.
-     * SWI133 utilise VehiclePropertyManager (getMixProperty).
-     */
-    fun isVsmBased(): Boolean {
-        val gen = getGeneration()
-        return gen == Gen.SWI68 || gen == Gen.SWI69 || gen == Gen.SWI131 || gen == Gen.SWI132 || gen == Gen.SWI165
-    }
-
-    /**
-     * SWI133, SWI68 et SWI165 ont les sièges chauffants et le volant chauffant.
-     * SWI69 et SWI131 sont des finitions Standard/SE sans ces équipements.
-     */
-    fun hasHeatFeatures(): Boolean {
-        val gen = getGeneration()
-        return gen == Gen.SWI133 || gen == Gen.SWI68 || gen == Gen.SWI165
-    }
-
-    /**
-     * SWI165 utilise le même SDK VehicleSettingManager que SWI68.
-     * L'AEB est contrôlé par setFcwAlarmMode() (même API que SWI68).
-     * setAutoEmergencyBraking() existe dans le SDK mais n'est pas utilisé par l'app officielle.
-     */
-    fun isSWI165(): Boolean = getGeneration() == Gen.SWI165
-
-    private fun readProp(key: String): String? = try {
-        val sp  = Class.forName("android.os.SystemProperties")
-        val get = sp.getMethod("get", String::class.java, String::class.java)
-        (get.invoke(null, key, "") as? String)?.takeIf { it.isNotBlank() && it != "0" }
-    } catch (_: Exception) { null }
-}
diff --git a/app/src/test/java/com/mg4/control/ProguardRulesTest.kt b/app/src/test/java/com/mg4/control/ProguardRulesTest.kt
index e290add..635129a 100644
--- a/app/src/test/java/com/mg4/control/ProguardRulesTest.kt
+++ b/app/src/test/java/com/mg4/control/ProguardRulesTest.kt
@@ -34,8 +34,8 @@ class ProguardRulesTest {
             "android.os.ServiceManager",
             "android.os.SystemProperties",
             "com.saicmotor.**",
-            "com.mg4.control.model.**",
-            "com.mg4.control.hardware.MG4Hardware"
+            "com.mg4.hardware.model.**",
+            "com.mg4.hardware.MG4Hardware"
         ).forEach { target ->
             assertTrue("règle -keep manquante pour $target",
                 rules.contains("-keep class $target"))
diff --git a/app/src/test/java/com/mg4/control/debug/AppLoggerTest.kt b/app/src/test/java/com/mg4/control/debug/AppLoggerTest.kt
index fe83b0a..6699073 100644
--- a/app/src/test/java/com/mg4/control/debug/AppLoggerTest.kt
+++ b/app/src/test/java/com/mg4/control/debug/AppLoggerTest.kt
@@ -1,5 +1,6 @@
 package com.mg4.control.debug
 
+import com.mg4.hardware.AppLogger
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNotNull
 import org.junit.Assert.assertNull
diff --git a/app/src/test/java/com/mg4/control/debug/CrashLoggerTest.kt b/app/src/test/java/com/mg4/control/debug/CrashLoggerTest.kt
index 98ffd50..767ae5b 100644
--- a/app/src/test/java/com/mg4/control/debug/CrashLoggerTest.kt
+++ b/app/src/test/java/com/mg4/control/debug/CrashLoggerTest.kt
@@ -1,5 +1,6 @@
 package com.mg4.control.debug
 
+import com.mg4.hardware.AppLogger
 import androidx.test.core.app.ApplicationProvider
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertTrue
diff --git a/app/src/test/java/com/mg4/control/hardware/VehicleWriteGateTest.kt b/app/src/test/java/com/mg4/control/hardware/VehicleWriteGateTest.kt
index 392f5b9..e956484 100644
--- a/app/src/test/java/com/mg4/control/hardware/VehicleWriteGateTest.kt
+++ b/app/src/test/java/com/mg4/control/hardware/VehicleWriteGateTest.kt
@@ -1,6 +1,7 @@
 package com.mg4.control.hardware
 
-import com.mg4.control.hardware.VehicleWriteGate.Decision
+import com.mg4.hardware.VehicleWriteGate
+import com.mg4.hardware.VehicleWriteGate.Decision
 import org.junit.Assert.assertEquals
 import org.junit.Test
 
diff --git a/app/src/test/java/com/mg4/control/profile/ProfileConcurrencyTest.kt b/app/src/test/java/com/mg4/control/profile/ProfileConcurrencyTest.kt
index 8778690..468b323 100644
--- a/app/src/test/java/com/mg4/control/profile/ProfileConcurrencyTest.kt
+++ b/app/src/test/java/com/mg4/control/profile/ProfileConcurrencyTest.kt
@@ -1,9 +1,9 @@
 package com.mg4.control.profile
 
 import androidx.test.core.app.ApplicationProvider
-import com.mg4.control.model.DriveMode
-import com.mg4.control.model.DrivingProfile
-import com.mg4.control.model.RegenLevel
+import com.mg4.hardware.model.DriveMode
+import com.mg4.hardware.model.DrivingProfile
+import com.mg4.hardware.model.RegenLevel
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNotNull
 import org.junit.Assert.assertTrue
diff --git a/app/src/test/java/com/mg4/control/profile/ProfileManagerTest.kt b/app/src/test/java/com/mg4/control/profile/ProfileManagerTest.kt
index eee40d5..b4aaedd 100644
--- a/app/src/test/java/com/mg4/control/profile/ProfileManagerTest.kt
+++ b/app/src/test/java/com/mg4/control/profile/ProfileManagerTest.kt
@@ -1,9 +1,9 @@
 package com.mg4.control.profile
 
 import androidx.test.core.app.ApplicationProvider
-import com.mg4.control.model.DriveMode
-import com.mg4.control.model.DrivingProfile
-import com.mg4.control.model.RegenLevel
+import com.mg4.hardware.model.DriveMode
+import com.mg4.hardware.model.DrivingProfile
+import com.mg4.hardware.model.RegenLevel
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertNull
diff --git a/app/src/test/java/com/mg4/control/tasker/TaskerBridgeVerdictTest.kt b/app/src/test/java/com/mg4/control/tasker/TaskerBridgeVerdictTest.kt
index 16c0342..3e8ea92 100644
--- a/app/src/test/java/com/mg4/control/tasker/TaskerBridgeVerdictTest.kt
+++ b/app/src/test/java/com/mg4/control/tasker/TaskerBridgeVerdictTest.kt
@@ -1,6 +1,6 @@
 package com.mg4.control.tasker
 
-import com.mg4.control.hardware.VehicleWriteGate
+import com.mg4.hardware.VehicleWriteGate
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertTrue
 import org.junit.Test
diff --git a/app/src/test/java/com/mg4/control/update/ApkSecurityTest.kt b/app/src/test/java/com/mg4/control/update/ApkSecurityTest.kt
index 19f7bfd..67c5f12 100644
--- a/app/src/test/java/com/mg4/control/update/ApkSecurityTest.kt
+++ b/app/src/test/java/com/mg4/control/update/ApkSecurityTest.kt
@@ -1,5 +1,6 @@
 package com.mg4.control.update
 
+import com.mg4.hardware.AppLogger
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
 import org.junit.Test
diff --git a/settings.gradle.kts b/settings.gradle.kts
index a25ee6f..6ca0202 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -15,3 +15,8 @@ dependencyResolutionManagement {
 
 rootProject.name = "MG4Control"
 include(":app")
+
+// Shared vehicle layer, vendored as a git submodule at ./MG4Hardware and consumed as a
+// Gradle subproject. One implementation of MG4Hardware/VehicleWriteGate/FirmwareInfo/models.
+include(":mg4hardware")
+project(":mg4hardware").projectDir = file("MG4Hardware/lib")

From c1859b52d5ed9b8c9f82ac05c87f9ccac83db9c1 Mon Sep 17 00:00:00 2001
From: Malys <malys.training@gmail.com>
Date: Thu, 23 Jul 2026 10:23:36 +0200
Subject: [PATCH 04/13] chore: bump MG4Hardware submodule (English translation
 complete)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 MG4Hardware | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/MG4Hardware b/MG4Hardware
index 131a2e4..4a47fc7 160000
--- a/MG4Hardware
+++ b/MG4Hardware
@@ -1 +1 @@
-Subproject commit 131a2e4a834d638ec9cc9ee2ffbc6eefb21a9177
+Subproject commit 4a47fc7f16c063e56649f1b9b85a4b12c3e8e048

From 86526ff24dd722e2185ba2c6cebb089d408d189c Mon Sep 17 00:00:00 2001
From: Malys <malys.training@gmail.com>
Date: Thu, 23 Jul 2026 10:30:05 +0200
Subject: [PATCH 05/13] chore: bump MG4Hardware (WINDOW_POS id fix + English)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 MG4Hardware | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/MG4Hardware b/MG4Hardware
index 4a47fc7..2b639e8 160000
--- a/MG4Hardware
+++ b/MG4Hardware
@@ -1 +1 @@
-Subproject commit 4a47fc7f16c063e56649f1b9b85a4b12c3e8e048
+Subproject commit 2b639e84d5ae0353235dd89f3316fc2aa6905587

From ae4b4bd310d5f98e32c097c8257f77865b8b4bc3 Mon Sep 17 00:00:00 2001
From: Malys <malys.training@gmail.com>
Date: Thu, 23 Jul 2026 14:11:56 +0200
Subject: [PATCH 06/13] build: migrate to AGP 9.1.1 / Gradle 9.3.1 / built-in
 Kotlin
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- AGP 8.5.2 → 9.1.1, Gradle 9.0 → 9.3.1, compileSdk 34 → 36.
- Drop the standalone Kotlin plugin (AGP 9 built-in); jvmTarget via
  kotlin { compilerOptions }.
- Replace the removed applicationVariants output API; the release workflow
  now renames app-<flavor>-release.apk to MG4Control-<flavor>-<version>.apk.
- Remove deprecated android.enableJetifier.
- Bump MG4Hardware submodule to its AGP 9 build.

Builds + unit tests green. MUST pass the on-vehicle release check (R8 +
reflection + system UID) before shipping — the AGP/R8 major bump changes
shrinking/obfuscation and cannot be validated off the car.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .github/workflows/release.yml            |    7 +-
 MG4Hardware                              |    2 +-
 analysis/DIFF_2.7.0.full.diff            | 4318 ++++++++++++++++++++++
 app/build.gradle.kts                     |   22 +-
 build.gradle.kts                         |    2 +-
 gradle.properties                        |    1 -
 gradle/libs.versions.toml                |    2 +-
 gradle/wrapper/gradle-wrapper.properties |    2 +-
 mise.toml                                |    3 +-
 9 files changed, 4339 insertions(+), 20 deletions(-)
 create mode 100644 analysis/DIFF_2.7.0.full.diff

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 3dede97..39cab85 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -53,7 +53,12 @@ jobs:
       - name: Collect APKs
         run: |
           mkdir -p dist
-          find app/build/outputs/apk -name "MG4Control-*-*.apk" -exec cp {} dist/ \;
+          # AGP 9 emits app-<flavor>-release.apk; rename to the published convention.
+          for f in $(find app/build/outputs/apk -name "app-*-release.apk"); do
+            flavor=$(basename "$f" | sed -E 's/app-(.*)-release.apk/\1/')
+            ver=$(grep -oE 'versionName = "[^"]+"' app/build.gradle.kts | head -1 | sed -E 's/.*"([^"]+)"/\1/')
+            cp "$f" "dist/MG4Control-${flavor}-${ver}.apk"
+          done
           ls -la dist/
 
       - name: Upload APKs as workflow artifacts
diff --git a/MG4Hardware b/MG4Hardware
index 2b639e8..650c571 160000
--- a/MG4Hardware
+++ b/MG4Hardware
@@ -1 +1 @@
-Subproject commit 2b639e84d5ae0353235dd89f3316fc2aa6905587
+Subproject commit 650c57106933184ce51b9a5e329a88b3433f21e6
diff --git a/analysis/DIFF_2.7.0.full.diff b/analysis/DIFF_2.7.0.full.diff
new file mode 100644
index 0000000..9a49905
--- /dev/null
+++ b/analysis/DIFF_2.7.0.full.diff
@@ -0,0 +1,4318 @@
+===== app/src/main/java/com/mg4/control/MG4App.kt (+1/-7) =====
+20,23d19
+<         // ── Crash handler global ──────────────────────────────────────────────
+<         // Intercepte toute exception non gérée, écrit la stack trace + les logs
+<         // AppLogger dans filesDir/crash_log.txt, puis laisse le handler par défaut
+<         // terminer le processus normalement (Android affiche son propre écran de crash).
+33d28
+<         // ── Migration + initialisation du thème ───────────────────────────────
+37,38c32
+<             // Migration depuis l'ancien booléen "dark_theme" (version < 2.x)
+<             // Sur nouvelle installation : "auto" (tous les firmwares le supportent)
+---
+> 
+
+===== app/src/main/java/com/mg4/control/MainActivity.kt (+19/-68) =====
+11d10
+< import android.view.View
+13d11
+< import android.widget.Toast
+19,20d16
+< import com.mg4.control.update.UpdateChecker
+< import com.mg4.control.update.UpdateDialogManager
+36,37d31
+<         // Init firmware EN PREMIER — avant toute inflation de fragment
+<         // Charge le mode forcé éventuel depuis les prefs
+40d33
+<         // [THEME-AUTO] Recrée l'activité quand le launcher MG change de thème en mode "auto"
+43d35
+<         // Premier lancement : choix de la langue avant tout
+59,60c51
+<         setupDiagnosticUnlock()
+<         checkUnknownFirmware()  // après setupFirmwareChips pour que les chips soient prêtes
+---
+>         checkUnknownFirmware()
+65,84d55
+<     // ── Déblocage du bouton Diagnostic (5 clics sur le logo) ────────────────
+< 
+<     private var logoClickCount = 0
+< 
+<     private fun setupDiagnosticUnlock() {
+<         findViewById<View>(R.id.topbar_logo)?.setOnClickListener {
+<             if (diagnosticUnlocked) return@setOnClickListener
+<             logoClickCount++
+<             if (logoClickCount >= 5) {
+<                 logoClickCount = 0
+<                 diagnosticUnlocked = true
+<                 // Révèle immédiatement le bouton si l'onglet Réglages est déjà affiché
+<                 findViewById<View>(R.id.btn_diagnostic)?.visibility = View.VISIBLE
+<                 Toast.makeText(this, getString(R.string.diagnostic_unlocked), Toast.LENGTH_SHORT).show()
+<             }
+<         }
+<     }
+< 
+<     // ── Navigation vers l'écran par défaut au démarrage ─────────────────────
+< 
+86c57
+<         // Ne naviguer que si c'est un vrai démarrage (pas une rotation / recreate)
+---
+> 
+92c63
+<             // "dashboard" → rien à faire, c'est déjà le startDestination
+---
+> 
+96,97d66
+<     // ── Vérification de mise à jour au démarrage ──────────────────────────────
+< 
+99,100d67
+<         val prefs = getSharedPreferences("mg4_settings", android.content.Context.MODE_PRIVATE)
+<         if (!prefs.getBoolean("auto_check_update", true)) return
+102,110d68
+<         UpdateChecker.check(
+<             context = this,
+<             onUpdateAvailable = { updateInfo ->
+<                 if (!isFinishing && !isDestroyed) {
+<                     UpdateDialogManager.show(this, updateInfo)
+<                 }
+<             }
+<             // onNoUpdate et onError ignorés au démarrage — silencieux si tout va bien
+<         )
+113,114d70
+<     // ── Indicateur firmware (chips SWI133 / SWI68 / SWI69 / SWI131 / SWI165) ──
+< 
+140c96
+<             // Firmware inconnu sans choix forcé : chip cliquable, surlignée en rouge
+---
+> 
+152c108
+<                 // Les six chips en mode "à choisir" (rouge dim, aucune barrée)
+---
+> 
+175c131
+<             else -> { // SWI133 ou forcé SWI133
+---
+>             else -> {
+181d136
+<         // Chips cliquables si firmware inconnu (naturel ou forcé) pour changer de mode
+210,211d164
+<     // ── Dialog firmware non reconnu ───────────────────────────────────────────
+< 
+213c166
+<         // Ne montre le dialog que si le firmware est inconnu ET pas encore de choix forcé
+---
+> 
+220d172
+<         // Affiche la chaîne firmware brute dans le badge (ex: "SWI69-12345")
+236c188
+<             // L'utilisateur peut maintenant taper sur les chips SWI133/SWI68
+---
+> 
+242,243d193
+<     // ── Boutons de navigation dans la top-bar ─────────────────────────────────
+< 
+244a195
+>         val btnAudio     = findViewById<MaterialButton>(R.id.btn_nav_audio)
+248a200,206
+>         btnAudio.setOnClickListener {
+>             when (navController.currentDestination?.id) {
+>                 R.id.audioFragment -> navController.popBackStack(R.id.dashboardFragment, false)
+>                 else               -> navController.navigate(R.id.audioFragment)
+>             }
+>         }
+> 
+272a231,233
+>             btnAudio.backgroundTintList = android.content.res.ColorStateList.valueOf(
+>                 if (destination.id == R.id.audioFragment) accent else inactive
+>             )
+285,286d245
+<     // ── Dialogue de choix de langue au premier lancement ─────────────────────
+< 
+314,321d272
+<     }
+< 
+<     companion object {
+<         /**
+<          * Débloqué via 5 clics sur le logo en haut à gauche. En mémoire uniquement :
+<          * réinitialisé au redémarrage du process (le bouton Diagnostic reste masqué par défaut).
+<          */
+<         @Volatile var diagnosticUnlocked = false
+
+===== app/src/main/java/com/mg4/control/bluetooth/BluetoothProfileManager.kt (+1/-29) =====
+8,19d7
+< /**
+<  * [BT-PROFILES] Utilitaires Bluetooth pour la fonctionnalité de profils automatiques.
+<  *
+<  * Les associations Bluetooth ↔ Profil sont désormais stockées directement dans
+<  * [DrivingProfile.btDeviceMac] — ce fichier ne gère que :
+<  *   • le suivi en mémoire des appareils ACL connectés
+<  *   • la liste des appareils appairés (pour l'UI de l'éditeur de profil)
+<  *   • la requête HFP async (fix "première configuration")
+<  *
+<  * Pour supprimer la fonctionnalité : supprimer ce fichier + tous les blocs
+<  * marqués // [BT-PROFILES] dans les autres fichiers modifiés.
+<  */
+22,25d9
+<     // ── Appareils actuellement connectés (en mémoire) ─────────────────────────
+<     // Mis à jour depuis MG4ControlService via ACTION_ACL_CONNECTED/DISCONNECTED.
+<     // Remis à zéro si le service redémarre — le chemin HFP async compense ce cas.
+< 
+32,33d15
+<     // ── Appareils appairés ────────────────────────────────────────────────────
+< 
+36c18
+<     /** Retourne la liste des appareils Bluetooth appairés, triée par nom. */
+---
+>     
+48,57d29
+< 
+<     // ── Appareils HFP actuellement connectés (requête async) ─────────────────
+<     //
+<     // Utilisé dans applyProfileOnIgnition() quand connectedMacs est vide,
+<     // ce qui se produit si le téléphone était déjà connecté avant le démarrage
+<     // du service (première configuration, redémarrage du service AAOS).
+<     //
+<     // On utilise BluetoothProfile.HEADSET (profil HFP AG, rôle voiture) :
+<     // sur AAOS la voiture est l'Audio Gateway, les téléphones connectés sont
+<     // donc accessibles via ce profil. HEADSET_CLIENT n'est pas exposé sur AAOS.
+
+===== app/src/main/java/com/mg4/control/debug/AppLogger.kt (+0/-10) =====
+9,12d8
+< /**
+<  * In-app log buffer — mirrors every Log.* call to an in-memory ring buffer
+<  * so the ConsoleFragment can display them without ADB.
+<  */
+31,32d26
+<     // ---- Public log methods (mirror android.util.Log) ----
+< 
+43,44d36
+<     // ---- Listener for live UI updates ----
+< 
+47,48d38
+< 
+<     // ---- Internal ----
+
+===== app/src/main/java/com/mg4/control/debug/CrashLogger.kt (+5/-22) =====
+9,15d8
+< /**
+<  * Écrit la stack trace d'un crash non-géré dans un fichier sur le stockage interne,
+<  * accompagnée des 60 dernières lignes du buffer AppLogger pour contexte.
+<  *
+<  * Le fichier est lu par SettingsFragment → showDiagnosticDialog().
+<  * Utilisation : installer dans MG4App.onCreate() via Thread.setDefaultUncaughtExceptionHandler.
+<  */
+19,21c12
+<     private const val MAX_FILE_BYTES = 48_000   // ~48 Ko max pour éviter de saturer filesDir
+< 
+<     // ── Écriture (appelé depuis le UncaughtExceptionHandler) ─────────────────
+---
+>     private const val MAX_FILE_BYTES = 48_000
+35d25
+<         // ── Exception principale ──────────────────────────────────────────
+40d29
+<         // ── Causes (chaîne de causes) ─────────────────────────────────────
+52d40
+<         // ── Dernières entrées AppLogger ───────────────────────────────────
+64d51
+<         // ── Écriture sur disque ───────────────────────────────────────────
+67c54
+<             // Tronque à MAX_FILE_BYTES pour ne pas saturer le stockage
+---
+> 
+74c61
+<             // Dernier recours — on ne peut rien faire de plus ici
+---
+> 
+78,80c65
+<     // ── Lecture (appelé depuis SettingsFragment) ──────────────────────────────
+< 
+<     /** Retourne le contenu du crash log ou null si aucun crash n'a été enregistré. */
+---
+>     
+86c71
+<     /** Supprime le fichier de crash log. */
+---
+>     
+90,91d74
+< 
+<     // ── Utilitaires ───────────────────────────────────────────────────────────
+
+===== app/src/main/java/com/mg4/control/hardware/MG4Hardware.kt (+292/-698) =====
+1c1
+< package com.mg4.control.hardware
+---
+> package com.mg4.control.hardware
+14a15,18
+> import java.util.concurrent.atomic.AtomicInteger
+> import kotlinx.coroutines.CoroutineScope
+> import kotlinx.coroutines.Dispatchers
+> import kotlinx.coroutines.launch
+16,24d19
+< /**
+<  * Hardware abstraction layer for MG4 vehicle control.
+<  * Reconstructed from DriveHub Dort 0.9 smali.
+<  *
+<  * Three communication layers (mirrors original exactly):
+<  *  Katman1 — android.car.Car → CarPropertyManager / CarHvacManager (async ServiceConnection)
+<  *  Katman2 — ServiceManager.getService("vehiclesetting") → raw IBinder (often SELinux-blocked)
+<  *  Katman3 — bindService(VehicleService) → IHubService → sub-services (not needed for our use case)
+<  */
+29d23
+<     // Area IDs
+33d26
+<     // Vehicle property IDs
+41d33
+<     // SAIC binder transaction codes
+51d42
+<     // ADAS property IDs — SWI133 (getMixProperty / getIntProperty)
+56,63d46
+<     // ELK — Assistant de sortie de voie (SWI133)
+<     // Accès via IVehicleSettingService binder (sVehicleBinder) — smali IVehicleSettingService$Stub$Proxy
+<     // getLaneKeepingAsstMode()   → TX 0x53 (synchrone, reply: readException + readInt)
+<     // setLaneKeepingAsstMode(I)  → TX 0x54 (ONEWAY, data: writeInt(value))
+<     // getLaneKeepingAsstSen()    → TX 0x55 (synchrone)
+<     // setLaneKeepingAsstSen(I)   → TX 0x56 (ONEWAY)
+<     // Mode  : 1=OFF, 2=Alerte(LDW), 3=Aider(LDP), 5=Maintien d'urgence(ELK)
+<     // Sen   : 1=Faible, 2=Standard, 3=Élevé
+69,71d51
+<     // SWI132 binder TX codes (IVehicleSettingService — DESCRIPTOR_VSM132, two-way flag=0x0)
+<     // Setters : 0x057=setSLIFWarningState, 0x128=setOverSpeedSoundMode, 0x12a=setSpeedLimitSoundMode
+<     // Getters : 0x058=getSLIFWarningState, 0x129=getOverSpeedSoundMode, 0x12b=getSpeedLimitSoundMode
+79c59
+<     /** Valeurs du mode ELK (LaneKeepingAsstMode). */
+---
+>     
+81,84c61,64
+<         const val OFF       = 1   // Désactivé
+<         const val ALERT     = 2   // Alerte (LDW)
+<         const val ASSIST    = 3   // Aider (LDP)
+<         const val EMERGENCY = 5   // Maintien d'urgence (ELK)
+---
+>         const val OFF       = 1
+>         const val ALERT     = 2
+>         const val ASSIST    = 3
+>         const val EMERGENCY = 5
+87c67
+<     /** Valeurs de sensibilité ELK. */
+---
+>     
+89,111c69,83
+<         const val LOW      = 1   // Faible
+<         const val STANDARD = 2   // Standard
+<         const val HIGH     = 3   // Élevé
+<     }
+< 
+<     // AEB — Système anti-collision avant (SWI133)
+<     // PROP_AEB_SWITCH    : CarPropertyManager, AREA_GLOBAL, 1=OFF / 2=ON
+<     private const val PROP_AEB_SWITCH    = 0x2140a108  // AAD_FRONT_COLLISION_ASST_SYS (CPM)
+<     // PROP_AEB_SYS_MODE  : VPM, ID_AAD_FRONT_COLLISION_ASST_SYS, 1=Alerte / 2=Alerte+Freinage
+<     // PROP_AEB_MODE      : VPM, ID_AAD_AUTO_EME_BREAK,            1=Alerte / 2=Alerte+Freinage
+<     // Le smali vehiclesettings écrit toujours les deux simultanément via setIntPropertyRecovery
+<     private const val PROP_AEB_SYS_MODE    = 0x302000a  // ID_AAD_FRONT_COLLISION_ASST_SYS (VPM)
+<     private const val PROP_AEB_MODE        = 0x302000b  // ID_AAD_AUTO_EME_BREAK (VPM)
+<     // PROP_AEB_SENSITIVITY : VPM, ForwardCollisionAsstSentItem, 1=Faible / 2=Standard / 3=Élevé
+<     private const val PROP_AEB_SENSITIVITY = 0x302000e  // ID_AAD_FRONT_COLLISION_ASST_SEN (VPM)
+< 
+<     // TSR — Reconnaissance des panneaux de vitesse (SLIF Warning)
+<     // SWI133 : VPM toggle 0/1 ; SWI68/SWI165 : VSM setSpeedAsstSlifWarning ; SWI69/SWI131 : VSM setSLIFWarningState (inversé)
+<     private const val PROP_TSR_MODE = 0x5030049  // ID_AAD_SLIF_WARNING
+< 
+<     // Économie d'énergie (Endurance Mode / Longer Endurance)
+<     // SWI133 : VPM PROP_ENERGY_SAVING ; SWI69/SWI131 : VSM setEnduranceMode ; SWI68/SWI165 : VSM setLongerEndurance
+<     private const val PROP_ENERGY_SAVING = 0x5030007  // ID_LONGER_ENDURANCE_MODE
+---
+>         const val LOW      = 1
+>         const val STANDARD = 2
+>         const val HIGH     = 3
+>     }
+> 
+>     private const val PROP_AEB_SWITCH    = 0x2140a108
+> 
+>     private const val PROP_AEB_SYS_MODE    = 0x302000a
+>     private const val PROP_AEB_MODE        = 0x302000b
+> 
+>     private const val PROP_AEB_SENSITIVITY = 0x302000e
+> 
+>     private const val PROP_TSR_MODE = 0x5030049
+> 
+>     private const val PROP_ENERGY_SAVING = 0x5030007
+113d84
+<     // SWI68 : VehicleSettingManager class name (loaded via launcher context)
+117,127d87
+<     // Luminosité écran — ancien SDK (SWI133/68/165) : GeneralManager.setBrightness(Int)/getBrightness().
+<     // Plage native 0..255 (constantes DARKEST_VALUE=0x0 / BRIGHTEST_VALUE=0xff confirmées dans le smali).
+<     // A9 (SWI132/131/69) = phase 2 (setScreenBrightness(III), params non décodables sans SystemUI).
+<     private const val GENERAL_MANAGER_CLASS = "com.saicmotor.sdk.systemsettings.GeneralManager"
+<     private const val BRIGHTNESS_NATIVE_MAX = 255
+<     private const val BRIGHTNESS_MIN_PERCENT = 5   // plancher de sécurité : ne jamais éteindre l'écran
+< 
+<     // SWI69/SWI131 : accès via CarAdapterClient → queryClient(0x8) → CarVehicleSettingClient
+<     // Architecture réelle : CarAdapterClient se connecte à com.saicmotor.caradapter.CarAdapterService,
+<     // puis queryClient(code) retourne l'IBinder pour chaque service.
+<     // Code 0x8 = CarVehicleSettingClient (vérifié dans VehicleSettingService.onResult() smali)
+131,132c91,92
+<     private const val VSM_SERVICE_CODE    = 0x8   // queryClient(0x8) → ICarVehicleSettingService
+<     private const val VEHICLE_SETTING_PKG = "com.saicmotor.vehiclesetting"  // SWI131 : carapi dans VS
+---
+>     private const val VSM_SERVICE_CODE    = 0x8
+>     private const val VEHICLE_SETTING_PKG = "com.saicmotor.vehiclesetting"
+134d93
+<     // Katman5 — VehicleConditionManager (IVehicleConditionService via IHubService "vehiclecondition")
+138d96
+<     // Katman5 SWI69/SWI131 — ICarGeneralService via CarAdapterClient (queryClient(0x1))
+140c98
+<     private const val BIND_CODE_CAR_GENERAL    = 0x1   // ICarAdapterService.queryClient(0x1)
+---
+>     private const val BIND_CODE_CAR_GENERAL    = 0x1
+142d99
+<     // Standard AAOS — VehicleProperty.IGNITION_STATE (compatible tous firmwares via CarPropertyManager)
+145c102
+<     /** Valeurs de IGNITION_STATE (VehicleIgnitionState) — propriété AAOS standard. */
+---
+>     
+151c108
+<         const val ON        = 4   // Clé détectée + frein appuyé = état READY
+---
+>         const val ON        = 4
+155,158c112
+<     /**
+<      * Valeurs retournées par IVehicleConditionService.getVehicleIgnition() (Katman5).
+<      * Source : VehicleConditionConst.smali + CarIgnitionItem.smali (SWI133 launcher).
+<      */
+---
+>     
+160,175c114,117
+<         const val OFF       = 0x0   // Voiture éteinte
+<         const val ACCESSORY = 0x1   // Accessoires uniquement
+<         const val RUN       = 0x2   // Clé ON / état READY
+<         const val CRANK     = 0x3   // Démarrage
+<     }
+< 
+<     /**
+<      * Limiteur de vitesse (Speed Assist System / SAS) — réglage INDÉPENDANT du mode ACC/TJA.
+<      * Sur SWI132 il est piloté par setSasMode (et NON par setAccTjaState/SHWA, qui ne l'active pas).
+<      * Valeurs confirmées dans le smali SWI132 (SasModel / sas_modes) :
+<      *   0 = Désactivé, 2 = Manuel, 3 = Intelligent  (1 = avert. vitesse, modèles TW uniquement)
+<      */
+<     object SasMode {
+<         const val OFF         = 0
+<         const val MANUEL      = 2
+<         const val INTELLIGENT = 3
+---
+>         const val OFF       = 0x0
+>         const val ACCESSORY = 0x1
+>         const val RUN       = 0x2
+>         const val CRANK     = 0x3
+178c120
+<     /** Valeurs de mode ADAS pour firmware SWI68/SWI132 (CarAccTja constants). */
+---
+>     
+180,183c122,125
+<         const val OFF  = 0x4   // Désactiver
+<         const val SHWA = 0x3   // Speed Limit Mode (Limiteur) — SWI132 uniquement
+<         const val ACC  = 0x1   // ACC
+<         const val TJA  = 0x2   // TJA (Traffic Jam Assist) = ICA dans l'UI SWI132
+---
+>         const val OFF  = 0x4
+>         const val SHWA = 0x3
+>         const val ACC  = 0x1
+>         const val TJA  = 0x2
+186c128
+<     /** Valeurs du mode AEB (communes SWI133 + SWI68). */
+---
+>     
+188,189c130,131
+<         const val ALARM       = 1   // Alerte seule (FCW)
+<         const val ALARM_BRAKE = 2   // Alerte + Freinage automatique d'urgence
+---
+>         const val ALARM       = 1
+>         const val ALARM_BRAKE = 2
+192c134
+<     /** Valeurs de sensibilité AEB — SWI133 uniquement (PROP_AEB_SENSITIVITY = 0x302000e). */
+---
+>     
+194,196c136,138
+<         const val LOW      = 1   // Faible
+<         const val STANDARD = 2   // Standard
+<         const val HIGH     = 3   // Élevé
+---
+>         const val LOW      = 1
+>         const val STANDARD = 2
+>         const val HIGH     = 3
+204,210c146,150
+<     @Volatile private var sVpm: Any? = null          // VehiclePropertyManager instance (SWI133, Katman4)
+<     @Volatile private var sVpmService: Any? = null   // mIVehiclePropertyService field value (SWI133)
+<     @Volatile private var sVsm: Any? = null          // VehicleSettingManager instance (SWI68, Katman4)
+<     @Volatile private var sVsmService: Any? = null   // mVehicleSettingService field value (SWI68)
+<     @Volatile private var sVsm133: Any? = null       // VehicleSettingManager instance (SWI133, pour ELK)
+<     @Volatile private var sGeneral: Any? = null      // GeneralManager instance (SWI133/68/165, luminosité)
+<     @Volatile private var sCarGeneral: Any? = null   // CarGeneralClient instance (A9 SWI132/131/69, luminosité)
+---
+>     @Volatile private var sVpm: Any? = null
+>     @Volatile private var sVpmService: Any? = null
+>     @Volatile private var sVsm: Any? = null
+>     @Volatile private var sVsmService: Any? = null
+>     @Volatile private var sVsm133: Any? = null
+218d157
+<     // ── Katman5 — IGNITION_STATE via CarPropertyManager (standard AAOS) ──────
+223d161
+<     // ── Katman5 — VehicleConditionManager / ICarGeneralService ───────────────
+227c165,166
+<     @Volatile private var sLastVcmIgnitionState = -1   // filtre les faux RUN répétés
+---
+> 
+>     private val sLastVcmIgnitionState = AtomicInteger(-1)
+231c170
+<     /** Listeners notifiés dès que Katman1 (CPM + HVAC) est opérationnel. */
+---
+>     
+234c173
+<     /** Listeners notifiés dès que Katman4 (mIVehiclePropertyService) est opérationnel. */
+---
+>     
+237,240c176
+<     /**
+<      * Exécute [action] dès que CarPropertyManager et CarHvacManager sont disponibles.
+<      * Si déjà prêt, exécution immédiate. Sinon, mis en file et déclenché à la connexion.
+<      */
+---
+>     
+249,252c185
+<     /**
+<      * Exécute [action] dès que le service ADAS (Katman4) est disponible.
+<      * SWI133 → mIVehiclePropertyService ; SWI68/SWI69/SWI131 → mVehicleSettingService
+<      */
+---
+>     
+258c191
+<     /** Exécute [action] dès que Katman5 (IVehicleConditionService) est opérationnel. */
+---
+>     
+263c196,203
+<     /** Enregistre un callback invoqué à chaque changement d'état d'allumage (CarIgnitionItem). */
+---
+>     
+>     fun clearPendingReadyListeners() {
+>         katman1ReadyListeners.clear()
+>         katman4ReadyListeners.clear()
+>         katman5ReadyListeners.clear()
+>     }
+> 
+>     
+272c212
+<     /** Enregistre un callback sur IGNITION_STATE via CarPropertyManager (standard AAOS). */
+---
+>     
+282c222
+<     /** Désenregistre le proxy CarPropertyManager (appeler depuis Service.onDestroy). */
+---
+>     
+299,302c239
+<     /**
+<      * Lit l'état d'allumage courant via CarPropertyManager.
+<      * Retourne -1 si CPM non prêt, 0 si propriété non supportée.
+<      */
+---
+>     
+315,318d251
+<     // -------------------------------------------------------------------------
+<     // Init
+<     // -------------------------------------------------------------------------
+< 
+328,330c261,263
+<             FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI165 -> initKatman4Swi68(context)  // même SDK que SWI68
+<             FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132 -> initKatman4Swi69(context)  // CarVehicleSettingClient, même path que SWI69
+<             FirmwareInfo.isNewGenVsm()                              -> initKatman4Swi69(context)   // SWI69 + SWI131
+---
+>             FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI165 -> initKatman4Swi68(context)
+>             FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132 -> initKatman4Swi69(context)
+>             FirmwareInfo.isNewGenVsm()                              -> initKatman4Swi69(context)
+333,334c266
+<         // Katman5 — détection IGNITION_STATE push (VehicleConditionManager ou ICarGeneralService)
+<         // SWI132 utilise ICarGeneralService (même path que SWI69/SWI131) — VehicleConditionManager absent de son smali
+---
+> 
+342a275
+>         initAudio(context)
+346,349d278
+<     // -------------------------------------------------------------------------
+<     // Katman1 — android.car.Car (async, mirrors original bindCarService exactly)
+<     // -------------------------------------------------------------------------
+< 
+367d295
+<         // Attempt 1: createCar(Context)
+373d300
+<         // Attempt 2: createCar(Context, Handler)
+382d308
+<         // Attempt 3: createCar(Context, ServiceConnection) — async, callback fires when connected
+416d341
+<         // Call car.connect() if available (required on older builds)
+421c346
+<             // connect() not present on all builds, ignore
+---
+> 
+426d350
+<         // Try sync managers immediately
+429d352
+<         // Schedule retries — délais étendus pour couvrir le boot lent du Car service SAIC
+441c364
+<         if (sCarPropertyManager != null && sCarHvacManager != null) return // already done
+---
+>         if (sCarPropertyManager != null && sCarHvacManager != null) return
+475d397
+<             // Notifier les abonnés whenKatman1Ready dès que les deux managers sont prêts
+482d403
+<             // Tentative d'enregistrement du callback IGNITION_STATE (best-effort)
+489,492d409
+<     // -------------------------------------------------------------------------
+<     // Katman2 — ServiceManager raw binder
+<     // -------------------------------------------------------------------------
+< 
+506,509d422
+<     // -------------------------------------------------------------------------
+<     // Katman4 — VehiclePropertyManager via saicmotor.hmi.launcher context
+<     // -------------------------------------------------------------------------
+< 
+529,530d441
+<         // ---- Constructeurs (priorité) ----
+<         // 1) ctor(launcherCtx) — most likely for a class bundled in the launcher APK
+534c445
+<         // 2) ctor(appCtx)
+---
+> 
+538c449
+<         // 3) ctor() no-arg
+---
+> 
+543d453
+<         // ---- Méthodes statiques de factory ----
+562d471
+<         // 1) bindService() — connecte au service véhicule (async)
+565d473
+<         // 2) init(Context, IVehicleServiceListener) via dynamic proxy — reçoit onServiceConnected
+568d475
+<         // 3) VehicleSettingManager pour SWI133 (ELK) — même singleton que SWI68
+571,574d477
+<         // 3b) GeneralManager pour SWI133 (luminosité écran)
+<         tryInitGeneralManager(launcherCtx, context)
+< 
+<         // 4) Retries pour récupérer mIVehiclePropertyService et VSM133 une fois le service connecté
+580d482
+<                 if (sGeneral == null) tryInitGeneralManager(launcherCtx, context)
+591d492
+<         // Log all methods for diagnostics
+597d497
+<         // Strategy 1: Inspect the actual init() signature to get the real listener type
+607d506
+<             // Try dynamic proxy with the actual listener interface type
+634d532
+<             // Fallback: try init(Context, null) — works if listener is nullable
+644d541
+<         // Strategy 2: init(Context) single-param
+654d550
+<         // Strategy 3: init() no-arg
+667c563
+<     /** Exécute [block], retourne le résultat ou null, log le résultat/erreur. */
+---
+>     
+687c583
+<                     // Notify any pending Katman4 listeners
+---
+> 
+697,702d592
+<     // -------------------------------------------------------------------------
+<     // -------------------------------------------------------------------------
+<     // SWI133 — VehicleSettingManager (ELK : getLaneKeepingAsstMode / setLaneKeepingAsstMode)
+<     // Même singleton que SWI68 mais initialisé dans le chemin SWI133.
+<     // -------------------------------------------------------------------------
+< 
+708d597
+<             // Tentative 1 : lire le singleton déjà initialisé par le launcher
+718d606
+<             // Tentative 2 : appeler init() nous-mêmes (comme SWI68)
+748,886c636
+<     // -------------------------------------------------------------------------
+<     // Luminosité écran — GeneralManager (ancien SDK SWI133/68/165)
+<     // GeneralManager.init(Context, ISettingsServiceListener) — singleton sInstance.
+<     // Même pattern que tryInitVsm133 ; chargé depuis le launcher com.saicmotor.hmi.launcher.
+<     // -------------------------------------------------------------------------
+< 
+<     private fun tryInitGeneralManager(launcherCtx: Context, appCtx: Context) {
+<         if (sGeneral != null) return
+<         try {
+<             val cls = launcherCtx.classLoader.loadClass(GENERAL_MANAGER_CLASS)
+< 
+<             // Tentative 1 : singleton déjà initialisé
+<             val f = cls.getDeclaredField("sInstance")
+<             f.isAccessible = true
+<             f.get(null)?.let {
+<                 sGeneral = it
+<                 AppLogger.i(TAG, "  GeneralManager singleton ✓")
+<                 return
+<             }
+< 
+<             // Tentative 2 : init(Context, ISettingsServiceListener) — proxy dynamique
+<             val initMethod = cls.methods.firstOrNull { m ->
+<                 m.name == "init" && m.parameterCount == 2 &&
+<                 Context::class.java.isAssignableFrom(m.parameterTypes[0])
+<             } ?: run {
+<                 AppLogger.w(TAG, "  GeneralManager init() non trouvé")
+<                 return
+<             }
+<             val listenerType = initMethod.parameterTypes[1]
+<             val listener = if (listenerType.isInterface) {
+<                 java.lang.reflect.Proxy.newProxyInstance(listenerType.classLoader, arrayOf(listenerType)) { _, method, _ ->
+<                     if (method.name == "onServiceConnected") {
+<                         try {
+<                             f.get(null)?.let { sGeneral = it }
+<                             AppLogger.i(TAG, "  GeneralManager onServiceConnected — sGeneral=${if (sGeneral != null) "OK ✓" else "null"}")
+<                         } catch (_: Exception) {}
+<                     }
+<                     null
+<                 }
+<             } else null
+<             initMethod.invoke(null, appCtx, listener)
+<             // init() crée sInstance immédiatement (service connecté de façon asynchrone ensuite)
+<             f.get(null)?.let { sGeneral = it }
+<             AppLogger.i(TAG, "  GeneralManager.init() called — sGeneral=${if (sGeneral != null) "OK ✓" else "null"}")
+<         } catch (e: Exception) {
+<             AppLogger.d(TAG, "  tryInitGeneralManager exc: ${e.message}")
+<         }
+<     }
+< 
+<     /** A9 (SWI132/131/69) : luminosité via CarGeneralClient.setScreenBrightness(mode,day,night). */
+<     private fun isA9Brightness(): Boolean =
+<         FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132
+< 
+<     /** Luminosité écran disponible : ancien SDK (133/68/165) ou A9 (132/131/69). */
+<     fun hasBrightnessControl(): Boolean = FirmwareInfo.getGeneration() != FirmwareInfo.Gen.UNKNOWN
+< 
+<     /** Lit la luminosité écran en % (0–100), ou -1 si indisponible. */
+<     fun getScreenBrightnessPercent(): Int =
+<         if (isA9Brightness()) getBrightnessA9() else getBrightnessOldSdk()
+< 
+<     /**
+<      * Règle la luminosité écran en % (0–100). Plancher de sécurité à BRIGHTNESS_MIN_PERCENT
+<      * pour ne jamais éteindre l'écran.
+<      */
+<     fun setScreenBrightnessPercent(pct: Int): Boolean {
+<         val clamped = pct.coerceIn(BRIGHTNESS_MIN_PERCENT, 100)
+<         return if (isA9Brightness()) setBrightnessA9(clamped) else setBrightnessOldSdk(clamped)
+<     }
+< 
+<     // ── Ancien SDK (SWI133/68/165) — GeneralManager.setBrightness(Int), plage native 0..255 ──
+< 
+<     private fun getBrightnessOldSdk(): Int {
+<         val g = sGeneral ?: return -1
+<         return try {
+<             val native = (g.javaClass.getMethod("getBrightness").invoke(g) as? Int) ?: return -1
+<             if (native < 0) return -1
+<             val pct = (native * 100 / BRIGHTNESS_NATIVE_MAX).coerceIn(0, 100)
+<             AppLogger.d(TAG, "  getBrightness native=$native → $pct%")
+<             pct
+<         } catch (e: Exception) {
+<             AppLogger.w(TAG, "  getBrightness exc: ${e.message}")
+<             -1
+<         }
+<     }
+< 
+<     private fun setBrightnessOldSdk(clampedPct: Int): Boolean {
+<         val g = sGeneral ?: return false
+<         val native = (clampedPct * BRIGHTNESS_NATIVE_MAX / 100).coerceIn(0, BRIGHTNESS_NATIVE_MAX)
+<         if (logEnabled) AppLogger.i(TAG, "setBrightness → $clampedPct% (native=$native/255)")
+<         return try {
+<             g.javaClass.getMethod("setBrightness", Int::class.javaPrimitiveType).invoke(g, native)
+<             true
+<         } catch (e: Exception) {
+<             AppLogger.w(TAG, "  setBrightness exc: ${e.message}")
+<             false
+<         }
+<     }
+< 
+<     // ── A9 (SWI132/131/69) — luminosité via Settings.System.SCREEN_BRIGHTNESS ──
+<     // L'app Settings A9 (GeneralModel.setBrightness) pilote réellement la dalle par
+<     // Settings.System.putInt("screen_brightness", 0..255) + passage en mode manuel.
+<     // CarGeneralClient.setScreenBrightness(mode,day,night) ne stocke que le jour/nuit
+<     // et n'a AUCUN effet sur la dalle (confirmé par les logs SWI132 : valeur lue=0,
+<     // aucun changement visuel). L'app étant uid.system, elle peut écrire Settings.System.
+<     private const val A9_BRIGHTNESS_NATIVE_MAX = 255
+< 
+<     private fun getBrightnessA9(): Int {
+<         val resolver = sAppContext?.contentResolver ?: return -1
+<         val native = try {
+<             android.provider.Settings.System.getInt(resolver, android.provider.Settings.System.SCREEN_BRIGHTNESS)
+<         } catch (e: Exception) {
+<             AppLogger.w(TAG, "  A9 getBrightness Settings.System exc: ${e.message}"); return -1
+<         }
+<         if (native < 0) return -1
+<         return (native * 100 / A9_BRIGHTNESS_NATIVE_MAX).coerceIn(0, 100)
+<     }
+< 
+<     private fun setBrightnessA9(clampedPct: Int): Boolean {
+<         val resolver = sAppContext?.contentResolver ?: return false
+<         val native = (clampedPct.coerceIn(0, 100) * A9_BRIGHTNESS_NATIVE_MAX / 100).coerceIn(1, A9_BRIGHTNESS_NATIVE_MAX)
+<         return try {
+<             // Mode manuel, sinon l'auto-luminosité écrase aussitôt la valeur
+<             android.provider.Settings.System.putInt(resolver,
+<                 android.provider.Settings.System.SCREEN_BRIGHTNESS_MODE,
+<                 android.provider.Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL)
+<             android.provider.Settings.System.putInt(resolver,
+<                 android.provider.Settings.System.SCREEN_BRIGHTNESS, native)
+<             if (logEnabled) AppLogger.i(TAG, "A9 brightness → Settings.System.SCREEN_BRIGHTNESS=$native ($clampedPct%)")
+<             true
+<         } catch (e: Exception) {
+<             AppLogger.w(TAG, "  A9 setBrightness Settings.System exc: ${e.message}")
+<             false
+<         }
+<     }
+< 
+<     /**
+<      * Appelle une méthode sur sVsm133 par réflexion.
+<      * Retourne la valeur (Int pour getters, null pour setters void) ou null si erreur.
+<      */
+---
+>     
+898,900d647
+<     // Katman4 SWI68 — VehicleSettingManager via saicmotor.hmi.launcher context
+<     // -------------------------------------------------------------------------
+< 
+918d664
+<         // Appel static : VehicleSettingManager.init(Context, IVehicleServiceListener)
+950d695
+<         // Récupère le singleton depuis le champ statique sVehicleSettingManager
+962,965d706
+<         // GeneralManager pour SWI68/SWI165 (luminosité écran) — même launcher context
+<         tryInitGeneralManager(launcherCtx, context)
+< 
+<         // Retries pour récupérer mVehicleSettingService et le singleton si pas encore prêt
+978d718
+<                 if (sGeneral == null) tryInitGeneralManager(launcherCtx, context)
+1003,1015d742
+<     // -------------------------------------------------------------------------
+<     // Katman4 SWI69/SWI131 — CarVehicleSettingClient via CarAdapterClient
+<     //
+<     // Architecture réelle (vérifiée dans smali) :
+<     //   CarAdapterClient.getInstance(ctx).start()
+<     //   → bindService(com.saicmotor.caradapter / CarAdapterService)
+<     //   → onResult(0=OK) : queryClient(0x8) → IBinder (ICarVehicleSettingService)
+<     //   → new CarVehicleSettingClient(ibinder)
+<     //
+<     // CarVehicleSettingClient expose exactement les mêmes méthodes que VehicleSettingManager
+<     // (getAccTjaState, setAccTjaState, getLasWarningSound, getFcwState, etc.)
+<     // -------------------------------------------------------------------------
+< 
+1036d762
+<         // Obtenir le singleton CarAdapterClient
+1049d774
+<         // Enregistrer le ServiceConnListener (onResult(0) = connecté)
+1071d795
+<         // Démarrer la connexion à CarAdapterService
+1076d799
+<         // Tentative immédiate si CarAdapterService était déjà connecté
+1079d801
+<         // Retries échelonnés
+1088,1091c810
+<     /**
+<      * Tente d'obtenir un CarVehicleSettingClient via queryClient(0x8).
+<      * Appelée à la connexion (onResult=0) et lors des retries.
+<      */
+---
+>     
+1131,1136c850
+<     /**
+<      * Appelle une méthode void sur sVsm par réflexion.
+<      * Contrairement à callVsm(), retourne true si la méthode existe et s'exécute sans exception,
+<      * même si invoke() retourne null (comportement normal pour les méthodes void).
+<      * Retourne false si sVsm est null ou si une exception est levée (méthode introuvable, etc.).
+<      */
+---
+>     
+1142c856
+<             true   // méthode trouvée et appelée sans exception → succès
+---
+>             true
+1166c880
+<     /** Variante avec recovery — utilisée par vehiclesettings pour les propriétés FCW/AEB. */
+---
+>     
+1175c889
+<             // Fallback sur setIntProperty si setIntPropertyRecovery absent
+---
+> 
+1181,1235d894
+<     // ── Alimentation véhicule (mise hors tension, infodivertissement maintenu) ─
+<     // Reproduit le bouton "Vehicle Power → Off" du launcher MG (onglet Safety).
+<     // Valeur 2 sur les 6 firmwares ; seul le chemin d'accès diffère :
+<     //   • SWI133        : VehiclePropertyManager.setIntPropertyRecovery(0x6030021, 2)
+<     //   • SWI68/SWI165  : VehicleSettingManager.setPowerModeSwitch(2)
+<     //   • A9 (132/131/69): CarAdapterClient.queryClient(0xf) → CarComfortabletClient.setPowerModeSwitch(2)
+<     // Le véhicule n'exécute la coupure qu'à l'arrêt en position P (garde côté firmware).
+<     private const val PROP_POWER_MODE_SWITCH    = 0x6030021   // ID_POWER_MODE_SWITCH (SWI133)
+<     private const val POWER_MODE_OFF            = 2
+<     private const val COMFORTABLET_CLIENT_CLASS = "com.saicmotor.carapi.client.CarComfortabletClient"
+<     private const val CAR_ADAPTER_CLIENT_CLASS  = "com.saicmotor.carapi.CarAdapterClient"
+<     private const val COMFORTABLET_SERVICE_CODE = 0xf
+< 
+<     /** Disponible sur tous les firmwares connus. */
+<     fun hasVehiclePowerOff(): Boolean =
+<         FirmwareInfo.getGeneration() != FirmwareInfo.Gen.UNKNOWN
+< 
+<     /** Coupe l'alimentation du véhicule tout en gardant l'écran/infodivertissement actif. */
+<     fun vehiclePowerOff(): Boolean {
+<         val gen = FirmwareInfo.getGeneration()
+<         AppLogger.i(TAG, "vehiclePowerOff (gen=$gen)")
+<         return when {
+<             gen == FirmwareInfo.Gen.SWI133 ->
+<                 setIntPropertyVpmRecovery(PROP_POWER_MODE_SWITCH, POWER_MODE_OFF)
+<             gen == FirmwareInfo.Gen.SWI68 || gen == FirmwareInfo.Gen.SWI165 ->
+<                 // sVsm = VehicleSettingManager (vieux SDK)
+<                 callVsmVoid("setPowerModeSwitch", POWER_MODE_OFF)
+<             FirmwareInfo.isNewGenVsm() || gen == FirmwareInfo.Gen.SWI132 ->
+<                 vehiclePowerOffA9()
+<             else -> false
+<         }
+<     }
+< 
+<     /** A9 (SWI132/131/69) : obtient CarComfortabletClient via l'adaptateur carapi et coupe l'alim. */
+<     private fun vehiclePowerOffA9(): Boolean {
+<         val cl = sVsm?.javaClass?.classLoader ?: run {
+<             AppLogger.w(TAG, "  A9 power-off: sVsm/classloader null"); return false
+<         }
+<         return try {
+<             val adapterClass = cl.loadClass(CAR_ADAPTER_CLIENT_CLASS)
+<             val adapter = adapterClass.getMethod("getInstance", Context::class.java).invoke(null, sAppContext)
+<             val binder = adapterClass.getMethod("queryClient", Int::class.javaPrimitiveType)
+<                 .invoke(adapter, COMFORTABLET_SERVICE_CODE) as? android.os.IBinder
+<                 ?: run { AppLogger.w(TAG, "  A9 power-off: queryClient(0xf) null"); return false }
+<             val comfortClass = cl.loadClass(COMFORTABLET_CLIENT_CLASS)
+<             val comfort = comfortClass.getConstructor(android.os.IBinder::class.java).newInstance(binder)
+<             comfortClass.getMethod("setPowerModeSwitch", Int::class.javaPrimitiveType).invoke(comfort, POWER_MODE_OFF)
+<             AppLogger.i(TAG, "  A9 power-off: CarComfortabletClient.setPowerModeSwitch($POWER_MODE_OFF) ✓")
+<             true
+<         } catch (e: Exception) {
+<             AppLogger.w(TAG, "  A9 power-off error: ${e.javaClass.simpleName}: ${e.message}")
+<             false
+<         }
+<     }
+< 
+1239c898
+<             // Méthode réelle sur VPM : getMixProperty(Class, int)
+---
+> 
+1258c917
+<             // Méthode réelle sur VPM : setMixProperty(Class, int, Object)
+---
+> 
+1270,1273d928
+<     // -------------------------------------------------------------------------
+<     // Low-level property accessors
+<     // -------------------------------------------------------------------------
+< 
+1321,1324c976
+<     /**
+<      * SAIC proprietary binder transact (Katman2 fallback).
+<      * Parcel layout from smali: [interfaceToken, AREA_GLOBAL, 1, value, float[], byte[]]
+<      */
+---
+>     
+1352,1355c1004
+<     /**
+<      * HVAC toggle — cycles the property by sending value=1 until target is reached.
+<      * Timeout: 7 seconds (from original smali: 0x1b58 ms = 7000 ms).
+<      */
+---
+>     
+1379,1382d1027
+<     // -------------------------------------------------------------------------
+<     // Public vehicle control API
+<     // -------------------------------------------------------------------------
+< 
+1455c1100
+<         // Send a single click and wait for state confirmation (avoids on/off oscillation)
+---
+> 
+1465,1468d1109
+<     // -------------------------------------------------------------------------
+<     // ADAS API (Katman4)
+<     // -------------------------------------------------------------------------
+< 
+1471,1472c1112
+<             // Priorité VSM (CarVehicleSettingClient) — confirmé dans smali SWI132
+<             // getOverSpeedSoundMode() : 0=OFF, 1/2/3=ON
+---
+> 
+1486,1487c1126
+<             // Essai 1 : CarVehicleSettingClient — setOverSpeedSoundMode(I)V est une méthode void ;
+<             // callVsmVoid() détecte le succès même quand invoke() retourne null (comportement normal).
+---
+> 
+1493c1132
+<             // Essai 2 : binder direct (TX 0x128, bloqué SELinux sur certains builds)
+---
+> 
+1503c1142
+<             // getSpeedLimitSoundMode() : 0=OFF, valeur positive=ON
+---
+> 
+1517c1156
+<             // Essai 1 : CarVehicleSettingClient — setSpeedLimitSoundMode(I)V (méthode void)
+---
+> 
+1523c1162
+<             // Essai 2 : binder direct (TX 0x12a)
+---
+> 
+1531c1170
+<     /** Returns 0–4 (Off/Limiteur/Auto/ACC/ICA), or -1 if Katman4 not ready. */
+---
+>     
+1535c1174
+<         // Primary: setMixProperty (smali-accurate). Fallback: setIntProperty if method missing.
+---
+> 
+1540,1545c1179
+<     // ── SWI68 / SWI69 ADAS API — VehicleSettingManager (noms de méthodes différents) ──
+< 
+<     /**
+<      * Retourne le mode ACC/TJA actuel (0x4=Off, 0x1=ACC, 0x2=TJA), ou -1 si pas prêt.
+<      * SWI68/SWI165 : getAccTjaMode()   SWI69/SWI131/SWI132 : getAccTjaState()
+<      */
+---
+>     
+1553c1187
+<     /** SWI68/SWI165 : setAccTjaMode(I)V   SWI69/SWI131/SWI132 : setAccTjaState(I)V — void */
+---
+>     
+1558c1192,1199
+<         return callVsmVoid(method, mode)   // void method — callVsmVoid évite le faux-négatif
+---
+>         return callVsmVoid(method, mode)
+>     }
+> 
+>     
+>     object SasMode {
+>         const val OFF         = 0
+>         const val MANUEL      = 2
+>         const val INTELLIGENT = 3
+1561,1568d1201
+<     /**
+<      * Limiteur de vitesse — API unifiée pour tous les firmwares VSM.
+<      * Le limiteur est un réglage INDÉPENDANT du mode ACC/TJA, avec les mêmes valeurs partout
+<      * (0=Désactivé, 2=Manuel, 3=Intelligent — vérifié dans le smali de chaque firmware),
+<      * seul le nom de méthode binder diffère :
+<      *   SWI132/SWI131/SWI69 : getSasMode/setSasMode        (CarVehicleSettingClient)
+<      *   SWI68/SWI165        : getSpeedAsstMode/setSpeedAsstMode (VehicleSettingManager)
+<      */
+1572d1204
+<     /** Lit le mode du limiteur de vitesse. Retourne 0/2/3, ou -1 si indisponible. */
+1579d1210
+<     /** Configure le mode du limiteur de vitesse. 0=Désactivé, 2=Manuel, 3=Intelligent. */
+1586,1590c1217
+<     /**
+<      * SWI68/SWI165 : getLaneKeepingWarningSound()
+<      * SWI69/SWI131/SWI132 : getLasWarningSound()   (confirmé dans smali SWI132)
+<      * Valeurs : 2=ON / 1=OFF
+<      */
+---
+>     
+1597c1224
+<     /** SWI68 : setLaneKeepingWarningSound(I)   SWI69/SWI131/SWI132 : setLasWarningSound(I) — void */
+---
+>     
+1605,1613c1232
+<     // ── AEB — Système anti-collision avant ──────────────────────────────────
+< 
+<     /**
+<      * Retourne true si le système anti-collision avant est activé.
+<      * SWI133          : lit PROP_AEB_SWITCH (2=ON, 1=OFF) via CarPropertyManager.
+<      * SWI68 / SWI165  : getFcwAlarmMode() == 2  (FCW_ALARM_ON=2, FCW_ALARM_OFF=1)
+<      *                   Vérifié dans SafeSettingsRepository SWI165 — même API que SWI68.
+<      * SWI69 / SWI131  : getFcwState() — 1=DÉSACTIVÉ, 2=ACTIVÉ
+<      */
+---
+>     
+1616c1235
+<             // SWI69 / SWI131 / SWI132 — CarVehicleSettingClient : getFcwState() (1=OFF, 2=ON)
+---
+> 
+1619,1620c1238,1239
+<             FirmwareInfo.isVsmBased()  -> (callVsm("getFcwAlarmMode") as? Int) == 2  // SWI68 / SWI165
+<             else                       -> getIntPropertyCPM(PROP_AEB_SWITCH, AREA_GLOBAL) == 0x2  // SWI133
+---
+>             FirmwareInfo.isVsmBased()  -> (callVsm("getFcwAlarmMode") as? Int) == 2
+>             else                       -> getIntPropertyCPM(PROP_AEB_SWITCH, AREA_GLOBAL) == 0x2
+1627,1629c1246
+<             // SWI69 / SWI131 / SWI132 — CarVehicleSettingClient (même API)
+<             // setFcwState(I)V et setFcwAutoBrakeMode(I)V sont des méthodes VOID →
+<             // callVsmVoid() est utilisé pour éviter le faux-négatif de callVsm() != null.
+---
+> 
+1631,1634c1248
+<                 // OFF : setFcwState(1) + setFcwAutoBrakeMode(1) + setFcwSensitivity(0)
+<                 // ON  : setFcwState(2) + setFcwAutoBrakeMode(curMode)
+<                 // Le launcher conditionne son affichage à fcwState==1 AND autoBreakState==1
+<                 // → sans setFcwAutoBrakeMode, son switch reste ON même quand l'AEB est désactivé
+---
+> 
+1648,1651c1262
+<                 // SWI68 / SWI165 : setFcwAlarmMode(2=ON / 1=OFF) + setFcwAutoBrakeMode(1) si OFF
+<                 // Vérifié dans SafeSettingsRepository SWI165 — même API que SWI68,
+<                 // setAutoEmergencyBraking() n'est jamais utilisé par l'app officielle.
+<                 // setFcwAlarmMode(I)V et setFcwAutoBrakeMode(I)V sont void → callVsmVoid()
+---
+> 
+1659,1663c1270
+<     /**
+<      * Retourne le mode AEB courant (1=Alerte, 2=Alerte+Freinage), ou -1 si pas prêt.
+<      * SWI133          : PROP_AEB_MODE (0x302000b) via VehiclePropertyManager.
+<      * SWI68/SWI69/SWI131 : getFcwAutoBrakeMode() (1=Alerte, 2=Alerte+Freinage).
+<      */
+---
+>     
+1676,1677c1283
+<             // SWI69 / SWI131 / SWI132 — CarVehicleSettingClient : fixer mode puis activer
+<             // setFcwAutoBrakeMode(I)V et setFcwState(I)V sont void → callVsmVoid()
+---
+> 
+1679c1285
+<                 // L'ordre : 1) fixer le mode, 2) activer (commit le mode).
+---
+> 
+1687c1293
+<                 // SWI68 / SWI165 : setFcwAutoBrakeMode uniquement (1=Alerte, 2=Alerte+Freinage)
+---
+> 
+1691c1297
+<                 // SWI133 smali exact
+---
+> 
+1703,1708c1309
+<     /**
+<      * Retourne la sensibilité AEB courante (1=Faible, 2=Standard, 3=Élevé), ou -1 si pas prêt.
+<      * SWI133         : PROP_AEB_SENSITIVITY (0x302000e, VPM)
+<      * SWI68/SWI165   : VehicleSettingManager.getFcwSensitivity()
+<      * SWI69/SWI131   : CarVehicleSettingClient.getFcwSensitivity()
+<      */
+---
+>     
+1720,1725c1321
+<     /**
+<      * Définit la sensibilité AEB (1=Faible, 2=Standard, 3=Élevé).
+<      * SWI133         : PROP_AEB_SENSITIVITY (0x302000e, VPM)
+<      * SWI68/SWI165   : VehicleSettingManager.setFcwSensitivity(I)
+<      * SWI69/SWI131   : CarVehicleSettingClient.setFcwSensitivity(I)
+<      */
+---
+>     
+1727c1323
+<         // setFcwSensitivity(I)V est void → callVsmVoid() pour éviter le faux-négatif
+---
+> 
+1737,1748c1333
+<     // -------------------------------------------------------------------------
+<     // ELK — Assistant de sortie de voie (SWI133 uniquement pour l'instant)
+<     // Utilise IVehicleSettingService via sVehicleBinder (TX 0x53–0x56)
+<     // -------------------------------------------------------------------------
+< 
+<     /**
+<      * Retourne le mode ELK courant (1=OFF, 2=Alerte, 3=Aider, 5=Maintien d'urgence).
+<      * Routage par firmware :
+<      *   SWI133         → VSM133 (getLaneKeepingAsstMode) → binder TX 0x53
+<      *   SWI68/SWI165   → VSM    (getLaneKeepingAsstMode)
+<      *   SWI69/SWI131   → VSM    (getLasMode)
+<      */
+---
+>     
+1758c1343
+<             // SWI69/SWI131/SWI132 — CarVehicleSettingClient
+---
+> 
+1764c1349
+<             // SWI68/SWI165 — VehicleSettingManager
+---
+> 
+1771,1774c1356
+<     /**
+<      * Définit le mode ELK.
+<      * Routage identique à getElkMode().
+<      */
+---
+>     
+1784c1366
+<             // SWI69/SWI131/SWI132 — CarVehicleSettingClient
+---
+> 
+1790c1372
+<             // SWI68/SWI165 — VehicleSettingManager
+---
+> 
+1797,1800c1379
+<     /**
+<      * Retourne la sensibilité ELK courante (1=Faible, 2=Standard, 3=Élevé).
+<      * Routage par firmware — identique à getElkMode().
+<      */
+---
+>     
+1810c1389
+<             // SWI69/SWI131/SWI132 — CarVehicleSettingClient
+---
+> 
+1816c1395
+<             // SWI68/SWI165 — VehicleSettingManager
+---
+> 
+1823,1826c1402
+<     /**
+<      * Définit la sensibilité ELK.
+<      * Routage identique à getElkMode().
+<      */
+---
+>     
+1836c1412
+<             // SWI69/SWI131/SWI132 — CarVehicleSettingClient
+---
+> 
+1842c1418
+<             // SWI68/SWI165 — VehicleSettingManager
+---
+> 
+1849c1425
+<     /** Retourne true si l'ELK est activé (mode ≠ OFF). */
+---
+>     
+1855,1858c1431
+<     /**
+<      * SWI132 — Alerte sonore (LAS Warning Sound) : 0=OFF, 1=ON.
+<      * Retourne -1 si erreur ou firmware non SWI132.
+<      */
+---
+>     
+1873,1876c1446
+<     /**
+<      * SWI132 — Rappel par vibration (LAS Warning Vibration) : 0=OFF, 1=ON.
+<      * Retourne -1 si erreur ou firmware non SWI132.
+<      */
+---
+>     
+1891,1896c1461
+<     /**
+<      * GET via IVehicleSettingService binder — layout smali :
+<      *   data : [writeInterfaceToken]
+<      *   transact(code, data, reply, 0)
+<      *   reply: readException() + readInt()
+<      */
+---
+>     
+1924,1928c1489
+<     /**
+<      * SET via IVehicleSettingService binder — layout smali :
+<      *   data : [writeInterfaceToken, writeInt(value)]
+<      *   transact(code, data, null, FLAG_ONEWAY=1)
+<      */
+---
+>     
+1949,1952c1510
+<     /**
+<      * GET via IVehicleSettingService SWI132 (DESCRIPTOR_VSM132, two-way flag=0x0).
+<      * Retourne la valeur entière lue, ou -1 en cas d'erreur.
+<      */
+---
+>     
+1980,1983c1538
+<     /**
+<      * SET via IVehicleSettingService SWI132 (DESCRIPTOR_VSM132, two-way flag=0x0).
+<      * Différent de elkBinderSet : utilise le bon DESCRIPTOR et flag two-way.
+<      */
+---
+>     
+2007,2010d1561
+<     // -------------------------------------------------------------------------
+<     // TSR — Reconnaissance des panneaux de vitesse
+<     // -------------------------------------------------------------------------
+< 
+2013,2014c1564
+<             // Priorité CarVehicleSettingClient (binder vehiclesetting bloqué SELinux)
+<             // Convention identique SWI69/SWI131 : 0=ON, 1=OFF
+---
+> 
+2018c1568
+<             } ?: (swi132BinderGet(VSM132_TX_GET_SLIF) == 1)  // fallback binder (rarement accessible)
+---
+>             } ?: (swi132BinderGet(VSM132_TX_GET_SLIF) == 1)
+2021c1571
+<         FirmwareInfo.isNewGenVsm() ->   // SWI69 + SWI131 — convention inversée : 0=ON, 1=OFF
+---
+>         FirmwareInfo.isNewGenVsm() ->
+2023c1573
+<         FirmwareInfo.isVsmBased() ->    // SWI68 + SWI165
+---
+>         FirmwareInfo.isVsmBased() ->
+2032,2033c1582
+<                 // Priorité CarVehicleSettingClient — setSLIFWarningState(I)V confirmé dans smali SWI132
+<                 // Convention identique SWI69/SWI131 : 0=activer, 1=désactiver
+---
+> 
+2038c1587
+<                     // Fallback binder direct (bloqué SELinux sur la plupart des builds SWI132)
+---
+> 
+2044,2045c1593
+<                 // SWI133 : le firmware remet OVERSPEED et SPEED_TONE à ON quand le SLIF est réactivé
+<                 // → on sauvegarde avant et on restaure après.
+---
+> 
+2067,2068c1615,1616
+<             FirmwareInfo.isNewGenVsm() -> {   // SWI69 + SWI131 — convention inversée : 0=activer, 1=désactiver
+<                 // setSLIFWarningState(I)V est void → callVsmVoid()
+---
+>             FirmwareInfo.isNewGenVsm() -> {
+> 
+2071,2073c1619,1620
+<             FirmwareInfo.isVsmBased() -> {    // SWI68 + SWI165
+<                 // L'avertissement sonore pourrait être remis à ON lors de la réactivation du TSR
+<                 // → on sauvegarde avant et on restaure après.
+---
+>             FirmwareInfo.isVsmBased() -> {
+> 
+2080c1627
+<                 // setSpeedAsstSlifWarning(I)V est void → callVsmVoid()
+---
+> 
+2094,2099c1641
+<     /**
+<      * SWI133 : retourne (overspeed, speedTone) tels que sauvegardés lors du dernier TSR OFF.
+<      * Utilisé par l'UI pour mettre à jour les switches après la réactivation du TSR, sans
+<      * relire le hardware (le VPM a une latence de propagation qui renverrait encore ON
+<      * pendant ~500–1000ms après les écritures internes de setTsrMode).
+<      */
+---
+>     
+2108,2111d1649
+<     // -------------------------------------------------------------------------
+<     // Économie d'énergie (Endurance Mode)
+<     // -------------------------------------------------------------------------
+< 
+2115c1653
+<         FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132 ->  // SWI69 + SWI131 + SWI132
+---
+>         FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132 ->
+2117c1655
+<         FirmwareInfo.isVsmBased() ->        // SWI68 + SWI165
+---
+>         FirmwareInfo.isVsmBased() ->
+2127,2128c1665,1666
+<             FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132 -> {  // SWI69 + SWI131 + SWI132
+<                 // setEnduranceMode(I)V est void → callVsmVoid()
+---
+>             FirmwareInfo.isNewGenVsm() || FirmwareInfo.getGeneration() == FirmwareInfo.Gen.SWI132 -> {
+> 
+2131,2132c1669,1670
+<             FirmwareInfo.isVsmBased() -> {   // SWI68 + SWI165
+<                 // setLongerEndurance(I)V est void → callVsmVoid()
+---
+>             FirmwareInfo.isVsmBased() -> {
+> 
+2146,2155c1684
+<     // -------------------------------------------------------------------------
+<     // IGNITION_STATE — CarPropertyManager callback (standard AAOS, tous firmwares)
+<     // -------------------------------------------------------------------------
+< 
+<     /**
+<      * Enregistre un CarPropertyEventCallback sur PROP_IGNITION_STATE via réflexion.
+<      * Protégé par [sIgnitionCallbackRegistered] — ne s'exécute qu'une seule fois.
+<      * Lit l'état courant immédiatement après l'enregistrement : CPM ne notifie que sur changement,
+<      * donc si la voiture est déjà READY au moment du bind, aucun event ne serait reçu sans cette lecture.
+<      */
+---
+>     
+2204c1733
+<             sIgnitionCallbackProxy = proxy   // référence forte pour éviter le GC
+---
+>             sIgnitionCallbackProxy = proxy
+2209d1737
+<             // Lecture immédiate de l'état courant
+2239,2242d1766
+<     // -------------------------------------------------------------------------
+<     // Katman5 SWI69/SWI131 — ICarGeneralService via CarAdapterClient (queryClient(0x1))
+<     // -------------------------------------------------------------------------
+< 
+2299d1822
+<             sCarGeneral = client   // conservé pour la luminosité écran A9 (setScreenBrightness)
+2314,2319d1836
+<             // Binder réel nécessaire pour l'enregistrement cross-process via AIDL.
+<             // ICarGeneralService est dans un processus distant (com.saicmotor.caradapter) :
+<             // registListener() appelle writeStrongBinder(callback.asBinder()) — un proxy qui
+<             // retourne null pour asBinder() transmettrait un binder null au service, qui ne
+<             // pourrait jamais rappeler. On crée donc un Binder concret qui implémente onTransact
+<             // pour le code 0x7 (TRANSACTION_onIgnitionStateChange, identique sur SWI69 et SWI131).
+2326c1843
+<                         0x7 -> { // TRANSACTION_onIgnitionStateChange
+---
+>                         0x7 -> {
+2345c1862
+<                             // Chemin in-process (rare) — le service appelle directement l'interface
+---
+> 
+2363c1880
+<                 sVcmListener = callbackBinder  // référence forte sur le Binder pour éviter le GC
+---
+>                 sVcmListener = callbackBinder
+2398,2402d1914
+<     // -------------------------------------------------------------------------
+<     // Katman5 — VehicleConditionManager (IVehicleConditionService via IHubService)
+<     // SWI133 / SWI68 / SWI165
+<     // -------------------------------------------------------------------------
+< 
+2426d1937
+<         // Tentative 1 : singleton déjà initialisé par le launcher
+2440d1950
+<         // Tentative 2 : appeler init(Context, IVehicleServiceListener)
+2492d2001
+<         // Retries — singleton disponible après connexion asynchrone
+2566d2074
+<             // Lecture immédiate (le callback ne se déclenche que sur CHANGEMENT)
+2583,2587c2091,2092
+<         // Ne dispatcher que si l'état change réellement — évite les faux RUN répétés
+<         // que VehicleConditionManager envoie à chaque changement de condition véhicule
+<         // (changement de rapport D/N/R, etc.) alors que la voiture est déjà en RUN.
+<         if (state == sLastVcmIgnitionState) return
+<         sLastVcmIgnitionState = state
+---
+> 
+>         if (sLastVcmIgnitionState.getAndSet(state) == state) return
+2601,2604d2105
+<     // -------------------------------------------------------------------------
+<     // Listener management
+<     // -------------------------------------------------------------------------
+< 
+2608,2612c2109
+<     // -------------------------------------------------------------------------
+<     // Diagnostic
+<     // -------------------------------------------------------------------------
+< 
+<     /** Retourne true si le binder IVehicleSettingService est disponible. */
+---
+>     
+2615,2619c2112
+<     /**
+<      * Génère un rapport de diagnostic complet :
+<      * état des services, tests binder SWI132 en temps réel, dump AppLogger.
+<      * À appeler sur Dispatchers.IO (les TX binder sont bloquants).
+<      */
+---
+>     
+2641c2134
+<         sb.appendLine("Katman5 ign  : ${carIgnitionName(sLastVcmIgnitionState)} ($sLastVcmIgnitionState)")
+---
+>         sb.appendLine("Katman5 ign  : ${carIgnitionName(sLastVcmIgnitionState.get())} (${sLastVcmIgnitionState.get()})")
+2646d2138
+<             // ── Binder IVehicleSettingService ─────────────────────────────
+2661d2152
+<             // ── Alertes — lecture brute + interprétation ──────────────────
+2678,2680d2168
+<             // ── Alertes — test SET aller-retour (écrit la valeur courante) ─
+<             // Si la valeur brute est lisible (≥ 0), on réécrit la même valeur pour tester
+<             // que le SET passe (sans modifier l'état réel de la voiture).
+2708d2195
+<             // ── CarVehicleSettingClient (Katman4) ─────────────────────────
+2715d2201
+<             // ACC/TJA
+2725d2210
+<             // AEB
+2739d2223
+<             // ELK
+2746d2229
+<             // ── ALERTES via VSM (nouveau path — confirmé dans smali SWI132) ─
+2762d2244
+<             // TSR / SLIF
+2771d2252
+<             // Son d'alerte de voie (LAS)
+2780d2260
+<             // Test SET round-trip via VSM (sans modifier l'état réel : on réécrit la valeur courante)
+2808d2287
+<             // Éco
+2824c2303,2418
+< }
+---
+> 
+>     private const val DESCRIPTOR_CARADAPTER = "com.saicmotor.carapi.ICarAdapterService"
+>     private const val TX_QUERY_AUDIO_CLIENT = 1
+>     private const val HELPER_AUDIO_CODE     = 10
+> 
+>     private const val AUDIO_SET_FADER_FRONT   = 12
+>     private const val AUDIO_SET_BALANCE_RIGHT = 13
+>     private const val AUDIO_SET_LOUDNESS      = 15
+>     private const val AUDIO_GET_LOUDNESS      = 16
+>     private const val AUDIO_SET_SPEED_VOL     = 17
+>     private const val AUDIO_GET_SPEED_VOL     = 18
+>     private const val AUDIO_SET_3D_EFFECT     = 26
+>     private const val AUDIO_GET_3D_EFFECT     = 27
+>     private const val AUDIO_SET_SOUND_FIELD   = 30
+>     private const val AUDIO_GET_BALANCE       = 31
+>     private const val AUDIO_GET_FADER         = 32
+>     private const val AUDIO_SET_BOSE_SOUND    = 36
+>     private const val AUDIO_GET_BOSE_SOUND    = 37
+>     private const val AUDIO_SET_TONE          = 40
+>     private const val AUDIO_GET_TONE          = 41
+> 
+>     @Volatile private var sCarAdapterBinder: IBinder? = null
+>     @Volatile private var sAudioHelper: IBinder? = null
+>     @Volatile private var sAudioDescriptor: String = ""
+>     @Volatile private var sAudioServiceConn: android.content.ServiceConnection? = null
+> 
+>     val isAudioAvailable: Boolean get() = sAudioHelper?.isBinderAlive == true
+> 
+>     private fun initAudio(context: Context) {
+>         if (sAudioHelper?.isBinderAlive == true) return
+>         if (sAudioServiceConn != null) return
+>         val intent = android.content.Intent().apply {
+>             setClassName("com.saicmotor.caradapter", "com.saicmotor.caradapter.service.CarAdapterService")
+>         }
+>         val conn = object : android.content.ServiceConnection {
+>             override fun onServiceConnected(name: android.content.ComponentName?, binder: IBinder?) {
+>                 sCarAdapterBinder = binder
+>                 AppLogger.i(TAG, "  Audio: CarAdapterService connecté ✓")
+>                 CoroutineScope(Dispatchers.IO).launch { tryGetAudioHelper() }
+>             }
+>             override fun onServiceDisconnected(name: android.content.ComponentName?) {
+>                 sCarAdapterBinder = null; sAudioHelper = null
+>             }
+>         }
+>         sAudioServiceConn = conn
+>         try {
+>             val bound = context.applicationContext.bindService(intent, conn, android.content.Context.BIND_AUTO_CREATE)
+>             if (!bound) {
+>                 sAudioServiceConn = null
+>                 Handler(Looper.getMainLooper()).postDelayed({ if (sAudioHelper == null) initAudio(context.applicationContext) }, 10_000L)
+>             }
+>         } catch (e: Exception) { sAudioServiceConn = null; AppLogger.w(TAG, "  Audio: bindService error: ${e.message}") }
+>     }
+> 
+>     private fun tryGetAudioHelper() {
+>         val svc = sCarAdapterBinder ?: return
+>         val data = Parcel.obtain(); val reply = Parcel.obtain()
+>         try {
+>             data.writeInterfaceToken(DESCRIPTOR_CARADAPTER)
+>             data.writeInt(HELPER_AUDIO_CODE)
+>             if (svc.transact(TX_QUERY_AUDIO_CLIENT, data, reply, 0)) {
+>                 reply.readException()
+>                 val helper = reply.readStrongBinder()
+>                 if (helper != null && helper.isBinderAlive) {
+>                     sAudioHelper = helper; sAudioDescriptor = helper.interfaceDescriptor ?: ""
+>                     AppLogger.i(TAG, "  Audio: helper OK descriptor='$sAudioDescriptor'")
+>                 } else {
+>                     Handler(Looper.getMainLooper()).postDelayed({ CoroutineScope(Dispatchers.IO).launch { tryGetAudioHelper() } }, 5_000)
+>                 }
+>             }
+>         } finally { data.recycle(); reply.recycle() }
+>     }
+> 
+>     private fun audioGet(txCode: Int): Int {
+>         val h = sAudioHelper ?: return -1
+>         if (!h.isBinderAlive) { sAudioHelper = null; return -1 }
+>         val data = Parcel.obtain(); val reply = Parcel.obtain()
+>         return try {
+>             data.writeInterfaceToken(sAudioDescriptor)
+>             if (h.transact(txCode, data, reply, 0)) { reply.readException(); reply.readInt() } else -1
+>         } catch (_: Exception) { -1 } finally { data.recycle(); reply.recycle() }
+>     }
+> 
+>     private fun audioSet(txCode: Int, value: Int): Boolean {
+>         val h = sAudioHelper ?: return false
+>         if (!h.isBinderAlive) { sAudioHelper = null; return false }
+>         val data = Parcel.obtain(); val reply = Parcel.obtain()
+>         return try {
+>             data.writeInterfaceToken(sAudioDescriptor)
+>             data.writeInt(value)
+>             h.transact(txCode, data, reply, 0).also { if (it) reply.readException() }
+>         } catch (_: Exception) { false } finally { data.recycle(); reply.recycle() }
+>     }
+> 
+>     private const val AUDIO_TYPE_MIN  = 0
+>     private const val AUDIO_TYPE_MAX  = 3
+>     private const val AUDIO_LEVEL_MIN = -9
+>     private const val AUDIO_LEVEL_MAX =  9
+> 
+>     fun getBoseSoundType(): Int              = audioGet(AUDIO_GET_BOSE_SOUND)
+>     fun setBoseSoundType(t: Int): Boolean    = audioSet(AUDIO_SET_BOSE_SOUND, t.coerceIn(AUDIO_TYPE_MIN, AUDIO_TYPE_MAX))
+>     fun getAudioBalance(): Int               = audioGet(AUDIO_GET_BALANCE)
+>     fun setAudioBalance(v: Int): Boolean     = audioSet(AUDIO_SET_BALANCE_RIGHT, v.coerceIn(AUDIO_LEVEL_MIN, AUDIO_LEVEL_MAX))
+>     fun getAudioFader(): Int                 = audioGet(AUDIO_GET_FADER)
+>     fun setAudioFader(v: Int): Boolean       = audioSet(AUDIO_SET_FADER_FRONT, v.coerceIn(AUDIO_LEVEL_MIN, AUDIO_LEVEL_MAX))
+>     fun getLoudnessState(): Int              = audioGet(AUDIO_GET_LOUDNESS)
+>     fun setLoudnessState(s: Int): Boolean    = audioSet(AUDIO_SET_LOUDNESS, s)
+>     fun getSpeedVolumeLevel(): Int           = audioGet(AUDIO_GET_SPEED_VOL)
+>     fun setSpeedVolumeLevel(l: Int): Boolean = audioSet(AUDIO_SET_SPEED_VOL, l.coerceIn(AUDIO_TYPE_MIN, AUDIO_TYPE_MAX))
+>     fun getSoundFieldType(): Int             = -1
+>     fun setSoundFieldType(t: Int): Boolean   = audioSet(AUDIO_SET_SOUND_FIELD, t)
+>     fun get3dEffectType(): Int               = audioGet(AUDIO_GET_3D_EFFECT)
+>     fun set3dEffectType(t: Int): Boolean     = audioSet(AUDIO_SET_3D_EFFECT, t.coerceIn(AUDIO_TYPE_MIN, AUDIO_TYPE_MAX))
+>     fun getToneControl(): Int                = audioGet(AUDIO_GET_TONE)
+>     fun setToneControl(v: Int): Boolean      = audioSet(AUDIO_SET_TONE, v.coerceIn(AUDIO_LEVEL_MIN, AUDIO_LEVEL_MAX))
+> }
+\ No newline at end of file
+
+===== app/src/main/java/com/mg4/control/model/DrivingProfile.kt (+19/-21) =====
+11c11
+<     val seatHeatLeft: Int = 0,        // 0=off, 1, 2, 3
+---
+>     val seatHeatLeft: Int = 0,
+13c13
+<     // ADAS SWI133 (Katman4) — valeurs par défaut OFF pour compatibilité profils existants
+---
+> 
+16,17c16,17
+<     val adasMode: Int = 0,            // 0=Off, 1=Limiteur, 2=Auto, 3=ACC, 4=ICA
+<     // ADAS SWI68 — champs distincts pour isoler les configurations par firmware
+---
+>     val adasMode: Int = 0,
+> 
+19,22c19,20
+<     val swi68AdasMode: Int = 0x4,     // Mode ACC/TJA (CarAccTja) : 0x4=Off, 0x1=ACC, 0x2=TJA/ICA
+<     // Limiteur de vitesse (SAS) — réglage INDÉPENDANT du mode ACC/TJA (SWI132).
+<     // swi132LimiterConfigured=false (défaut + profils créés avant cette fonction) → le limiteur
+<     // n'est PAS touché lors de l'application du profil (aucune régression sur l'état voiture).
+---
+>     val swi68AdasMode: Int = 0x4,
+> 
+24,35c22,33
+<     val swi132SasMode: Int = 0,       // SAS : 0=Désactivé, 2=Manuel, 3=Intelligent
+<     // AEB — Système anti-collision avant (commun SWI133 + SWI68)
+<     val aebEnabled: Boolean = false,   // false=OFF, true=ON
+<     val aebMode: Int = 1,              // 1=Alerte seule, 2=Alerte+Freinage auto
+<     val aebSensitivity: Int = 0,       // 0=non configuré, 1=Faible, 2=Standard, 3=Élevé (SWI133)
+<     // ELK — Assistant de sortie de voie
+<     val elkMode: Int = 0,              // 0=non configuré, 1=OFF, 2=Alerte(LDW), 3=Aider(LDP), 5=ELK
+<     val elkSensitivity: Int = 0,       // 0=non configuré, 1=Faible, 2=Standard, 3=Élevé
+<     // ELK SWI132 — Alerte sonore + Vibration (spécifique SWI132)
+<     val lasAudibleWarning: Boolean = true,    // true=ON (défaut ON dans la voiture)
+<     val lasVibrationReminder: Boolean = true, // true=ON (défaut ON dans la voiture)
+<     // Économie d'énergie + TSR
+---
+>     val swi132SasMode: Int = 0,
+> 
+>     val aebEnabled: Boolean = false,
+>     val aebMode: Int = 1,
+>     val aebSensitivity: Int = 0,
+> 
+>     val elkMode: Int = 0,
+>     val elkSensitivity: Int = 0,
+> 
+>     val lasAudibleWarning: Boolean = true,
+>     val lasVibrationReminder: Boolean = true,
+> 
+39c37
+<     // [BT-PROFILES] MAC de l'appareil Bluetooth associé à ce profil (null = aucun)
+---
+> 
+
+===== app/src/main/java/com/mg4/control/profile/ProfileApplier.kt (+19/-180) =====
+5d4
+< import com.mg4.control.hardware.MG4Hardware.Swi68Mode
+7a7
+> import kotlinx.coroutines.CoroutineScope
+9c9
+< import kotlinx.coroutines.GlobalScope
+---
+> import kotlinx.coroutines.SupervisorJob
+16,43c16,20
+<     /**
+<      * Id du dernier profil appliqué MANUELLEMENT (popup volant, bouton dans l'app, raccourci
+<      * APPLY_PROFILE) — c.-à-d. avec autoStart=false. Permet au passage en READY de respecter le
+<      * choix explicite de l'utilisateur au lieu de ré-appliquer le profil par défaut.
+<      * En mémoire : réinitialisé à l'extinction de la voiture (IGNITION_OFF) ou au redémarrage du process.
+<      */
+<     @Volatile
+<     var lastManualProfileId: String? = null
+< 
+<     /**
+<      * Applique tous les paramètres de [profile] au véhicule de façon asynchrone.
+<      * Les opérations HVAC (siège/volant) sont bloquantes (polling jusqu'à 7s),
+<      * exécutées sur le dispatcher IO.
+<      *
+<      * @param autoStart true si l'application est déclenchée automatiquement au démarrage
+<      *   (IGNITION/boot). Active la passe de vérification des alertes sonores (SWI132/SWI133) :
+<      *   au démarrage à froid, le firmware peut ré-asserter OVERSPEED/SPEED_TONE après nos
+<      *   écritures — on relit et on réécrit en cas d'écart. Inutile en application manuelle.
+<      */
+<     fun apply(profile: DrivingProfile, autoStart: Boolean = false, onComplete: ((Boolean) -> Unit)? = null) {
+<         AppLogger.i(TAG, "Application du profil : ${profile.name} (autoStart=$autoStart)")
+< 
+<         // Application manuelle (popup volant / app / raccourci) → on mémorise le choix de l'utilisateur
+<         // pour que le passage en READY le respecte au lieu de ré-appliquer le profil par défaut.
+<         if (!autoStart) {
+<             lastManualProfileId = profile.id
+<             AppLogger.i(TAG, "  Choix manuel mémorisé : ${profile.name} (id=${profile.id})")
+<         }
+---
+>     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+> 
+>     
+>     fun apply(profile: DrivingProfile, onComplete: ((Boolean) -> Unit)? = null) {
+>         AppLogger.i(TAG, "Application du profil : ${profile.name}")
+45,46c22
+<         @Suppress("OPT_IN_USAGE")
+<         GlobalScope.launch(Dispatchers.IO) {
+---
+>         scope.launch {
+49d24
+<             // Mode de conduite (rapide — binder call)
+54d28
+<             // Niveau de régénération (rapide — binder call)
+59d32
+<             // Volant + Sièges chauffants — uniquement SWI133 et SWI68 (SWI69/SWI131 n'ont pas ces équipements)
+72d44
+<             // ADAS (Katman4) — appliqué dès que le service est prêt
+76,81d47
+<                     // ── SWI132 ──────────────────────────────────────────────────────────
+<                     //
+<                     // SWI132 utilise CarVehicleSettingClient pour l'ADAS (ACC/TJA)
+<                     // mais le binder direct IVehicleSettingService pour les alertes sonores.
+<                     // → setOverspeedAlarm() et setSpeedLimitTone() envoient les TX binder corrects
+<                     //   (0x128 et 0x12a) sans passer par VehicleSettingManager.
+83d48
+<                     // TSR (SLIF) via VSM — appliqué en premier comme SWI133
+87,92d51
+<                     // Alertes sonores via VSM
+<                     // Le firmware SWI132 remet overspeed et speedTone à ON ~400ms après l'activation
+<                     // du TSR (même comportement que SWI133). setTsrMode() retourne immédiatement sans
+<                     // attendre cette réinitialisation. Si on écrit les alertes trop tôt, le firmware
+<                     // les écrase ensuite. On attend 450ms pour laisser le firmware terminer sa
+<                     // réinitialisation avant d'appliquer les valeurs du profil.
+96,98c55
+<                     // Délai de 150ms entre les deux écritures : le middleware traite les propriétés
+<                     // dans une file avec debounce — deux écritures trop rapides font que seule la
+<                     // dernière est validée. 150ms garantit que la première est traitée.
+---
+> 
+105,116c62,63
+<                     // Mode ACC/TJA via CarVehicleSettingClient (setAccTjaState).
+<                     // SHWA (ancien codage limiteur) n'est plus un mode ACC/TJA → ramené à Off ;
+<                     // le limiteur est géré séparément via setSasMode ci-dessous.
+<                     val cruiseMode = if (profile.swi68AdasMode == Swi68Mode.SHWA) Swi68Mode.OFF else profile.swi68AdasMode
+<                     val adOk = MG4Hardware.setAccTjaMode(cruiseMode)
+<                     AppLogger.i(TAG, "  AdasMode=0x${cruiseMode.toString(16)} → $adOk")
+<                     // Limiteur de vitesse (SAS) — appliqué uniquement si le profil l'a configuré.
+<                     // Profils créés avant cette fonction (swi132LimiterConfigured=false) → non touché.
+<                     if (profile.swi132LimiterConfigured) {
+<                         MG4Hardware.setSpeedLimiterMode(profile.swi132SasMode)
+<                         AppLogger.i(TAG, "  SasMode=${profile.swi132SasMode} (0=Off 2=Manuel 3=Intelligent)")
+<                     }
+---
+>                     val adOk = MG4Hardware.setAccTjaMode(profile.swi68AdasMode)
+>                     AppLogger.i(TAG, "  AdasMode=0x${profile.swi68AdasMode.toString(16)} → $adOk")
+119d65
+<                     // Économie d'énergie — via CarVehicleSettingClient (setEnduranceMode), même path que SWI69
+124,128c70
+<                     // ── SWI68/SWI69/SWI131/SWI165 ──────────────────────────────────────
+<                     //
+<                     // Le TSR est appliqué EN PREMIER : setTsrMode() bloque 400 ms en interne
+<                     // et restaure soundWarning depuis les préférences. On l'appelle en premier
+<                     // pour pouvoir ensuite écraser l'alerte sonore avec la valeur du profil.
+---
+> 
+132d73
+<                     // Alerte sonore — appliquée APRÈS le TSR pour écraser sa restauration interne
+136,145c77,78
+<                     // Mode ACC/TJA — SHWA (ancien codage limiteur) ramené à Off (limiteur géré à part)
+<                     val cruiseMode = if (profile.swi68AdasMode == Swi68Mode.SHWA) Swi68Mode.OFF else profile.swi68AdasMode
+<                     val adOk = MG4Hardware.setAccTjaMode(cruiseMode)
+<                     AppLogger.i(TAG, "  AdasMode=0x${cruiseMode.toString(16)} → $adOk")
+<                     // Limiteur de vitesse — appliqué uniquement si le profil l'a configuré.
+<                     // (SWI69/SWI131 → setSasMode ; SWI68/SWI165 → setSpeedAsstMode, dispatch interne)
+<                     if (profile.swi132LimiterConfigured) {
+<                         MG4Hardware.setSpeedLimiterMode(profile.swi132SasMode)
+<                         AppLogger.i(TAG, "  LimiterMode=${profile.swi132SasMode} (0=Off 2=Manuel 3=Intelligent)")
+<                     }
+---
+>                     val adOk = MG4Hardware.setAccTjaMode(profile.swi68AdasMode)
+>                     AppLogger.i(TAG, "  AdasMode=0x${profile.swi68AdasMode.toString(16)} → $adOk")
+148d80
+<                     // Économie d'énergie — firmwares VSM hors SWI132 (SWI68/SWI69/SWI131/SWI165)
+152,156c84
+<                     // ── SWI133/UNKNOWN ──────────────────────────────────────────────────
+<                     //
+<                     // Même logique : activer le TSR ré-active OVERSPEED_ALARM et SPEED_LIMIT_TONE.
+<                     // setTsrMode() restaure depuis les préférences — on l'appelle en premier
+<                     // puis on écrase avec les valeurs du profil.
+---
+> 
+162,165d89
+<                     // Alertes vitesse — appliquées APRÈS le TSR
+<                     // Délai de 150ms entre les deux écritures : le middleware véhicule (VPM) traite
+<                     // les propriétés dans une file avec debounce — deux écritures trop rapides font
+<                     // que seule la dernière est validée. 150ms garantit que la première est traitée.
+176d99
+<                     // Économie d'énergie — SWI133 via VPM
+182,183d104
+<                 // ELK — commun à tous les firmwares connus
+<                 applyElk(profile.elkMode, profile.elkSensitivity, profile.lasAudibleWarning, profile.lasVibrationReminder)
+185,249c106
+<                 // ── Passe de vérification ADAS (auto-démarrage uniquement) ────────────
+<                 // Au démarrage à froid, le firmware peut ré-asserter certains réglages APRÈS
+<                 // notre écriture (alertes survitesse/ton ~400ms après le SLIF/TSR ; ELK remis à
+<                 // sa valeur par défaut). On relit après stabilisation et on réécrit en cas d'écart.
+<                 // Concerne SWI132/SWI133 (2 alertes distinctes + ELK).
+<                 val gen = FirmwareInfo.getGeneration()
+<                 if (autoStart && (gen == FirmwareInfo.Gen.SWI133 || gen == FirmwareInfo.Gen.SWI132)) {
+<                     verifyAdasWithRetry(profile)
+<                 }
+<             }
+<         }
+<     }
+< 
+<     /**
+<      * Passe de vérification post-application (auto-démarrage, SWI132/SWI133). Attend la fin de
+<      * la fenêtre de ré-assertion firmware puis relit/réécrit en cas d'écart :
+<      *   - alertes sonores survitesse + ton
+<      *   - ELK (assistant de sortie de voie) — le firmware le remet à sa valeur par défaut au boot
+<      */
+<     private fun verifyAdasWithRetry(profile: DrivingProfile) {
+<         AppLogger.i(TAG, "  [VERIFY] Vérification ADAS (auto-démarrage) — stabilisation 500ms")
+<         try { Thread.sleep(500) } catch (_: InterruptedException) {}
+<         verifyOneAlert("OverspeedAlarm", profile.overspeedAlarm,
+<             { MG4Hardware.isOverspeedAlarmOn() }, { MG4Hardware.setOverspeedAlarm(it) })
+<         verifyOneAlert("SpeedLimitTone", profile.speedLimitTone,
+<             { MG4Hardware.isSpeedLimitToneOn() }, { MG4Hardware.setSpeedLimitTone(it) })
+<         verifyElk(profile)
+<     }
+< 
+<     /**
+<      * Vérifie le mode ELK (assistant de sortie de voie) après stabilisation et le réécrit s'il a
+<      * dérivé (réactivation auto par le firmware). Ne fait rien si le profil ne configure pas l'ELK
+<      * (elkMode=0). Réapplique la config ELK complète (mode + sensibilité + sonore/vibration SWI132).
+<      */
+<     private fun verifyElk(profile: DrivingProfile) {
+<         if (profile.elkMode == 0) return   // ELK non configuré dans ce profil → ne pas toucher
+<         repeat(3) { i ->
+<             val actual = MG4Hardware.getElkMode()
+<             if (actual == profile.elkMode) {
+<                 AppLogger.i(TAG, "  [VERIFY] ElkMode conforme (lu=$actual" +
+<                     if (i > 0) ", après $i correction(s))" else ")")
+<                 return
+<             }
+<             AppLogger.w(TAG, "  [VERIFY] ElkMode ÉCART (lu=$actual, attendu=${profile.elkMode}) → réécriture (tentative ${i + 1}/3)")
+<             applyElk(profile.elkMode, profile.elkSensitivity, profile.lasAudibleWarning, profile.lasVibrationReminder)
+<             try { Thread.sleep(300) } catch (_: InterruptedException) {}
+<         }
+<         val finalVal = MG4Hardware.getElkMode()
+<         if (finalVal == profile.elkMode)
+<             AppLogger.i(TAG, "  [VERIFY] ElkMode finalement conforme (lu=$finalVal)")
+<         else
+<             AppLogger.w(TAG, "  [VERIFY] ElkMode ÉCHEC après 3 tentatives (lu=$finalVal, attendu=${profile.elkMode})")
+<     }
+< 
+<     /**
+<      * Relit une alerte ; si elle diffère de la valeur voulue, la réécrit et réessaie.
+<      * Jusqu'à 3 tentatives espacées de 300ms pour couvrir un écrasement firmware tardif.
+<      */
+<     private fun verifyOneAlert(name: String, desired: Boolean, read: () -> Boolean, write: (Boolean) -> Boolean) {
+<         repeat(3) { i ->
+<             val actual = read()
+<             if (actual == desired) {
+<                 AppLogger.i(TAG, "  [VERIFY] $name conforme (lu=$actual" +
+<                     if (i > 0) ", après $i correction(s))" else ")")
+<                 return
+---
+>                 applyElk(profile.elkMode, profile.elkSensitivity, profile.lasAudibleWarning, profile.lasVibrationReminder)
+251,253d107
+<             AppLogger.w(TAG, "  [VERIFY] $name ÉCART (lu=$actual, attendu=$desired) → réécriture (tentative ${i + 1}/3)")
+<             write(desired)
+<             try { Thread.sleep(300) } catch (_: InterruptedException) {}
+255,259d108
+<         val finalVal = read()
+<         if (finalVal == desired)
+<             AppLogger.i(TAG, "  [VERIFY] $name finalement conforme (lu=$finalVal)")
+<         else
+<             AppLogger.w(TAG, "  [VERIFY] $name ÉCHEC après 3 tentatives (lu=$finalVal, attendu=$desired)")
+262,266c111
+<     /**
+<      * Applique les réglages ELK (assistant de sortie de voie) du profil — tous firmwares.
+<      * Si elkMode=0 (valeur par défaut — profil créé avant l'ajout de l'ELK),
+<      * on ne touche pas aux réglages ELK pour éviter une modification involontaire.
+<      */
+---
+>     
+278,280c123
+<         // SWI132 : Alerte sonore + Vibration appliquées après délai
+<         // Le firmware peut réinitialiser ces valeurs lors du changement de mode ELK.
+<         // 300ms garantit que le firmware a terminé sa réinitialisation interne.
+---
+> 
+290,294c133
+<     /**
+<      * Applique les réglages AEB du profil.
+<      * Si aebEnabled=false ET aebMode=1 ET aebSensitivity=0 (valeurs par défaut),
+<      * on ne touche pas à l'état AEB de la voiture pour éviter une désactivation involontaire.
+<      */
+---
+>     
+
+===== app/src/main/java/com/mg4/control/profile/ProfileManager.kt (+2/-12) =====
+20,23d19
+<     // -------------------------------------------------------------------------
+<     // CRUD
+<     // -------------------------------------------------------------------------
+< 
+29,30c25
+<             // Migration : profils créés avant l'ajout AEB ont aebMode=0 (valeur JVM par défaut).
+<             // On les initialise à AEB activé + mode Alerte+Freinage par défaut.
+---
+> 
+54c49
+<         // Clear default if it was this profile
+---
+> 
+77d71
+<     // [BT-PROFILES] Retourne le premier profil dont le btDeviceMac correspond au MAC donné.
+80,83d73
+< 
+<     // -------------------------------------------------------------------------
+<     // Persistence
+<     // -------------------------------------------------------------------------
+
+===== app/src/main/java/com/mg4/control/receiver/BootReceiver.kt (+0/-2) =====
+31d30
+<         // Essai immédiat
+35d33
+<         // Retry à 3s et 8s au cas où le système n'est pas encore prêt
+
+===== app/src/main/java/com/mg4/control/service/MG4ControlService.kt (+69/-127) =====
+29a30,31
+> import kotlinx.coroutines.SupervisorJob
+> import kotlinx.coroutines.cancel
+33a36,37
+>     private val serviceScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+> 
+40d43
+<         // Intent action broadcast par le système SAIC pour les touches physiques
+43,51c46,50
+<         // Keycodes des boutons ★ du volant
+<         private const val KEYCODE_BTN1     = 17    // STAR_LEFT
+<         private const val KEYCODE_BTN2     = 286   // STAR_RIGHT
+<         private const val KEYCODE_BTN2_ALT = 18    // alias STAR_RIGHT (certains firmwares)
+< 
+<         /**
+<          * Flag one-shot : le profil n'est appliqué qu'une seule fois par session de processus.
+<          * Évite le double-apply quand MainActivity et BootReceiver démarrent le service.
+<          */
+---
+>         private const val KEYCODE_BTN1     = 17
+>         private const val KEYCODE_BTN2     = 286
+>         private const val KEYCODE_BTN2_ALT = 18
+> 
+>         
+56,57d54
+<     // ── Hardkey receiver ─────────────────────────────────────────────────────
+< 
+60d56
+<     // ── [BT-PROFILES] Receiver ACL Bluetooth ─────────────────────────────────
+63d58
+<     // ── Receiver sync thème launcher ─────────────────────────────────────────
+66d60
+<     // ── Listener de cycle d'allumage (Katman5) ──────────────────────────────
+69d62
+<     // État par slot pour la détection d'appui long
+72,74d64
+<     // États des toggles en mémoire — réinitialisés à chaque démarrage du service (= redémarrage voiture)
+<     // Évite le bug du 1er appui : si on utilise SharedPrefs, l'état persisté peut ne pas correspondre
+<     // à l'état réel de la voiture après un redémarrage, causant un toggle dans le mauvais sens.
+83,84c73,74
+<         registerBtAclReceiver()        // [BT-PROFILES]
+<         registerSkinChangeReceiver()   // [THEME-AUTO]
+---
+>         registerBtAclReceiver()
+>         registerSkinChangeReceiver()
+94c84
+<         btAclReceiver?.let { unregisterReceiver(it) }     // [BT-PROFILES]
+---
+>         btAclReceiver?.let { unregisterReceiver(it) }
+96c86
+<         skinChangeReceiver?.let { unregisterReceiver(it) } // [THEME-AUTO]
+---
+>         skinChangeReceiver?.let { unregisterReceiver(it) }
+97a88,89
+>         MG4Hardware.clearPendingReadyListeners()
+>         serviceScope.cancel()
+108,109d99
+<     // ── Enregistrement dynamique du receiver ─────────────────────────────────
+< 
+120,121d109
+<     // ── Traitement d'un event hardkey ────────────────────────────────────────
+< 
+125d112
+<         // Raccourcis désactivés globalement → on laisse le launcher gérer
+128d114
+<         // Lecture du keycode (plusieurs noms d'extra selon le firmware)
+170,171d155
+<     // ── Exécution du toggle ──────────────────────────────────────────────────
+< 
+175d158
+<         // PROFILE_PICKER : overlay flottant au-dessus du launcher — aucun toggle d'état
+183d165
+<         // APPLY_PROFILE : action directe — pas de toggle d'état, chaque pression applique le profil
+186c168
+<             CoroutineScope(Dispatchers.IO).launch {
+---
+>             serviceScope.launch {
+199,200d180
+<         // Pour tous les autres toggles : état en mémoire (réinitialisé au démarrage du service)
+<         // Évite le bug du 1er appui causé par un état SharedPrefs désynchronisé après redémarrage.
+206c186
+<         CoroutineScope(Dispatchers.IO).launch {
+---
+>         serviceScope.launch {
+229d208
+<                     // Tous les firmwares connus stockent des indices 0-4 (Off/Lim.Manuel/Lim.Auto/ACC/ICA|TJA)
+234,235d212
+<                         // VSM (SWI68/69/131/132/165) : index → mode ACC/TJA (setAccTjaMode)
+<                         // + limiteur de vitesse (setSpeedLimiterMode), réglages exclusifs.
+237,241c214,218
+<                             1 -> { MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.MANUEL);      MG4Hardware.setAccTjaMode(Swi68Mode.OFF) }
+<                             2 -> { MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.INTELLIGENT); MG4Hardware.setAccTjaMode(Swi68Mode.OFF) }
+<                             3 -> { MG4Hardware.setAccTjaMode(Swi68Mode.ACC); MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.OFF) }
+<                             4 -> { MG4Hardware.setAccTjaMode(Swi68Mode.TJA); MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.OFF) }
+<                             else -> { MG4Hardware.setAccTjaMode(Swi68Mode.OFF); MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.OFF) }
+---
+>                             1 -> { MG4Hardware.setAccTjaMode(Swi68Mode.OFF); MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.MANUEL) }
+>                             2 -> { MG4Hardware.setAccTjaMode(Swi68Mode.OFF); MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.INTELLIGENT) }
+>                             3 -> { MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.OFF); MG4Hardware.setAccTjaMode(Swi68Mode.ACC) }
+>                             4 -> { MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.OFF); MG4Hardware.setAccTjaMode(Swi68Mode.TJA) }
+>                             else -> { MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.OFF); MG4Hardware.setAccTjaMode(Swi68Mode.OFF) }
+244d220
+<                         // SWI133 : VPM direct (l'index est aussi la valeur mixedIntelligentDrive)
+271,276c247
+<     /**
+<      * Planifie l'application du profil au démarrage du processus (one-shot).
+<      * Priorité : profil BT associé → profil par défaut.
+<      * Si connectedMacs est vide (téléphone connecté avant démarrage du service),
+<      * une requête HFP async est effectuée en fallback.
+<      */
+---
+>     
+292d262
+<         // [BT-PROFILES] Cherche tous les profils BT parmi les appareils déjà connus en mémoire
+299c269
+<                 // Conflit BT : plusieurs appareils ont un profil associé → popup de sélection
+---
+> 
+306,307c276,277
+<                             // Timeout sans sélection → applique le 1er profil (comportement historique)
+<                             CoroutineScope(Dispatchers.IO).launch {
+---
+> 
+>                             serviceScope.launch {
+309c279
+<                                 ProfileApplier.apply(btProfiles[0], autoStart = true) { ok ->
+---
+>                                 ProfileApplier.apply(btProfiles[0]) { ok ->
+321c291
+<                     ProfileApplier.apply(btProfiles[0], autoStart = true) { ok ->
+---
+>                     ProfileApplier.apply(btProfiles[0]) { ok ->
+329d298
+<         // [BT-PROFILES] Fallback : requête HFP async (cas téléphone connecté avant démarrage service)
+342c311
+<                                 CoroutineScope(Dispatchers.IO).launch {
+---
+>                                 serviceScope.launch {
+344c313
+<                                     ProfileApplier.apply(hfpProfiles[0], autoStart = true) { ok ->
+---
+>                                     ProfileApplier.apply(hfpProfiles[0]) { ok ->
+355c324
+<                         ProfileApplier.apply(hfpProfiles[0], autoStart = true) { ok ->
+---
+>                         ProfileApplier.apply(hfpProfiles[0]) { ok ->
+361c330
+<                     // Aucun match BT → profil par défaut
+---
+> 
+370c339
+<                         ProfileApplier.apply(defaultProfile, autoStart = true) { ok ->
+---
+>                         ProfileApplier.apply(defaultProfile) { ok ->
+379,384c348
+<     // ── Listener IGNITION_STATE (Katman5) ────────────────────────────────────
+< 
+<     /**
+<      * Enregistre le listener Katman5 sur les changements d'état d'allumage.
+<      * À chaque RUN (0x2), applique le profil par défaut.
+<      */
+---
+>     
+387,400c351,355
+<             when (state) {
+<                 MG4Hardware.CarIgnitionItem.RUN -> {
+<                     AppLogger.i(TAG, "Katman5 IGNITION_RUN → application du profil")
+<                     Handler(Looper.getMainLooper()).postDelayed({
+<                         applyDefaultProfileOnIgnition()
+<                     }, 500L)
+<                 }
+<                 MG4Hardware.CarIgnitionItem.OFF -> {
+<                     // Extinction → on oublie le choix manuel : le prochain cycle repart sur le défaut/BT
+<                     if (ProfileApplier.lastManualProfileId != null) {
+<                         AppLogger.i(TAG, "Katman5 IGNITION_OFF → reset du choix manuel")
+<                         ProfileApplier.lastManualProfileId = null
+<                     }
+<                 }
+---
+>             if (state == MG4Hardware.CarIgnitionItem.RUN) {
+>                 AppLogger.i(TAG, "Katman5 IGNITION_RUN → application du profil par défaut")
+>                 Handler(Looper.getMainLooper()).postDelayed({
+>                     applyDefaultProfileOnIgnition()
+>                 }, 500L)
+408,411c363
+<     /**
+<      * [BT-PROFILES] Enregistre les receivers ACL Bluetooth pour maintenir
+<      * la liste des appareils connectés dans BluetoothProfileManager.
+<      */
+---
+>     
+421a374,375
+> 
+>                         applyBtProfileForMac(mac)
+438,441c392
+<     /**
+<      * Applique le profil approprié suite à un événement IGNITION_STATE=RUN.
+<      * Priorité : choix manuel récent (popup/app) → profil BT associé → profil par défaut.
+<      */
+---
+>     
+451,471d401
+<         // Choix manuel récent (popup volant / app) → prioritaire sur BT et défaut.
+<         // L'utilisateur a explicitement sélectionné un profil depuis le démarrage : on le respecte.
+<         val manualId = ProfileApplier.lastManualProfileId
+<         if (manualId != null) {
+<             val manualProfile = pm.getById(manualId)
+<             if (manualProfile != null) {
+<                 AppLogger.i(TAG, "IGNITION → choix manuel respecté : '${manualProfile.name}'")
+<                 MG4Hardware.whenKatman1Ready {
+<                     ProfileApplier.apply(manualProfile, autoStart = true) { ok ->
+<                         AppLogger.i(TAG, "IGNITION → profil manuel '${manualProfile.name}' ré-appliqué — ok=$ok")
+<                     }
+<                 }
+<                 return
+<             } else {
+<                 // Profil supprimé entre-temps → on oublie le choix et on retombe sur le défaut/BT
+<                 AppLogger.i(TAG, "IGNITION → choix manuel introuvable (id=$manualId), fallback défaut/BT")
+<                 ProfileApplier.lastManualProfileId = null
+<             }
+<         }
+< 
+<         // [BT-PROFILES] Cherche tous les profils BT parmi les appareils connectés
+484c414
+<                             CoroutineScope(Dispatchers.IO).launch {
+---
+>                             serviceScope.launch {
+486c416
+<                                 ProfileApplier.apply(btProfiles[0], autoStart = true) { ok ->
+---
+>                                 ProfileApplier.apply(btProfiles[0]) { ok ->
+497c427
+<                     ProfileApplier.apply(btProfiles[0], autoStart = true) { ok ->
+---
+>                     ProfileApplier.apply(btProfiles[0]) { ok ->
+503c433
+<                 // Aucun match BT → profil par défaut
+---
+> 
+510c440
+<                     ProfileApplier.apply(defaultProfile, autoStart = true) { ok ->
+---
+>                     ProfileApplier.apply(defaultProfile) { ok ->
+518,525c448
+<     // ── Receiver sync thème launcher (SWI69 / SWI131 / SWI132) ─────────────
+< 
+<     /**
+<      * Écoute le broadcast "com.saicmotor.changeSkin" émis par le launcher MG
+<      * lorsque l'utilisateur change de thème (sombre ↔ clair).
+<      * Ne fait rien si le firmware n'expose pas SKIN_THEME_CONFIG ou si
+<      * l'utilisateur a choisi un thème manuel (mode ≠ "auto").
+<      */
+---
+>     
+528c451
+<             // SWI133/68 : MODE_NIGHT_FOLLOW_SYSTEM gère la sync automatiquement
+---
+> 
+546a470,488
+>     }
+> 
+>     
+>     private fun applyBtProfileForMac(mac: String) {
+>         val prefs = getSharedPreferences("mg4_settings", MODE_PRIVATE)
+>         if (!prefs.getBoolean("auto_apply_profile", true)) {
+>             AppLogger.i(TAG, "[BT] auto_apply_profile désactivé — skip pour $mac")
+>             return
+>         }
+>         val profile = ProfileManager(applicationContext).getProfileForBtDevice(mac) ?: run {
+>             AppLogger.i(TAG, "[BT] Connexion $mac sans profil associé — profil actif conservé")
+>             return
+>         }
+>         AppLogger.i(TAG, "[BT] Connexion $mac → profil '${profile.name}' prioritaire sur le défaut")
+>         MG4Hardware.whenKatman1Ready {
+>             ProfileApplier.apply(profile) { ok ->
+>                 AppLogger.i(TAG, "[BT] Profil '${profile.name}' appliqué — ok=$ok")
+>             }
+>         }
+
+===== app/src/main/java/com/mg4/control/service/ProfilePickerOverlay.kt (+8/-119) =====
+17d16
+< import com.google.android.material.slider.Slider
+20d18
+< import com.mg4.control.hardware.MG4Hardware
+24d21
+< import com.mg4.control.util.LocaleHelper
+29,39d25
+< /**
+<  * Overlay flottant affichant la liste des profils de conduite.
+<  *
+<  * Deux modes d'utilisation :
+<  *  - Raccourci volant → show(ctx) : affiche tous les profils
+<  *  - Conflit BT       → show(ctx, profiles, onAutoDismiss) : affiche uniquement
+<  *    les profils associés aux appareils connectés ; si l'utilisateur ne choisit
+<  *    pas avant le timeout, [onAutoDismiss] est appelé (ex. applique le 1er profil).
+<  *
+<  * Toutes les opérations WindowManager se font sur le thread principal.
+<  */
+51,56c37
+<     // ── API publique ─────────────────────────────────────────────────────────
+< 
+<     /**
+<      * Affiche l'overlay avec tous les profils (raccourci volant).
+<      * Peut être appelé depuis n'importe quel thread.
+<      */
+---
+>     
+61,65c42
+<     /**
+<      * Affiche l'overlay avec une liste restreinte de profils (conflit BT).
+<      * [onAutoDismiss] est appelé si le timeout s'écoule sans sélection.
+<      * Peut être appelé depuis n'importe quel thread.
+<      */
+---
+>     
+70,73c47
+<     /**
+<      * Ferme l'overlay immédiatement (sans déclencher onAutoDismiss).
+<      * Peut être appelé depuis n'importe quel thread.
+<      */
+---
+>     
+78,79d51
+<     // ── Implémentation (main thread) ─────────────────────────────────────────
+< 
+85c57
+<         // Si déjà affiché → on remplace (sans déclencher l'ancien onAutoDismiss)
+---
+> 
+96,104c68
+<         // Le contexte du Service n'applique pas la langue choisie dans l'app
+<         // (LocaleHelper n'est posé que sur MainActivity/MG4App). Sans ça, le popup
+<         // tombe sur la langue système. On enveloppe avec la locale courante (lecture
+<         // fraîche → reflète un changement de langue en cours de session).
+<         val localizedContext = LocaleHelper.applyLocale(context)
+< 
+<         // Le contexte du Service n'a pas de thème Material → on l'enveloppe
+<         // avec le thème de l'app pour que MaterialButton puisse s'instancier.
+<         val themedContext = ContextThemeWrapper(localizedContext, R.style.Theme_MG4Control)
+---
+>         val themedContext = ContextThemeWrapper(context, R.style.Theme_MG4Control)
+106d69
+<         // Inflate la vue depuis le layout XML (utilise le contexte thémé)
+109d71
+<         // ── Grille 2 colonnes de profils ─────────────────────────────────
+136d97
+<         // Découpe en lignes de 2, chaque ligne = LinearLayout horizontal
+155d115
+<             // Nombre impair → placeholder invisible pour garder la symétrie
+166d125
+<         // ── Fermeture manuelle ────────────────────────────────────────────
+171d129
+<         // ── Tap sur le fond → fermeture ───────────────────────────────────
+175,176d132
+<         // La carte intérieure intercepte les appuis sans propager au fond
+<         view.findViewById<View>(R.id.overlay_card)?.setOnClickListener { /* consommer */ }
+178c134,135
+<         // ── Paramètres WindowManager ──────────────────────────────────────
+---
+>         view.findViewById<View>(R.id.overlay_card)?.setOnClickListener {  }
+> 
+193d149
+<         // ── Compte à rebours ──────────────────────────────────────────────
+200c156
+<                 tvCountdown?.text = localizedContext.getString(R.string.overlay_countdown, remaining)
+---
+>                 tvCountdown?.text = context.getString(R.string.overlay_countdown, remaining)
+210,213d165
+<         // ── Fermeture automatique ─────────────────────────────────────────
+<         // onAutoDismiss est appelé UNIQUEMENT ici (timeout sans sélection).
+<         // Si l'utilisateur choisit un profil ou appuie sur Fermer,
+<         // dismissOnMainThread(fireAutoDismiss=false) annule ce runnable.
+221,283d172
+< 
+<         // Ré-arme les deux timers (appelé à chaque interaction luminosité pour
+<         // ne pas fermer le popup pendant le réglage).
+<         fun resetTimers() {
+<             handler.removeCallbacks(dr)
+<             handler.postDelayed(dr, AUTO_DISMISS_MS)
+<             countdownRunnable?.let { handler.removeCallbacks(it) }
+<             remaining = (AUTO_DISMISS_MS / 1_000L).toInt()
+<             handler.post(tick)
+<         }
+< 
+<         // ── Bloc luminosité (ancien SDK SWI133/68/165 ; A9 = phase 2) ─────
+<         val briSection = view.findViewById<View>(R.id.overlay_brightness_section)
+<         if (!MG4Hardware.hasBrightnessControl()) {
+<             briSection?.visibility = View.GONE
+<         } else {
+<             val slider   = view.findViewById<Slider>(R.id.overlay_bri_slider)
+<             val briValue = view.findViewById<TextView>(R.id.overlay_bri_value)
+< 
+<             fun applyBrightnessAsync(pct: Int) {
+<                 CoroutineScope(Dispatchers.IO).launch { MG4Hardware.setScreenBrightnessPercent(pct) }
+<             }
+<             // Debounce des écritures pendant le glissement (évite de spammer le binder)
+<             val pendingApply = Runnable { slider?.let { applyBrightnessAsync(it.value.toInt()) } }
+< 
+<             slider?.addOnChangeListener { _, value, fromUser ->
+<                 briValue?.text = "${value.toInt()}%"
+<                 if (fromUser) {
+<                     resetTimers()
+<                     handler.removeCallbacks(pendingApply)
+<                     handler.postDelayed(pendingApply, 60L)
+<                 }
+<             }
+<             slider?.addOnSliderTouchListener(object : Slider.OnSliderTouchListener {
+<                 override fun onStartTrackingTouch(s: Slider) { resetTimers() }
+<                 override fun onStopTrackingTouch(s: Slider) {
+<                     handler.removeCallbacks(pendingApply)
+<                     applyBrightnessAsync(s.value.toInt())   // application finale
+<                     resetTimers()
+<                 }
+<             })
+< 
+<             // Presets — déplacent le curseur (met à jour le label via le listener) puis appliquent
+<             fun preset(pct: Int) {
+<                 slider?.value = pct.toFloat()
+<                 applyBrightnessAsync(pct)
+<                 resetTimers()
+<             }
+<             view.findViewById<View>(R.id.overlay_bri_night)?.setOnClickListener { preset(15) }
+<             view.findViewById<View>(R.id.overlay_bri_mid)?.setOnClickListener   { preset(50) }
+<             view.findViewById<View>(R.id.overlay_bri_day)?.setOnClickListener   { preset(100) }
+< 
+<             // Initialisation depuis la valeur courante (lecture binder en arrière-plan)
+<             briValue?.text = "…"
+<             CoroutineScope(Dispatchers.IO).launch {
+<                 val cur = MG4Hardware.getScreenBrightnessPercent()
+<                 handler.post {
+<                     if (overlayView == null) return@post
+<                     if (cur >= 0) slider?.value = cur.coerceIn(5, 100).toFloat()  // label via le listener
+<                     else briValue?.text = "--%"
+<                 }
+<             }
+<         }
+
+===== app/src/main/java/com/mg4/control/ui/AdasFragment.kt (+11/-41) =====
+20d19
+<     // SWI133 views
+29d27
+<     // SWI68/69/131/165 views — 5 boutons (index 0-4) : Off / Lim.Manuel / Lim.Auto / ACC / TJA
+37d34
+<     // AEB views (communes SWI133 + SWI68)
+46d42
+<     // index 0-4 → button (Off / Lim.Manuel / Lim.Auto / ACC / TJA)
+59c55
+<         // ── Références views ────────────────────────────────────────────────
+---
+> 
+77d72
+<         // ── Afficher la bonne section selon le firmware ──────────────────────
+82,84d76
+<         // SWI133 : 5 boutons ADAS (Off/Limiteur/Auto/ACC/ICA)
+<         // SWI132 : 4 boutons ADAS (Off/Lim/ACC/ICA) — même section que SWI133, bouton Auto masqué
+<         // SWI68/SWI69/SWI131/SWI165 : 3 boutons ADAS (Off/ACC/TJA)
+89d80
+<         // Ligne du bas (AEB + alertes) — disponible si firmware connu
+92,93d82
+<         // Alertes : colonne droite — SWI133 et SWI132 ont 2 alertes séparées (survitesse + ton)
+<         //                          — SWI68/SWI69/SWI131/SWI165 ont une seule alerte sonore VSM
+99d87
+<         // ── Listeners SWI133 ─────────────────────────────────────────────────
+119,122d106
+<         // ── Listeners SWI132 — alertes + ADAS 5 modes ─────────────────────────
+<         // Off / Lim.Manuel / Lim.Auto(Intelligent) / ACC / ICA.
+<         // Le mode ACC/TJA (setAccTjaMode) et le limiteur de vitesse (setSasMode) sont deux
+<         // réglages indépendants : le sélecteur unique impose l'exclusivité.
+132d115
+<             // Le bouton Auto est disponible sur SWI132 : il sélectionne le limiteur Intelligent.
+144d126
+<         // ── Listeners AEB (communs SWI133 + SWI68) ──────────────────────────
+168,170d149
+<         // ── Listeners SWI68 / SWI69 / SWI131 / SWI165 — sélecteur 5 modes (index 0-4) ─
+<         // Off / Lim.Manuel / Lim.Auto / ACC / TJA. Mode ACC/TJA + limiteur indépendants,
+<         // exclusivité via le sélecteur unique (même logique que SWI132).
+194,199c173
+<     /**
+<      * SWI132 : applique l'index du sélecteur ADAS (0-4) en distinguant le mode ACC/TJA
+<      * (setAccTjaMode) du limiteur de vitesse (setSasMode). Le sélecteur unique impose
+<      * l'exclusivité : choisir un mode désactive l'autre sous-système.
+<      *   0=Off, 1=Lim.Manuel(SAS 2), 2=Lim.Auto/Intelligent(SAS 3), 3=ACC, 4=ICA
+<      */
+---
+>     
+202,206c176,182
+<             1 -> { MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.MANUEL);      MG4Hardware.setAccTjaMode(Swi68Mode.OFF) }
+<             2 -> { MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.INTELLIGENT); MG4Hardware.setAccTjaMode(Swi68Mode.OFF) }
+<             3 -> { MG4Hardware.setAccTjaMode(Swi68Mode.ACC); MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.OFF) }
+<             4 -> { MG4Hardware.setAccTjaMode(Swi68Mode.TJA); MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.OFF) }
+<             else -> { MG4Hardware.setAccTjaMode(Swi68Mode.OFF); MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.OFF) }
+---
+> 
+>             1 -> { MG4Hardware.setAccTjaMode(Swi68Mode.OFF); MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.MANUEL) }
+>             2 -> { MG4Hardware.setAccTjaMode(Swi68Mode.OFF); MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.INTELLIGENT) }
+> 
+>             3 -> { MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.OFF); MG4Hardware.setAccTjaMode(Swi68Mode.ACC) }
+>             4 -> { MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.OFF); MG4Hardware.setAccTjaMode(Swi68Mode.TJA) }
+>             else -> { MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.OFF); MG4Hardware.setAccTjaMode(Swi68Mode.OFF) }
+210d185
+<     /** SWI132 : état lu (mode ACC/TJA + limiteur SAS) → index de bouton (0-4). */
+229,232d203
+<     /**
+<      * SWI132 : rafraîchit l'état ADAS (mode Off/Lim/ACC/ICA via CarVehicleSettingClient),
+<      * les alertes sonores (via binder getter TX 0x129/0x12b) et l'AEB.
+<      */
+235c206
+<         val sas       = MG4Hardware.getSpeedLimiterMode()   // limiteur : 0=Off, 2=Manuel, 3=Intelligent
+---
+>         val sas       = MG4Hardware.getSpeedLimiterMode()
+246d216
+<             // SWI132 : mode ACC/TJA + limiteur SAS → index bouton (0-4)
+279c249
+<         val sas     = MG4Hardware.getSpeedLimiterMode()   // limiteur : 0=Off, 2=Manuel, 3=Intelligent
+---
+>         val sas     = MG4Hardware.getSpeedLimiterMode()
+
+===== app/src/main/java/com/mg4/control/ui/ClimateFragment.kt (+1/-3) =====
+34d33
+<         // isPressed guard prevents the listener firing on programmatic setChecked()
+55,56c54
+<             // getSeatHeatLeft returns -1 (coerced to 0) when HVAC not ready;
+<             // use -1 raw to detect not-ready state
+---
+> 
+
+===== app/src/main/java/com/mg4/control/ui/ConsoleFragment.kt (+0/-4) =====
+57,58d56
+<     // ---- Status banner ----
+< 
+77,78d74
+< 
+<     // ---- Log list ----
+
+===== app/src/main/java/com/mg4/control/ui/DashboardFragment.kt (+63/-176) =====
+29,33d28
+< /**
+<  * Fragment principal du dashboard — ViewPager2 horizontal.
+<  *   Page 0 : paramètres de conduite, climat, alertes, AEB
+<  *   Page 1 : Assistant de sortie de voie (ELK)
+<  */
+36d30
+<     // ── ViewPager ────────────────────────────────────────────────────────────
+40d33
+<     // ── Page 0 — Drive mode ─────────────────────────────────────────────────
+43d35
+<     // ── Page 0 — Régénération ───────────────────────────────────────────────
+46d37
+<     // ── Page 0 — ADAS SWI133 ────────────────────────────────────────────────
+49d39
+<     private var btnAdasAuto: Button?    = null
+53c43
+<         get() = mapOf(0 to btnAdasOff, 1 to btnAdasLimiteur, 2 to btnAdasAuto, 3 to btnAdasAcc, 4 to btnAdasIca)
+---
+>         get() = mapOf(0 to btnAdasOff, 1 to btnAdasLimiteur, 3 to btnAdasAcc, 4 to btnAdasIca)
+55,56d44
+<     // ── Page 0 — ADAS SWI68/69/131/165 (5 boutons index 0-4) ────────────────
+<     // Off / Lim.Manuel / Lim.Auto / ACC / TJA
+58,59d45
+<     private var btnSwi68Lim: Button? = null
+<     private var btnSwi68Auto: Button? = null
+63c49
+<         get() = mapOf(0 to btnSwi68Off, 1 to btnSwi68Lim, 2 to btnSwi68Auto, 3 to btnSwi68Acc, 4 to btnSwi68Tja)
+---
+>         get() = mapOf(Swi68Mode.OFF to btnSwi68Off, Swi68Mode.ACC to btnSwi68Acc, Swi68Mode.TJA to btnSwi68Tja)
+65d50
+<     // ── Page 0 — Climat ─────────────────────────────────────────────────────
+70d54
+<     // ── Page 0 — Alertes ────────────────────────────────────────────────────
+76d59
+<     // ── Page 0 — TSR + Économie d'énergie ───────────────────────────────────
+80c63
+<     /** Dernier mode de conduite connu — nécessaire pour arbitrer les exclusions SNOW / Éco énergie. */
+---
+>     
+83d65
+<     // ── AEB : page 0 pour VSM-based, page 1 (SWI133) pour les autres ───────────
+93d74
+<     // ── Page 1 — ELK ────────────────────────────────────────────────────────
+101c82
+<     // SWI132 ELK extra
+---
+> 
+109c90
+<     /** True pendant les mises à jour programmatiques des Switch — bloque les listeners. */
+---
+>     
+111c92
+<     /** Dernier mode ELK actif connu (pour restaurer le mode lors du toggle ON). */
+---
+>     
+114d94
+<     // ── Couleurs (lazy pour contexte disponible) ─────────────────────────────
+124,127d103
+<     // ═════════════════════════════════════════════════════════════════════════
+<     //  Lifecycle
+<     // ═════════════════════════════════════════════════════════════════════════
+< 
+144c120
+<                 if (FirmwareInfo.isVsmBased()) refreshElk()  // ELK utilise sVsm sur ces firmwares
+---
+>                 if (FirmwareInfo.isVsmBased()) refreshElk()
+147c123
+<         refreshElk()  // SWI133 — sVsm133 indépendant de Katman4
+---
+>         refreshElk()
+150,153d125
+<     // ═════════════════════════════════════════════════════════════════════════
+<     //  ViewPager2 — Adapter + Dots
+<     // ═════════════════════════════════════════════════════════════════════════
+< 
+159c131
+<         pager?.offscreenPageLimit = 1  // garde les 2 pages en mémoire
+---
+>         pager?.offscreenPageLimit = 1
+161d132
+<         // Dots
+179c150
+<                 // Refresh ELK quand on arrive sur la page 1
+---
+> 
+208,211d178
+<     // ═════════════════════════════════════════════════════════════════════════
+<     //  Page 0 — Binding, visibility, listeners  (code existant)
+<     // ═════════════════════════════════════════════════════════════════════════
+< 
+216c183
+<         // Refresh immédiat (la page vient d'être créée)
+---
+> 
+228c195
+<         // Drive
+---
+> 
+235d201
+<         // Regen
+243d208
+<         // ADAS SWI133
+246d210
+<         btnAdasAuto     = view.findViewById(R.id.btn_adas_auto)
+250,255c214,216
+<         // ADAS SWI68
+<         btnSwi68Off  = view.findViewById(R.id.btn_swi68_off)
+<         btnSwi68Lim  = view.findViewById(R.id.btn_swi68_lim)
+<         btnSwi68Auto = view.findViewById(R.id.btn_swi68_auto)
+<         btnSwi68Acc  = view.findViewById(R.id.btn_swi68_acc)
+<         btnSwi68Tja  = view.findViewById(R.id.btn_swi68_tja)
+---
+>         btnSwi68Off = view.findViewById(R.id.btn_swi68_off)
+>         btnSwi68Acc = view.findViewById(R.id.btn_swi68_acc)
+>         btnSwi68Tja = view.findViewById(R.id.btn_swi68_tja)
+257d217
+<         // Climat
+268d227
+<         // Alertes
+274d232
+<         // TSR + Économie d'énergie
+278d235
+<         // AEB déplacé sur page 1 pour tous les firmwares — pas de binding ici
+288d244
+<         // SWI132 utilise les 4 boutons Off/Lim/ACC/ICA (même groupe que SWI133), pas Off/ACC/TJA
+291c247
+<         // SWI132 utilise deux alertes séparées (survitesse + ton) comme SWI133, pas soundWarning
+---
+> 
+294c250
+<         // AEB déplacé sur page 1 pour tous les firmwares
+---
+> 
+297c253
+<         // TSR + Économie d'énergie — tous firmwares connus
+---
+> 
+309d264
+<         // Drive mode
+317d271
+<         // Regen
+325,328d278
+<         // ADAS
+<         // SWI133/UNKNOWN : setMixedIntelligentDrive (VPM) — indices 0/1/3/4 → Off/Lim/ACC/ICA
+<         // SWI132          : setAccTjaMode (VSM) — valeurs 0x4/0x3/0x1/0x2 → Off/Lim/ACC/ICA
+<         // SWI68/SWI69/SWI131/SWI165 : setAccTjaMode (VSM) — valeurs 0x4/0x1/0x2 → Off/ACC/TJA
+334,336c284
+<                             // SWI132 : mode ACC/TJA (setAccTjaMode) et limiteur de vitesse (setSasMode)
+<                             // sont deux réglages indépendants ; le sélecteur unique impose l'exclusivité.
+<                             applyVsmAdasMode(modeIndex)
+---
+>                             MG4Hardware.setAccTjaMode(swi133IndexToSwi132Value(modeIndex))
+345,347c293
+<             // SWI68/SWI69/SWI131/SWI165 : sélecteur 5 modes (index 0-4), même logique que SWI132
+<             // (mode ACC/TJA + limiteur de vitesse indépendants, exclusivité via le sélecteur unique).
+<             swi68AdasMap.forEach { (modeIndex, btn) ->
+---
+>             swi68AdasMap.forEach { (modeValue, btn) ->
+350,351c296,297
+<                         applyVsmAdasMode(modeIndex)
+<                         withContext(Dispatchers.Main) { if (isAdded) applySwi68AdasUI(modeIndex) }
+---
+>                         MG4Hardware.setAccTjaMode(modeValue)
+>                         withContext(Dispatchers.Main) { if (isAdded) applySwi68AdasUI(modeValue) }
+357d302
+<         // Climat
+371d315
+<         // Alertes SWI133 + SWI132 (deux toggles indépendants : survitesse + ton limite)
+383d326
+<         // Alerte sonore SWI68/SWI69/SWI131/SWI165 (un seul toggle)
+391d333
+<         // TSR — tous firmwares connus
+397,399c339
+<                     // Mise à jour UI immédiate — pas besoin d'attendre le hardware :
+<                     // TSR OFF → alertes forcées à OFF et section grisée (non modifiable)
+<                     // TSR ON  → section ré-activée ; les valeurs réelles sont lues après le SET
+---
+> 
+415,420c355
+<                                         // Le firmware SWI133 remet overspeed/speedTone à ON dès que
+<                                         // le TSR est activé. setTsrMode() les restaure ensuite via VPM,
+<                                         // mais les écritures VPM ont une latence de propagation pouvant
+<                                         // dépasser 500ms : lire le hardware ici renverrait encore ON.
+<                                         // → On utilise directement les valeurs sauvegardées en prefs,
+<                                         //   qui sont exactement ce que setTsrMode() vient de restaurer.
+---
+> 
+431,432c366
+<                                         // SWI132 : activer le TSR réinitialise overspeed/speedTone à ON
+<                                         // dans la voiture. Forcer les toggles à ON dans l'UI directement.
+---
+> 
+450d383
+<         // Économie d'énergie — tous firmwares connus
+461d393
+<         // AEB : listeners sur page 1 via setupAebPage2Listeners() — rien ici
+464,467d395
+<     // ═════════════════════════════════════════════════════════════════════════
+<     //  Page 1 — ELK : Binding + Listeners
+<     // ═════════════════════════════════════════════════════════════════════════
+< 
+470c398
+<         // ELK — switch principal : IDs différents selon le firmware
+---
+> 
+472c400
+<             // SWI132 : layout multi-lignes dans elk_activation_swi132
+---
+> 
+478c406
+<             // SWI132 : pas de mode Emergency — masqué
+---
+> 
+481c409
+<             // Défaut SWI132 : Alerte (mode 2), pas Emergency
+---
+> 
+493d420
+<         // AEB — page 1 pour tous les firmwares connus
+513c440
+<         // Toggle ON/OFF
+---
+> 
+517c444
+<                 // SWI132 : grise les 2 switches supplémentaires si désactivé
+---
+> 
+531d457
+<         // SWI132 — Alerte sonore
+543d468
+<         // Mode buttons
+554d478
+<         // Sensitivity buttons
+566c490
+<         // Toggle ON/OFF
+---
+> 
+575c499
+<         // Mode
+---
+> 
+588c512
+<         // Sensibilité
+---
+> 
+617,634c541,556
+<     // ═════════════════════════════════════════════════════════════════════════
+<     //  Helpers UI
+<     // ═════════════════════════════════════════════════════════════════════════
+< 
+<     /**
+<      * SWI132 : applique l'index du sélecteur ADAS en distinguant le mode ACC/TJA (setAccTjaMode)
+<      * du limiteur de vitesse (setSasMode), deux réglages indépendants sur la voiture. Le sélecteur
+<      * unique impose l'exclusivité : choisir un mode désactive l'autre sous-système.
+<      *   0=Off, 1=Lim.Manuel(SAS 2), 2=Lim.Auto/Intelligent(SAS 3), 3=ACC, 4=ICA
+<      */
+<     private fun applyVsmAdasMode(index: Int) {
+<         when (index) {
+<             1 -> { MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.MANUEL);      MG4Hardware.setAccTjaMode(Swi68Mode.OFF) }
+<             2 -> { MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.INTELLIGENT); MG4Hardware.setAccTjaMode(Swi68Mode.OFF) }
+<             3 -> { MG4Hardware.setAccTjaMode(Swi68Mode.ACC); MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.OFF) }
+<             4 -> { MG4Hardware.setAccTjaMode(Swi68Mode.TJA); MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.OFF) }
+<             else -> { MG4Hardware.setAccTjaMode(Swi68Mode.OFF); MG4Hardware.setSpeedLimiterMode(MG4Hardware.SasMode.OFF) }
+<         }
+---
+>     
+>     private fun swi132ValueToSwi133Index(value: Int): Int = when (value) {
+>         Swi68Mode.OFF  -> 0
+>         Swi68Mode.SHWA -> 1
+>         Swi68Mode.ACC  -> 3
+>         Swi68Mode.TJA  -> 4
+>         else           -> 0
+>     }
+> 
+>     
+>     private fun swi133IndexToSwi132Value(index: Int): Int = when (index) {
+>         0 -> Swi68Mode.OFF
+>         1 -> Swi68Mode.SHWA
+>         3 -> Swi68Mode.ACC
+>         4 -> Swi68Mode.TJA
+>         else -> Swi68Mode.OFF
+637,653c559
+<     /**
+<      * SWI132 : convertit l'état lu (mode ACC/TJA + limiteur SAS) en index de bouton (0-4).
+<      * Manuel→1 (Lim.Manuel), Intelligent→2 (Lim.Auto), ACC→3, TJA→4, sinon Off→0.
+<      */
+<     private fun vsmStateToIndex(accTja: Int, sas: Int): Int = when {
+<         sas == MG4Hardware.SasMode.MANUEL      -> 1
+<         sas == MG4Hardware.SasMode.INTELLIGENT -> 2
+<         accTja == Swi68Mode.ACC                -> 3
+<         accTja == Swi68Mode.TJA                -> 4
+<         else                                   -> 0
+<     }
+< 
+<     /**
+<      * SWI133 / SWI132 : active ou grise la section des 2 alertes sonores.
+<      * Quand le TSR (RECO. PANNEAUX) est OFF, les alertes sont désactivées et non modifiables.
+<      * L'alpha est appliqué sur le conteneur entier (labels + switches) pour un rendu cohérent.
+<      */
+---
+>     
+660,663d565
+<     // ═════════════════════════════════════════════════════════════════════════
+<     //  Refresh depuis le hardware
+<     // ═════════════════════════════════════════════════════════════════════════
+< 
+665c567
+<         if (driveModeButtons.isEmpty()) return  // page pas encore créée
+---
+>         if (driveModeButtons.isEmpty()) return
+702,703c604
+<         // Vérifie que les boutons ADAS de page 0 sont créés (AEB est sur page 1)
+<         // SWI132 utilise les boutons swi133 (Off/Lim/ACC/ICA), pas les boutons swi68
+---
+> 
+737c638
+<             setAlertsSwi133Enabled(tsrOn)   // grise les alertes si TSR est OFF
+---
+>             setAlertsSwi133Enabled(tsrOn)
+744,747c645
+<     /**
+<      * SWI132 : mode ACC/TJA (CarVehicleSettingClient) + alertes binder direct
+<      * (overspeed TX 0x129, speedTone TX 0x12b) + TSR binder direct + AEB + économie.
+<      */
+---
+>     
+750d647
+<         val sas          = MG4Hardware.getSpeedLimiterMode()   // limiteur : 0=Off, 2=Manuel, 3=Intelligent
+770,771c667,668
+<             setAlertsSwi133Enabled(tsrOn)   // grise les alertes si TSR est OFF
+<             applySwi133AdasUI(vsmStateToIndex(mode, sas))  // SWI132 : Off/Limiteur/ACC/ICA
+---
+>             setAlertsSwi133Enabled(tsrOn)
+>             applySwi133AdasUI(swi132ValueToSwi133Index(mode))
+779d675
+<         val sas          = MG4Hardware.getSpeedLimiterMode()   // limiteur : 0=Off, 2=Manuel, 3=Intelligent
+797c693
+<             applySwi68AdasUI(vsmStateToIndex(mode, sas))
+---
+>             applySwi68AdasUI(mode)
+804c700
+<         if (switchElk == null) return  // page pas encore créée
+---
+>         if (switchElk == null) return
+830,833d725
+<     // ═════════════════════════════════════════════════════════════════════════
+<     //  Helpers UI — Page 0
+<     // ═════════════════════════════════════════════════════════════════════════
+< 
+838c730
+<         // Regen : indisponible si Éco actif OU si SNOW sélectionné
+---
+> 
+854c746
+<         // Regen : indisponible si SNOW OU si Éco énergie actif
+---
+> 
+856c748
+<         // Bouton Éco énergie : indisponible en mode SNOW (modes exclusifs)
+---
+> 
+873,874c765
+<             // ONE_PEDAL reste accessible même quand Éco énergie est actif,
+<             // sauf en mode SNOW où tous les niveaux de regen sont indisponibles.
+---
+> 
+927,930d817
+< 
+<     // ═════════════════════════════════════════════════════════════════════════
+<     //  Helpers UI — Page 1 (ELK)
+<     // ═════════════════════════════════════════════════════════════════════════
+
+===== app/src/main/java/com/mg4/control/ui/DriveRegenFragment.kt (+2/-2) =====
+97c97
+<         // SNOW : regen forcée faible par le véhicule → griser les boutons regen
+---
+> 
+111c111
+<     /** Active ou grise les boutons de régénération. */
+---
+>     
+
+===== app/src/main/java/com/mg4/control/ui/ProfileAdapter.kt (+1/-1) =====
+50c50
+<             // SWI68/SWI69/SWI131 : mêmes modes ADAS (ACC / TJA / Off)
+---
+> 
+
+===== app/src/main/java/com/mg4/control/ui/ProfileFragment.kt (+16/-63) =====
+86d85
+<         // ── Bouton Fermer ─────────────────────────────────────────────────────
+111,114d109
+<     // -------------------------------------------------------------------------
+<     // Nouveau profil : lit l'état hardware courant puis ouvre le dialog pré-rempli
+<     // -------------------------------------------------------------------------
+< 
+120c115
+<                 // SWI68/SWI69/SWI131/SWI132/SWI165 : ADAS ACC/TJA — sièges/volant uniquement sur SWI68/SWI165
+---
+> 
+132c127
+<                     // SWI132 : deux alertes indépendantes comme SWI133 (pas de soundWarning VSM)
+---
+> 
+136d130
+<                     // Mode ACC/TJA — SHWA (ancien codage limiteur) ramené à Off (limiteur géré à part)
+140d133
+<                     // Limiteur de vitesse — capturé pour tous les firmwares VSM (SWI68/69/131/132/165)
+154c147
+<                 // SWI133/UNKNOWN : ADAS mixte, sièges et volant chauffants
+---
+> 
+183,186d175
+<     // -------------------------------------------------------------------------
+<     // Dialog d'édition / création — style dark MaterialButton
+<     // -------------------------------------------------------------------------
+< 
+192d180
+<         // ── Couleurs ─────────────────────────────────────────────────────────
+202c190
+<         /** Lie un groupe de boutons : un seul actif à la fois. Retourne une lambda pour lire la valeur courante. */
+---
+>         
+213,214c201
+<         // ── Variables de sélection ───────────────────────────────────────────
+<         var selectedBtMac: String? = data.btDeviceMac   // [BT-PROFILES]
+---
+>         var selectedBtMac: String? = data.btDeviceMac
+222c209
+<         var swi132SasMode   = data.swi132SasMode                       // 0=Off, 2=Manuel, 3=Intelligent
+---
+>         var swi132SasMode   = data.swi132SasMode
+230c217
+<         /** Dernier mode ELK actif pour restauration après toggle ON */
+---
+>         
+237d223
+<         // ── Bouton Éco énergie — déclaré tôt pour être accessible dans le binding drive mode ─
+240d225
+<         // ── Mode de conduite ─────────────────────────────────────────────────
+263,264c248
+<                 // ONE_PEDAL reste accessible même quand Éco énergie est actif,
+<                 // sauf en mode SNOW où tous les niveaux de regen sont indisponibles.
+---
+> 
+274c258
+<             // Regen : indisponible si SNOW ou Éco énergie actif (ONE_PEDAL exempt de l'Éco)
+---
+> 
+276c260
+<             // Bouton Éco énergie : indisponible en mode SNOW (modes exclusifs)
+---
+> 
+282c266
+<         // État initial : regen indisponible si SNOW ou Éco énergie déjà actif
+---
+> 
+285d268
+<         // ── Régénération ─────────────────────────────────────────────────────
+296d278
+<         // ── Volant chauffant ─────────────────────────────────────────────────
+303d284
+<         // ── Siège gauche ─────────────────────────────────────────────────────
+312d292
+<         // ── Siège droit ──────────────────────────────────────────────────────
+321d300
+<         // ── Sections Climat (Volant + Sièges) — masquées si pas de chauffage (SWI69/SWI131) ─
+328d306
+<         // ── Section AEB (commune SWI133 + SWI68 + SWI69) ────────────────────
+336d313
+<             // Sensibilité AEB — SWI133 uniquement
+378d354
+<         // ── Section ELK (tous firmwares connus) ─────────────────────────────
+392d367
+<             // SWI132 : pas de mode Emergency + 2 switches supplémentaires
+461d435
+<         // ── Sections ADAS ────────────────────────────────────────────────────
+468,470d441
+<                 // SWI132 : 5 boutons ADAS Off/Lim.Manuel/Lim.Auto/ACC/ICA + alertes séparées.
+<                 // Le mode ACC/TJA (swi68Mode) et le limiteur de vitesse (swi132SasMode) sont
+<                 // deux réglages indépendants ; le sélecteur unique impose l'exclusivité.
+502,503d472
+<                 // SWI68/SWI69/SWI131/SWI165 : section SWI68 (5 boutons + alerte sonore).
+<                 // Off / Lim.Manuel / Lim.Auto / ACC / TJA — mode ACC/TJA + limiteur indépendants.
+533c502
+<                 // SWI133/UNKNOWN : section SWI133 (overspeed + speedTone + 5 boutons ADAS)
+---
+> 
+551,552d519
+<         // ── Économie d'énergie + TSR (tous firmwares connus) ───────────────
+<         // btn_energy_saving_d est en Col 1 (drive section), section_tsr_dialog en Col 2
+556c523
+<             // Grisé si SNOW est déjà sélectionné à l'ouverture du dialog
+---
+> 
+564c531
+<                 // Regen : indisponible si Éco actif ou si SNOW sélectionné
+---
+> 
+567d533
+<             // Note : l'état initial de la regen est déjà géré après le bindGroup des modes
+575d540
+<         // ── [BT-PROFILES] Spinner appareil Bluetooth ────────────────────────
+578d542
+<         // "Aucun" en première entrée, suivi des appareils appairés
+582d545
+<         // Chargement async des appareils appairés, puis population du Spinner
+595d557
+<                 // Pré-sélectionner l'appareil déjà associé au profil
+601d562
+<                 // Callback de sélection — stocké dans une var accessible lors du Save
+608c569
+<                 // Initialise selectedBtMac avec la valeur pré-sélectionnée
+---
+> 
+613d573
+<         // ── Profil par défaut ────────────────────────────────────────────────
+617d576
+<         // ── Nom ──────────────────────────────────────────────────────────────
+621d579
+<         // ── Création du dialog sans chrome Android ───────────────────────────
+628d585
+<         // Titre dynamique intégré dans le layout
+632d588
+<         // ── Bouton Annuler ───────────────────────────────────────────────────
+637d592
+<         // ── Bouton Enregistrer : ne ferme PAS si le nom est vide ────────────
+646d600
+<             // SWI132 utilise désormais sectionSwi133 (mêmes IDs que SWI133 — sans suffixe _d)
+675c629
+<                 btDeviceMac    = selectedBtMac   // [BT-PROFILES]
+---
+>                 btDeviceMac    = selectedBtMac
+685d638
+<         // Borner la taille du dialog : footer toujours visible + largeur adaptée à 3 colonnes
+
+===== app/src/main/java/com/mg4/control/ui/SettingsFragment.kt (+11/-178) =====
+7d6
+< import android.content.Intent
+10d8
+< import com.mg4.control.MainActivity
+12d9
+< import android.graphics.Bitmap
+16d12
+< import android.net.Uri
+22d17
+< import android.widget.ImageView
+30,32d24
+< import com.google.zxing.BarcodeFormat
+< import com.google.zxing.EncodeHintType
+< import com.google.zxing.MultiFormatWriter
+37,38d28
+< import com.mg4.control.update.UpdateChecker
+< import com.mg4.control.update.UpdateDialogManager
+48,49c38
+<     private val githubUrl = "https://github.com/SliDeeN/MG4Control"
+<     private val gitlabUrl = "https://gitlab.com/SliDeeN/mg4control"
+---
+>     private var updateClickCount = 0
+65d53
+<         // ── Langue ───────────────────────────────────────────────────────────
+94d81
+<         // ── Écran par défaut ─────────────────────────────────────────────────
+122d108
+<         // ── Thème : Auto / Sombre / Clair ───────────────────────────────────
+155d140
+<         // ── Auto-apply ───────────────────────────────────────────────────────
+162d146
+<         // ── Vérification auto des mises à jour ───────────────────────────────
+169,192d152
+<         // ── Alimentation véhicule (SWI133) — éteint la voiture, garde l'écran ──
+<         val rowVehiclePower = view.findViewById<View>(R.id.row_vehicle_power)
+<         val dividerVehiclePower = view.findViewById<View>(R.id.row_vehicle_power_divider)
+<         val btnVehiclePower = view.findViewById<MaterialButton>(R.id.btn_vehicle_power_off)
+<         if (!MG4Hardware.hasVehiclePowerOff()) {
+<             rowVehiclePower.visibility = View.GONE
+<             dividerVehiclePower.visibility = View.GONE
+<         } else {
+<             btnVehiclePower.setOnClickListener {
+<                 AlertDialog.Builder(requireContext())
+<                     .setTitle(R.string.vehicle_power_dialog_title)
+<                     .setMessage(R.string.vehicle_power_dialog_msg)
+<                     .setNegativeButton(R.string.vehicle_power_dialog_cancel, null)
+<                     .setPositiveButton(R.string.vehicle_power_dialog_confirm) { _, _ ->
+<                         CoroutineScope(Dispatchers.IO).launch {
+<                             val ok = MG4Hardware.vehiclePowerOff()
+<                             AppLogger.i("MG4_SETTINGS", "Vehicle power off → $ok")
+<                         }
+<                     }
+<                     .show()
+<             }
+<         }
+< 
+<         // ── Bouton Vérifier mise à jour ──────────────────────────────────────
+195,198d154
+<         val originalUpdateText = getString(R.string.btn_check_update)
+< 
+<         // Bouton Diagnostic débloqué via 5 clics sur le logo (cf. MainActivity)
+<         btnDiagnostic.visibility = if (MainActivity.diagnosticUnlocked) View.VISIBLE else View.GONE
+201d156
+<             btnUpdate.isEnabled = false
+203,220c158,165
+<             UpdateChecker.check(
+<                 context = requireContext(),
+<                 onUpdateAvailable = { updateInfo ->
+<                     if (isAdded) {
+<                         btnUpdate.isEnabled = true
+<                         UpdateDialogManager.show(
+<                             requireActivity() as androidx.appcompat.app.AppCompatActivity,
+<                             updateInfo
+<                         )
+<                     }
+<                 },
+<                 onNoUpdate = {
+<                     if (isAdded) showUpToDate(btnUpdate, originalUpdateText)
+<                 },
+<                 onError = {
+<                     if (isAdded) showUpdateError(btnUpdate, originalUpdateText)
+<                 }
+<             )
+---
+>             updateClickCount++
+>             if (updateClickCount >= 5) {
+>                 updateClickCount = 0
+>                 btnDiagnostic.visibility = View.VISIBLE
+>             }
+> 
+>             btnUpdate.text = getString(R.string.btn_update_disabled)
+>             btnUpdate.postDelayed({ if (isAdded) btnUpdate.text = getString(R.string.btn_check_update) }, 2_000)
+223d167
+<         // ── Bouton Nettoyer APK ──────────────────────────────────────────────
+262d205
+<         // ── Bouton Diagnostic (caché par défaut — débloqué par 5 clics sur MAJ) ──
+267d209
+<         // ── Bouton Infos ─────────────────────────────────────────────────────
+272d213
+<         // ── Bouton Fermer ─────────────────────────────────────────────────────
+278,333d218
+<     // ── Feedback "application à jour" sur le bouton ──────────────────────────
+< 
+<     private fun showUpToDate(btn: MaterialButton, originalText: String) {
+<         val ctx = requireContext()
+<         val ecoDim    = ctx.getColor(R.color.dash_eco_dim)
+<         val eco       = ctx.getColor(R.color.dash_eco)
+<         val accentDim = ctx.getColor(R.color.dash_accent_dim)
+<         val accent    = ctx.getColor(R.color.dash_accent)
+< 
+<         // Passe le bouton en vert "à jour"
+<         btn.text = getString(R.string.update_up_to_date)
+<         btn.backgroundTintList = android.content.res.ColorStateList.valueOf(ecoDim)
+<         btn.strokeColor        = android.content.res.ColorStateList.valueOf(eco)
+<         btn.setTextColor(eco)
+<         btn.isEnabled = false
+< 
+<         // Revient à l'état normal après 3 secondes
+<         btn.postDelayed({
+<             if (isAdded) {
+<                 btn.text = originalText
+<                 btn.backgroundTintList = android.content.res.ColorStateList.valueOf(accentDim)
+<                 btn.strokeColor        = android.content.res.ColorStateList.valueOf(accent)
+<                 btn.setTextColor(accent)
+<                 btn.isEnabled = true
+<             }
+<         }, 3_000)
+<     }
+< 
+<     // ── Feedback "erreur réseau" sur le bouton ────────────────────────────────
+< 
+<     private fun showUpdateError(btn: MaterialButton, originalText: String) {
+<         val ctx = requireContext()
+<         val dangerDim = ctx.getColor(R.color.dash_danger_dim)
+<         val danger    = ctx.getColor(R.color.dash_danger)
+<         val accentDim = ctx.getColor(R.color.dash_accent_dim)
+<         val accent    = ctx.getColor(R.color.dash_accent)
+< 
+<         btn.text = getString(R.string.update_network_error)
+<         btn.backgroundTintList = android.content.res.ColorStateList.valueOf(dangerDim)
+<         btn.strokeColor        = android.content.res.ColorStateList.valueOf(danger)
+<         btn.setTextColor(danger)
+<         btn.isEnabled = false
+< 
+<         btn.postDelayed({
+<             if (isAdded) {
+<                 btn.text = originalText
+<                 btn.backgroundTintList = android.content.res.ColorStateList.valueOf(accentDim)
+<                 btn.strokeColor        = android.content.res.ColorStateList.valueOf(accent)
+<                 btn.setTextColor(accent)
+<                 btn.isEnabled = true
+<             }
+<         }, 3_000)
+<     }
+< 
+<     // ── Dialog Diagnostic ────────────────────────────────────────────────────
+< 
+341d225
+<         // ── Layout : crash banner (optionnel) + rapport matériel ──────────────
+350d233
+<         // Section crash log (si un crash a été enregistré)
+364d246
+<             // Séparateur
+375d256
+<         // Section rapport matériel
+386d266
+<         // Section AppLogger en temps réel (30 dernières lignes)
+421c301
+<             // "Copier" — copie tout sans fermer le dialog
+---
+> 
+433c313
+<             // "Effacer crash" — supprime le fichier et ferme le dialog
+---
+> 
+442d321
+<         // Génération du rapport matériel sur le thread IO
+451,452d329
+<     // ── Dialog À propos ──────────────────────────────────────────────────────
+< 
+457d333
+<         // Version de l'app
+464d339
+<         // Version firmware (lecture asynchrone)
+472,490d346
+<         // QR Code GitHub
+<         val ivQrGithub = dialogView.findViewById<ImageView>(R.id.iv_qr_code_github)
+<         generateQrBitmap(githubUrl, 400)?.let { ivQrGithub.setImageBitmap(it) }
+< 
+<         // QR Code GitLab
+<         val ivQrGitlab = dialogView.findViewById<ImageView>(R.id.iv_qr_code_gitlab)
+<         generateQrBitmap(gitlabUrl, 400)?.let { ivQrGitlab.setImageBitmap(it) }
+< 
+<         // Lien GitHub cliquable
+<         dialogView.findViewById<TextView>(R.id.tv_github_link).setOnClickListener {
+<             startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(githubUrl)))
+<         }
+< 
+<         // Lien GitLab cliquable
+<         dialogView.findViewById<TextView>(R.id.tv_gitlab_link).setOnClickListener {
+<             startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(gitlabUrl)))
+<         }
+< 
+<         // Création du dialog sans chrome Android (fond transparent = layout seul visible)
+497d352
+<         // Bouton Fermer intégré dans le layout
+505,526d359
+<     // ── Génération QR code (ZXing core) ──────────────────────────────────────
+< 
+<     private fun generateQrBitmap(content: String, sizePx: Int = 400): Bitmap? {
+<         return try {
+<             val hints = mapOf(
+<                 EncodeHintType.MARGIN to 1,
+<                 EncodeHintType.CHARACTER_SET to "UTF-8"
+<             )
+<             val matrix = MultiFormatWriter().encode(
+<                 content, BarcodeFormat.QR_CODE, sizePx, sizePx, hints
+<             )
+<             val bmp = Bitmap.createBitmap(sizePx, sizePx, Bitmap.Config.RGB_565)
+<             for (x in 0 until sizePx) {
+<                 for (y in 0 until sizePx) {
+<                     bmp.setPixel(x, y, if (matrix[x, y]) Color.BLACK else Color.WHITE)
+<                 }
+<             }
+<             bmp
+<         } catch (e: Exception) {
+<             null
+<         }
+<     }
+
+===== app/src/main/java/com/mg4/control/ui/ShortcutsFragment.kt (+43/-62) =====
+20a21
+> import com.mg4.control.hardware.MG4Hardware.Swi68Mode
+37c38
+<     /** Éléments disponibles dans les Spinners — calculés une fois selon le firmware. */
+---
+>     
+40c41
+<     /** Liste de base (sans label custom) — partagée pour tous les spinners. */
+---
+>     
+43c44
+<     /** Clés identifiant chaque ligne slot × type de pression. */
+---
+>     
+49d49
+<     // ── Par-spinner : label list mutable + adapter + vue ─────────────────
+71d70
+<         // ── Construction des items de base selon firmware ─────────────────
+78c77
+<             // SWI68/69/131/165 : une seule alerte sonore VSM
+---
+> 
+82c81
+<             // SWI133 + SWI132 : deux alertes indépendantes (survitesse + ton limite)
+---
+> 
+102,106c101,103
+<         // ── Affichage des sections de config selon firmware ───────────────
+<         // Tous les firmwares connus utilisent la config 5 modes (Off/Lim.Manuel/Lim.Auto/ACC/ICA|TJA).
+<         view.findViewById<View>(R.id.config_adas_section)?.visibility = if (isKnown) View.VISIBLE else View.GONE
+<         view.findViewById<View>(R.id.config_adas_swi133)?.visibility  = if (isKnown) View.VISIBLE else View.GONE
+<         view.findViewById<View>(R.id.config_adas_swi68)?.visibility   = View.GONE
+---
+>         view.findViewById<View>(R.id.config_adas_section)?.visibility = if (isKnown)    View.VISIBLE else View.GONE
+>         view.findViewById<View>(R.id.config_adas_swi133)?.visibility  = if (!isVsmBased && isKnown) View.VISIBLE else View.GONE
+>         view.findViewById<View>(R.id.config_adas_swi68)?.visibility   = if (isVsmBased) View.VISIBLE else View.GONE
+108d104
+<         // ── Bouton Fermer ─────────────────────────────────────────────
+114c110
+<         setupConfigListeners(view)
+---
+>         setupConfigListeners(view, isVsmBased)
+118,119d113
+<     // ── Spinners (un adapter par spinner) ────────────────────────────────
+< 
+125d118
+<             // Construire la liste de labels pour ce slot (OPEN_CUSTOM_APP peut avoir un label custom)
+135d127
+<             // Sélection initiale
+140,141d131
+<             // Listener positionné APRÈS pour ignorer le callback auto de setSelection.
+<             // Le flag `initialized` absorbe le premier onItemSelected automatique (sélection initiale).
+163,167c153
+<     /**
+<      * Construit la liste de labels pour un slot.
+<      * - OPEN_CUSTOM_APP : affiche "Ouvrir [AppName]" si une app est sauvegardée.
+<      * - APPLY_PROFILE   : affiche "▶ [NomProfil]" si un profil est sauvegardé.
+<      */
+---
+>     
+194c180
+<     /** Retourne le label de l'application (packageName) ou null si introuvable. */
+---
+>     
+204,205d189
+<     // ── Dialog de sélection d'application ────────────────────────────────
+< 
+209d192
+<         // Récupérer toutes les apps launchables, triées par label
+228c211
+<                 // Si aucune app n'était sauvegardée → revenir à NONE
+---
+> 
+238,239d220
+<     // ── Dialog de sélection de profil ────────────────────────────────────────
+< 
+244c225
+<             // Aucun profil créé → revenir à NONE
+---
+> 
+266c247
+<                 // Annulation sans profil préalablement sauvegardé → revenir à NONE
+---
+> 
+276c257
+<     /** Met à jour le label APPLY_PROFILE dans l'adapter du spinner concerné. */
+---
+>     
+290c271
+<     /** Met à jour le label OPEN_CUSTOM_APP dans l'adapter du spinner concerné. */
+---
+>     
+301c282
+<         // S'assurer que le spinner affiche le bon item sélectionné
+---
+> 
+305,307c286
+<     // ── Config buttons (1 Pédale / AEB / ADAS) ───────────────────────────
+< 
+<     private fun setupConfigListeners(view: View) {
+---
+>     private fun setupConfigListeners(view: View, isVsmBased: Boolean) {
+316d294
+<         // One Pedal — regen de retour
+325,334c303,323
+<         // ADAS — modes A et B : tous les firmwares connus utilisent les indices 0-4
+<         // (Off/Lim.Manuel/Lim.Auto/ACC/ICA|TJA). La conversion index→hardware est faite dans le service.
+<         setupConfigRow("shortcut_adas_mode_a", 0, view,
+<             R.id.sc_adas_a_0 to 0, R.id.sc_adas_a_1 to 1, R.id.sc_adas_a_2 to 2,
+<             R.id.sc_adas_a_3 to 3, R.id.sc_adas_a_4 to 4
+<         )
+<         setupConfigRow("shortcut_adas_mode_b", 3, view,
+<             R.id.sc_adas_b_0 to 0, R.id.sc_adas_b_1 to 1, R.id.sc_adas_b_2 to 2,
+<             R.id.sc_adas_b_3 to 3, R.id.sc_adas_b_4 to 4
+<         )
+---
+>         if (!isVsmBased) {
+>             setupConfigRow("shortcut_adas_mode_a", 0, view,
+>                 R.id.sc_adas_a_0 to 0, R.id.sc_adas_a_1 to 1,
+>                 R.id.sc_adas_a_3 to 3, R.id.sc_adas_a_4 to 4
+>             )
+>             setupConfigRow("shortcut_adas_mode_b", 3, view,
+>                 R.id.sc_adas_b_0 to 0, R.id.sc_adas_b_1 to 1,
+>                 R.id.sc_adas_b_3 to 3, R.id.sc_adas_b_4 to 4
+>             )
+>         } else {
+>             setupConfigRow("shortcut_adas_mode_a", Swi68Mode.ACC, view,
+>                 R.id.sc_adas_a_s68_off to Swi68Mode.OFF,
+>                 R.id.sc_adas_a_s68_acc to Swi68Mode.ACC,
+>                 R.id.sc_adas_a_s68_tja to Swi68Mode.TJA
+>             )
+>             setupConfigRow("shortcut_adas_mode_b", Swi68Mode.OFF, view,
+>                 R.id.sc_adas_b_s68_off to Swi68Mode.OFF,
+>                 R.id.sc_adas_b_s68_acc to Swi68Mode.ACC,
+>                 R.id.sc_adas_b_s68_tja to Swi68Mode.TJA
+>             )
+>         }
+355,356d343
+<     // ── Restauration de l'état ────────────────────────────────────────────
+< 
+363,364d349
+<     // ── Helpers UI ───────────────────────────────────────────────────────
+< 
+379,380d363
+<         val activeTextColor   = requireContext().getColor(R.color.text_active)
+<         val inactiveTextColor = requireContext().getColor(R.color.text_secondary)
+382,384c365,367
+<             val isActive = value == active
+<             btn?.backgroundTintList = ColorStateList.valueOf(if (isActive) accentColor else defColor)
+<             btn?.setTextColor(if (isActive) activeTextColor else inactiveTextColor)
+---
+>             btn?.backgroundTintList = ColorStateList.valueOf(
+>                 if (value == active) accentColor else defColor
+>             )
+395,396d377
+< 
+<     // ── Prefs helpers ────────────────────────────────────────────────────
+
+===== app/src/main/java/com/mg4/control/update/ApkCleanup.kt (+1/-25) =====
+3,9d2
+< import android.os.Environment
+< import android.util.Log
+< 
+< /**
+<  * Nettoie automatiquement les anciens fichiers MGControl*.apk dans le dossier Téléchargements.
+<  * Ne conserve que les [MAX_APK] plus récents.
+<  */
+12,14c5
+<     private const val TAG     = "ApkCleanup"
+<     private const val MAX_APK = 5
+< 
+---
+>     
+16,21d6
+<         val downloadsDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS)
+<         val apkFiles = downloadsDir.listFiles { f ->
+<             f.isFile && f.name.startsWith("MGControl") && f.name.endsWith(".apk")
+<         } ?: return
+< 
+<         if (apkFiles.size <= MAX_APK) return
+23,31d7
+<         val toDelete = apkFiles.sortedBy { it.lastModified() }.take(apkFiles.size - MAX_APK)
+<         toDelete.forEach { file ->
+<             if (file.delete()) {
+<                 Log.i(TAG, "Supprimé : ${file.name}")
+<             } else {
+<                 Log.w(TAG, "Échec suppression : ${file.name}")
+<             }
+<         }
+<         Log.i(TAG, "${toDelete.size} APK(s) supprimé(s) — ${MAX_APK} conservé(s)")
+
+===== app/src/main/java/com/mg4/control/update/ApkDownloader.kt (+4/-63) =====
+3,4d2
+< import kotlinx.coroutines.Dispatchers
+< import kotlinx.coroutines.withContext
+6,7d3
+< import java.net.HttpURLConnection
+< import java.net.URL
+9,13d4
+< /**
+<  * Télécharge un fichier APK depuis une URL vers un fichier local.
+<  * Gère les redirections HTTP/HTTPS (GitHub CDN).
+<  * La progression (0–100) est remontée via [onProgress] sur le thread appelant.
+<  */
+15a7,8
+>     
+>     @Suppress("UNUSED_PARAMETER")
+20,23c13
+<     ): Boolean = withContext(Dispatchers.IO) {
+<         try {
+<             // Supprimer un éventuel fichier précédent
+<             if (destFile.exists()) destFile.delete()
+---
+>     ): Boolean {
+25,74c15
+<             val conn = openConnection(url)
+<             if (conn.responseCode != 200) {
+<                 conn.disconnect()
+<                 return@withContext false
+<             }
+< 
+<             val totalBytes = conn.contentLengthLong
+<             var downloaded = 0L
+< 
+<             conn.inputStream.use { input ->
+<                 destFile.outputStream().use { output ->
+<                     val buffer = ByteArray(8_192)
+<                     var read: Int
+<                     while (input.read(buffer).also { read = it } != -1) {
+<                         output.write(buffer, 0, read)
+<                         downloaded += read
+<                         if (totalBytes > 0) {
+<                             val pct = (downloaded * 100L / totalBytes).toInt()
+<                             withContext(Dispatchers.Main) { onProgress(pct) }
+<                         }
+<                     }
+<                 }
+<             }
+< 
+<             conn.disconnect()
+<             destFile.exists() && destFile.length() > 0
+< 
+<         } catch (_: Exception) {
+<             destFile.delete()
+<             false
+<         }
+<     }
+< 
+<     /** Ouvre une connexion en suivant manuellement les redirections (GitHub → CDN). */
+<     private fun openConnection(urlStr: String, depth: Int = 0): HttpURLConnection {
+<         val conn = (URL(urlStr).openConnection() as HttpURLConnection).apply {
+<             instanceFollowRedirects = true
+<             setRequestProperty("User-Agent", "MG4Control-Android")
+<             connectTimeout = 15_000
+<             readTimeout    = 120_000
+<             connect()
+<         }
+<         // Fallback de suivi de redirect manuel (au cas où instanceFollowRedirects est ignoré)
+<         val code = conn.responseCode
+<         if ((code == 301 || code == 302 || code == 303) && depth < 5) {
+<             val location = conn.getHeaderField("Location") ?: return conn
+<             conn.disconnect()
+<             return openConnection(location, depth + 1)
+<         }
+<         return conn
+---
+>         return false
+
+===== app/src/main/java/com/mg4/control/update/ApkInstaller.kt (+3/-77) =====
+4,6d3
+< import android.content.Intent
+< import android.util.Log
+< import androidx.core.content.FileProvider
+9,22d5
+< /**
+<  * Installe un APK via deux méthodes en cascade, adaptées aux contraintes AAOS :
+<  *
+<  *   1. pm install depuis le stockage externe  (getExternalFilesDir — accessible par pm)
+<  *   2. pm install depuis le stockage interne  (cacheDir — fallback si pas de stockage externe)
+<  *
+<  * Note :
+<  *   - PackageInstaller (API silencieuse) : bloqué par AAOS ("non-system apps on internal storage")
+<  *   - ACTION_INSTALL_PACKAGE : bloqué par le sharedUserId="android.uid.system" de l'app
+<  *     (le système refuse de mettre à jour une app système via l'installeur standard)
+<  *   - Seul pm install depuis un chemin lisible par le processus pm peut fonctionner
+<  *
+<  * Retourne null si une méthode a pu être lancée, message d'erreur sinon.
+<  */
+25,28c8,9
+<     private const val TAG = "ApkInstaller"
+<     // Nom différent du fichier téléchargé pour éviter toute collision source/dest
+<     private const val PM_TMP_NAME = "mg4control_pm_tmp.apk"
+< 
+---
+>     
+>     @Suppress("UNUSED_PARAMETER")
+30,76d10
+<         if (!apkFile.exists() || apkFile.length() == 0L) {
+<             return "APK manquant ou vide : ${apkFile.absolutePath}"
+<         }
+< 
+<         // ── Stratégie 1 : pm install depuis le stockage externe ───────────────
+<         val extDir = context.getExternalFilesDir(null)
+<         if (extDir != null) {
+<             val extApk = File(extDir, PM_TMP_NAME)
+<             val error = tryPmInstall(apkFile, extApk)
+<             if (error == null) {
+<                 Log.i(TAG, "pm install (externe) : succès")
+<                 return null
+<             }
+<             Log.w(TAG, "pm install (externe) échoué : $error")
+<         }
+< 
+<         // ── Stratégie 2 : pm install depuis le stockage interne (cache) ───────
+<         val intApk = File(context.cacheDir, PM_TMP_NAME)
+<         val error = tryPmInstall(apkFile, intApk)
+<         if (error == null) {
+<             Log.i(TAG, "pm install (interne) : succès")
+<             return null
+<         }
+<         Log.w(TAG, "pm install (interne) échoué : $error")
+< 
+<         val extMsg = if (extDir != null) "ext: échec" else "ext: absent"
+<         return "$extMsg | int: $error"
+<     }
+< 
+<     // ── pm install -r ─────────────────────────────────────────────────────────
+< 
+<     private fun tryPmInstall(source: File, dest: File): String? {
+<         return try {
+<             // Copie vers la destination (nom différent → jamais la même que source)
+<             source.copyTo(dest, overwrite = true)
+< 
+<             val process = ProcessBuilder(
+<                 "/system/bin/pm", "install", "-r", "--user", "0", dest.absolutePath
+<             )
+<                 .redirectErrorStream(true)
+<                 .start()
+< 
+<             val output = process.inputStream.bufferedReader().readText().trim()
+<             val exitCode = process.waitFor()
+< 
+<             dest.runCatching { delete() }
+<             Log.d(TAG, "pm install [${dest.parent}] exitCode=$exitCode output=$output")
+78,86c12
+<             if (output.contains("Success", ignoreCase = true) || exitCode == 0) {
+<                 null
+<             } else {
+<                 "exitCode=$exitCode | $output"
+<             }
+<         } catch (e: Exception) {
+<             dest.runCatching { delete() }
+<             "${e.javaClass.simpleName}: ${e.message}"
+<         }
+---
+>         return "Mise à jour automatique désactivée (gestion locale)"
+
+===== app/src/main/java/com/mg4/control/update/InstallReceiver.kt (+0/-48) =====
+6,9d5
+< import android.content.pm.PackageInstaller
+< import android.util.Log
+< import android.widget.Toast
+< import com.mg4.control.R
+11,14d6
+< /**
+<  * Reçoit le résultat de l'installation silencieuse depuis [ApkInstaller].
+<  * Enregistré dans le Manifest ; appelé par PackageInstaller après commit().
+<  */
+19d10
+<         private const val TAG = "InstallReceiver"
+23d13
+<         if (intent.action != ACTION_INSTALL_STATUS) return
+25,62d14
+<         val status  = intent.getIntExtra(PackageInstaller.EXTRA_STATUS, PackageInstaller.STATUS_FAILURE)
+<         val message = intent.getStringExtra(PackageInstaller.EXTRA_STATUS_MESSAGE) ?: ""
+< 
+<         Log.d(TAG, "Install status=$status message=$message")
+< 
+<         when (status) {
+<             PackageInstaller.STATUS_SUCCESS -> {
+<                 Log.i(TAG, "Installation réussie !")
+<                 Toast.makeText(
+<                     context,
+<                     context.getString(R.string.update_installed),
+<                     Toast.LENGTH_LONG
+<                 ).show()
+<             }
+< 
+<             PackageInstaller.STATUS_PENDING_USER_ACTION -> {
+<                 // Ne devrait pas arriver avec INSTALL_PACKAGES système,
+<                 // mais on ouvre quand même la confirmation si nécessaire.
+<                 @Suppress("DEPRECATION")
+<                 val confirmIntent = if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.TIRAMISU)
+<                     intent.getParcelableExtra(Intent.EXTRA_INTENT, Intent::class.java)
+<                 else
+<                     intent.getParcelableExtra<Intent>(Intent.EXTRA_INTENT)
+<                 confirmIntent?.let {
+<                     it.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+<                     context.startActivity(it)
+<                 }
+<             }
+< 
+<             else -> {
+<                 Log.e(TAG, "Installation échouée — status=$status : $message")
+<                 Toast.makeText(
+<                     context,
+<                     context.getString(R.string.update_install_error, message),
+<                     Toast.LENGTH_LONG
+<                 ).show()
+<             }
+<         }
+
+===== app/src/main/java/com/mg4/control/update/UpdateChecker.kt (+3/-219) =====
+4,11d3
+< import com.mg4.control.debug.AppLogger
+< import kotlinx.coroutines.CoroutineScope
+< import kotlinx.coroutines.Dispatchers
+< import kotlinx.coroutines.launch
+< import kotlinx.coroutines.withContext
+< import org.json.JSONObject
+< import java.net.HttpURLConnection
+< import java.net.URL
+13,17d4
+< /**
+<  * Vérifie si une version plus récente est disponible.
+<  * Stratégie : GitHub en priorité, GitLab en fallback si GitHub est inaccessible
+<  * (timeout, erreur réseau, rate-limit, repo privé, etc.).
+<  */
+20,45c7
+<     private const val TAG = "MG4_UPDATE"
+< 
+<     private const val GITHUB_API_URL =
+<         "https://api.github.com/repos/SliDeeN/MG4Control/releases/latest"
+< 
+<     private const val GITLAB_API_URL =
+<         "https://gitlab.com/api/v4/projects/SliDeeN%2Fmg4control/releases/permalink/latest"
+< 
+<     private const val PREFS_SKIP       = "mg4_update_skip"
+<     private const val KEY_SKIP_VERSION = "skip_version"
+< 
+<     // -------------------------------------------------------------------------
+<     // Données brutes extraites depuis GitHub ou GitLab
+<     // -------------------------------------------------------------------------
+< 
+<     private data class RawRelease(
+<         val tagName: String,
+<         val apkUrl: String,
+<         val releaseNotes: String,
+<         val source: String          // "GitHub" ou "GitLab" — pour les logs
+<     )
+< 
+<     // -------------------------------------------------------------------------
+<     // Point d'entrée public
+<     // -------------------------------------------------------------------------
+< 
+---
+>     
+52,60d13
+<         CoroutineScope(Dispatchers.IO).launch {
+<             try {
+<                 val currentVersion = context.packageManager
+<                     .getPackageInfo(context.packageName, 0).versionName
+<                     ?: return@launch
+< 
+<                 val skippedVersion = context
+<                     .getSharedPreferences(PREFS_SKIP, Context.MODE_PRIVATE)
+<                     .getString(KEY_SKIP_VERSION, null)
+62,95c15
+<                 // Essai GitHub → fallback GitLab
+<                 val release = fetchFromGitHub()
+<                     ?: fetchFromGitLab()
+<                     ?: run {
+<                         AppLogger.w(TAG, "GitHub et GitLab inaccessibles")
+<                         withContext(Dispatchers.Main) { onError?.invoke() }
+<                         return@launch
+<                     }
+< 
+<                 AppLogger.i(TAG, "Release récupérée depuis ${release.source} : ${release.tagName}")
+< 
+<                 val versionName = release.tagName.trimStart('v')
+< 
+<                 if (isNewer(versionName, currentVersion)) {
+<                     if (versionName == skippedVersion) {
+<                         AppLogger.i(TAG, "Mise à jour $versionName ignorée (utilisateur)")
+<                         withContext(Dispatchers.Main) { onNoUpdate?.invoke() }
+<                         return@launch
+<                     }
+<                     val skippedCount = versionHops(currentVersion, versionName)
+<                     val info = UpdateInfo(
+<                         versionName, release.tagName, release.apkUrl,
+<                         release.releaseNotes, skippedCount
+<                     )
+<                     withContext(Dispatchers.Main) { onUpdateAvailable(info) }
+<                 } else {
+<                     AppLogger.i(TAG, "Version actuelle ($currentVersion) à jour — pas de mise à jour")
+<                     withContext(Dispatchers.Main) { onNoUpdate?.invoke() }
+<                 }
+< 
+<             } catch (_: Exception) {
+<                 withContext(Dispatchers.Main) { onError?.invoke() }
+<             }
+<         }
+---
+>         onNoUpdate?.invoke()
+98,198c18
+<     // -------------------------------------------------------------------------
+<     // Requête GitHub
+<     // -------------------------------------------------------------------------
+< 
+<     private fun fetchFromGitHub(): RawRelease? {
+<         return try {
+<             val conn = (URL(GITHUB_API_URL).openConnection() as HttpURLConnection).apply {
+<                 setRequestProperty("Accept", "application/vnd.github.v3+json")
+<                 setRequestProperty("User-Agent", "MG4Control-Android")
+<                 connectTimeout = 10_000
+<                 readTimeout    = 10_000
+<             }
+<             if (conn.responseCode != 200) {
+<                 AppLogger.w(TAG, "GitHub réponse ${conn.responseCode} → fallback GitLab")
+<                 conn.disconnect()
+<                 return null
+<             }
+<             val json = JSONObject(conn.inputStream.bufferedReader().readText())
+<             conn.disconnect()
+< 
+<             val tagName = json.getString("tag_name")
+<             val notes   = json.optString("body", "").take(400)
+<             val assets  = json.optJSONArray("assets") ?: return null
+<             var apkUrl  = ""
+<             for (i in 0 until assets.length()) {
+<                 val asset = assets.getJSONObject(i)
+<                 if (asset.getString("name").endsWith(".apk")) {
+<                     apkUrl = asset.getString("browser_download_url")
+<                     break
+<                 }
+<             }
+<             if (apkUrl.isEmpty()) {
+<                 AppLogger.w(TAG, "GitHub : aucun asset .apk trouvé → fallback GitLab")
+<                 return null
+<             }
+<             RawRelease(tagName, apkUrl, notes, "GitHub")
+< 
+<         } catch (e: Exception) {
+<             AppLogger.w(TAG, "GitHub inaccessible : ${e.message} → fallback GitLab")
+<             null
+<         }
+<     }
+< 
+<     // -------------------------------------------------------------------------
+<     // Requête GitLab (fallback)
+<     // -------------------------------------------------------------------------
+< 
+<     private fun fetchFromGitLab(): RawRelease? {
+<         return try {
+<             val conn = (URL(GITLAB_API_URL).openConnection() as HttpURLConnection).apply {
+<                 setRequestProperty("User-Agent", "MG4Control-Android")
+<                 connectTimeout = 10_000
+<                 readTimeout    = 10_000
+<             }
+<             if (conn.responseCode != 200) {
+<                 AppLogger.w(TAG, "GitLab réponse ${conn.responseCode}")
+<                 conn.disconnect()
+<                 return null
+<             }
+<             val json = JSONObject(conn.inputStream.bufferedReader().readText())
+<             conn.disconnect()
+< 
+<             val tagName = json.getString("tag_name")
+<             val notes   = json.optString("description", "").take(400)
+< 
+<             // Structure GitLab : assets.links[] (contrairement à assets[] sur GitHub)
+<             // Le champ "name" est un libellé libre (ex: "MG4Control v1.2.0") — pas forcément
+<             // le nom de fichier. On vérifie donc aussi l'URL elle-même en fallback.
+<             val links  = json.optJSONObject("assets")?.optJSONArray("links") ?: return null
+<             var apkUrl = ""
+<             for (i in 0 until links.length()) {
+<                 val link      = links.getJSONObject(i)
+<                 val linkName  = link.optString("name")
+<                 val linkUrl   = link.optString("direct_asset_url").ifEmpty {
+<                     link.optString("url")
+<                 }
+<                 if (linkName.endsWith(".apk", ignoreCase = true)
+<                     || linkUrl.contains(".apk", ignoreCase = true)) {
+<                     apkUrl = linkUrl
+<                     break
+<                 }
+<             }
+<             if (apkUrl.isEmpty()) {
+<                 AppLogger.w(TAG, "GitLab : aucun asset .apk trouvé dans les links")
+<                 return null
+<             }
+<             RawRelease(tagName, apkUrl, notes, "GitLab")
+< 
+<         } catch (e: Exception) {
+<             AppLogger.w(TAG, "GitLab inaccessible : ${e.message}")
+<             null
+<         }
+<     }
+< 
+<     // -------------------------------------------------------------------------
+<     // Helpers
+<     // -------------------------------------------------------------------------
+< 
+<     /**
+<      * Sauvegarde la version [version] comme "à ne plus rappeler".
+<      */
+---
+>     
+200,230d19
+<         context.getSharedPreferences(PREFS_SKIP, Context.MODE_PRIVATE)
+<             .edit()
+<             .putString(KEY_SKIP_VERSION, version)
+<             .apply()
+<     }
+< 
+<     /**
+<      * Retourne true si [remote] est une version supérieure à [current].
+<      * Comparaison sémantique segment par segment (ex: "2.1.3" > "2.1.2").
+<      */
+<     private fun isNewer(remote: String, current: String): Boolean {
+<         fun segments(v: String) =
+<             v.trimStart('v').split(".").mapNotNull { it.toIntOrNull() }
+< 
+<         val r = segments(remote)
+<         val c = segments(current)
+<         for (i in 0 until maxOf(r.size, c.size)) {
+<             val rv = r.getOrElse(i) { 0 }
+<             val cv = c.getOrElse(i) { 0 }
+<             if (rv > cv) return true
+<             if (rv < cv) return false
+<         }
+<         return false
+<     }
+< 
+<     /**
+<      * Estime le nombre de versions intermédiaires entre [from] et [to].
+<      */
+<     private fun versionHops(from: String, to: String): Int {
+<         fun segments(v: String) =
+<             v.trimStart('v').split(".").mapNotNull { it.toIntOrNull() }
+232,236d20
+<         val f = segments(from)
+<         val t = segments(to)
+<         return (0 until maxOf(f.size, t.size)).sumOf { i ->
+<             maxOf(0, t.getOrElse(i) { 0 } - f.getOrElse(i) { 0 })
+<         }
+
+===== app/src/main/java/com/mg4/control/update/UpdateDialogManager.kt (+2/-263) =====
+3,19d2
+< import android.app.AlertDialog
+< import android.app.DownloadManager
+< import android.content.Context
+< import android.content.Intent
+< import android.graphics.Bitmap
+< import android.graphics.Color
+< import android.graphics.Paint
+< import android.net.ConnectivityManager
+< import android.net.NetworkCapabilities
+< import android.net.Uri
+< import android.os.Environment
+< import android.util.Log
+< import android.view.LayoutInflater
+< import android.view.View
+< import android.widget.ImageView
+< import android.widget.ProgressBar
+< import android.widget.TextView
+21,27d3
+< import androidx.lifecycle.lifecycleScope
+< import com.google.android.material.button.MaterialButton
+< import com.google.zxing.BarcodeFormat
+< import com.google.zxing.MultiFormatWriter
+< import com.mg4.control.R
+< import kotlinx.coroutines.delay
+< import kotlinx.coroutines.launch
+29,35d4
+< /**
+<  * Gère l'affichage du dialog de mise à jour.
+<  * 3 phases distinctes :
+<  *   1. Info      : versions + boutons Télécharger / Manuel / Plus tard
+<  *   2. Progress  : téléchargement via DownloadManager (dossier Téléchargements public)
+<  *   3. Manuel    : instructions GitHub/QR code
+<  */
+38,41c7,8
+<     private const val TAG = "UpdateDialogManager"
+<     private const val GITHUB_RELEASES_URL =
+<         "https://github.com/SliDeeN/MG4Control/releases/latest"
+< 
+---
+>     
+>     @Suppress("UNUSED_PARAMETER")
+43,207d9
+<         val view = LayoutInflater.from(activity).inflate(R.layout.dialog_update, null)
+< 
+<         val dialog = AlertDialog.Builder(activity)
+<             .setView(view)
+<             .setCancelable(false)
+<             .create()
+< 
+<         // ── Références vues ──────────────────────────────────────────────────
+<         val groupInfo     = view.findViewById<View>(R.id.group_info)
+<         val groupProgress = view.findViewById<View>(R.id.group_progress)
+<         val groupManual   = view.findViewById<View>(R.id.group_manual)
+< 
+<         // Phase 1 — Info
+<         val tvFrom       = view.findViewById<TextView>(R.id.tv_version_from)
+<         val tvTo         = view.findViewById<TextView>(R.id.tv_version_to)
+<         val tvNotes      = view.findViewById<TextView>(R.id.tv_release_notes)
+<         val tvSkipHint   = view.findViewById<TextView>(R.id.tv_skip_hint)
+<         val rowDataWarn  = view.findViewById<View>(R.id.row_data_warning)
+<         val btnAuto      = view.findViewById<MaterialButton>(R.id.btn_update_auto)
+<         val btnManual    = view.findViewById<MaterialButton>(R.id.btn_update_manual)
+<         val btnLater     = view.findViewById<MaterialButton>(R.id.btn_update_later)
+<         val btnSkip      = view.findViewById<MaterialButton>(R.id.btn_update_skip)
+< 
+<         // Phase 2 — Progress
+<         val tvStatus     = view.findViewById<TextView>(R.id.tv_progress_status)
+<         val progressBar  = view.findViewById<ProgressBar>(R.id.progress_bar)
+<         val btnCancel    = view.findViewById<MaterialButton>(R.id.btn_cancel_download)
+< 
+<         // Phase 3 — Manuel
+<         val ivQr         = view.findViewById<ImageView>(R.id.iv_update_qr)
+<         val tvGhLink     = view.findViewById<TextView>(R.id.tv_update_gh_link)
+<         val tvApkPath    = view.findViewById<TextView>(R.id.tv_apk_path)
+<         val tvManualInst = view.findViewById<TextView>(R.id.tv_manual_instructions)
+<         val btnClose     = view.findViewById<MaterialButton>(R.id.btn_close_manual)
+< 
+<         // ── Remplissage initial ──────────────────────────────────────────────
+<         val currentVersion = try {
+<             activity.packageManager.getPackageInfo(activity.packageName, 0).versionName ?: "?"
+<         } catch (_: Exception) { "?" }
+< 
+<         tvFrom.text  = "v$currentVersion"
+<         tvTo.text    = "v${info.versionName}"
+<         tvNotes.text = info.releaseNotes.ifBlank { "—" }
+< 
+<         val onWifi = isOnWifi(activity)
+<         rowDataWarn.visibility = if (onWifi) View.GONE else View.VISIBLE
+< 
+<         // ── Hint : N mises à jour non installées ─────────────────────────────
+<         if (info.skippedCount > 0) {
+<             tvSkipHint.text = activity.resources.getQuantityString(
+<                 R.plurals.update_skipped_hint, info.skippedCount, info.skippedCount)
+<             tvSkipHint.visibility = View.VISIBLE
+<         }
+< 
+<         // ── Bouton NE PLUS ME RAPPELER ───────────────────────────────────────
+<         btnSkip.setOnClickListener {
+<             UpdateChecker.skipVersion(activity, info.versionName)
+<             dialog.dismiss()
+<         }
+< 
+<         // ── Bouton PLUS TARD ─────────────────────────────────────────────────
+<         btnLater.setOnClickListener { dialog.dismiss() }
+< 
+<         // ── Panneau Manuel ───────────────────────────────────────────────────
+<         tvGhLink.setOnClickListener {
+<             runCatching {
+<                 activity.startActivity(
+<                     Intent(Intent.ACTION_VIEW, Uri.parse(GITHUB_RELEASES_URL))
+<                 )
+<             }
+<         }
+<         btnClose.setOnClickListener { dialog.dismiss() }
+< 
+<         generateQrBitmap(GITHUB_RELEASES_URL, 152)?.let { ivQr.setImageBitmap(it) }
+<         tvGhLink.text = GITHUB_RELEASES_URL
+<         tvGhLink.paintFlags = tvGhLink.paintFlags or Paint.UNDERLINE_TEXT_FLAG
+< 
+<         fun showManualPanel(inDownloads: Boolean = false) {
+<             if (inDownloads) {
+<                 tvManualInst.text = activity.getString(R.string.update_downloaded_instructions)
+<                 tvApkPath.visibility = View.GONE
+<             }
+<             switchTo(groupInfo, groupProgress, groupManual, showGroup = groupManual)
+<         }
+< 
+<         // ── Bouton INSTALLATION MANUELLE ─────────────────────────────────────
+<         btnManual.setOnClickListener { showManualPanel() }
+< 
+<         // ── Bouton TÉLÉCHARGER L'APK ──────────────────────────────────────────
+<         btnAuto.setOnClickListener {
+<             if (!onWifi) {
+<                 AlertDialog.Builder(activity)
+<                     .setTitle(R.string.update_data_warn_title)
+<                     .setMessage(R.string.update_data_warn_message)
+<                     .setPositiveButton(R.string.update_continue) { _, _ ->
+<                         switchTo(groupInfo, groupProgress, groupManual, showGroup = groupProgress)
+<                         launchDownload(activity, info, dialog, tvStatus, progressBar, btnCancel) {
+<                             showManualPanel(inDownloads = true)
+<                         }
+<                     }
+<                     .setNegativeButton(R.string.update_cancel, null)
+<                     .show()
+<             } else {
+<                 switchTo(groupInfo, groupProgress, groupManual, showGroup = groupProgress)
+<                 launchDownload(activity, info, dialog, tvStatus, progressBar, btnCancel) {
+<                     showManualPanel(inDownloads = true)
+<                 }
+<             }
+<         }
+< 
+<         dialog.show()
+<     }
+< 
+<     // ── Téléchargement via DownloadManager → dossier Téléchargements public ───
+< 
+<     private fun launchDownload(
+<         activity: AppCompatActivity,
+<         info: UpdateInfo,
+<         dialog: AlertDialog,
+<         tvStatus: TextView,
+<         progressBar: ProgressBar,
+<         btnCancel: MaterialButton,
+<         onDownloaded: () -> Unit
+<     ) {
+<         val dm = activity.getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager
+<         // On conserve le nom d'origine du fichier tel qu'il est sur GitHub
+<         val fileName = info.apkUrl
+<             .substringAfterLast('/')
+<             .substringBefore('?')
+<             .ifBlank { "MGControl${info.versionName}.apk" }
+< 
+<         val request = DownloadManager.Request(Uri.parse(info.apkUrl)).apply {
+<             setTitle("MG4Control ${info.versionName}")
+<             setDescription(activity.getString(R.string.update_downloading))
+<             setNotificationVisibility(
+<                 DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED
+<             )
+<             setDestinationInExternalPublicDir(Environment.DIRECTORY_DOWNLOADS, fileName)
+<             setMimeType("application/vnd.android.package-archive")
+<         }
+< 
+<         val downloadId = dm.enqueue(request)
+<         Log.i(TAG, "DownloadManager enqueued id=$downloadId → $fileName")
+< 
+<         btnCancel.setOnClickListener {
+<             dm.remove(downloadId)
+<             dialog.dismiss()
+<         }
+< 
+<         tvStatus.setText(R.string.update_downloading)
+<         progressBar.isIndeterminate = false
+<         progressBar.progress = 0
+< 
+<         activity.lifecycleScope.launch {
+<             while (true) {
+<                 val cursor = dm.query(DownloadManager.Query().setFilterById(downloadId))
+<                 if (!cursor.moveToFirst()) { cursor.close(); break }
+< 
+<                 val status = cursor.getInt(
+<                     cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_STATUS))
+<                 val downloaded = cursor.getLong(
+<                     cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR))
+<                 val total = cursor.getLong(
+<                     cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_TOTAL_SIZE_BYTES))
+<                 cursor.close()
+209,235d10
+<                 when (status) {
+<                     DownloadManager.STATUS_SUCCESSFUL -> {
+<                         progressBar.progress = 100
+<                         // Nettoie les anciens APK dans Téléchargements (garde les 5 plus récents)
+<                         ApkCleanup.cleanIfNeeded()
+<                         // Ouvre le dossier Téléchargements dans le gestionnaire AAOS
+<                         openDownloadsFolder(activity)
+<                         onDownloaded()
+<                         break
+<                     }
+<                     DownloadManager.STATUS_FAILED -> {
+<                         tvStatus.setText(R.string.update_error_download)
+<                         btnCancel.setText(R.string.update_close)
+<                         break
+<                     }
+<                     else -> {
+<                         if (total > 0) {
+<                             val pct = (downloaded * 100 / total).toInt()
+<                             progressBar.progress = pct
+<                             tvStatus.text = activity.getString(
+<                                 R.string.update_downloading_pct, pct)
+<                         }
+<                     }
+<                 }
+<                 delay(500)
+<             }
+<         }
+237,272d11
+< 
+<     // ── Ouvre le dossier Téléchargements dans le gestionnaire AAOS ───────────
+< 
+<     private fun openDownloadsFolder(context: Context) {
+<         try {
+<             val intent = Intent(DownloadManager.ACTION_VIEW_DOWNLOADS).apply {
+<                 addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+<             }
+<             context.startActivity(intent)
+<             Log.i(TAG, "Dossier Téléchargements ouvert")
+<         } catch (e: Exception) {
+<             Log.w(TAG, "Impossible d'ouvrir Téléchargements : ${e.message}")
+<         }
+<     }
+< 
+<     // ── Utilitaires ──────────────────────────────────────────────────────────
+< 
+<     private fun switchTo(vararg allGroups: View, showGroup: View) {
+<         allGroups.forEach { it.visibility = View.GONE }
+<         showGroup.visibility = View.VISIBLE
+<     }
+< 
+<     private fun isOnWifi(context: Context): Boolean {
+<         val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+<         val caps = cm.getNetworkCapabilities(cm.activeNetwork) ?: return false
+<         return caps.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
+<     }
+< 
+<     private fun generateQrBitmap(url: String, sizePx: Int): Bitmap? = runCatching {
+<         val bitMatrix = MultiFormatWriter().encode(url, BarcodeFormat.QR_CODE, sizePx, sizePx)
+<         val bmp = Bitmap.createBitmap(sizePx, sizePx, Bitmap.Config.RGB_565)
+<         for (x in 0 until sizePx) for (y in 0 until sizePx) {
+<             bmp.setPixel(x, y, if (bitMatrix[x, y]) Color.BLACK else Color.WHITE)
+<         }
+<         bmp
+<     }.getOrNull()
+
+===== app/src/main/java/com/mg4/control/update/UpdateInfo.kt (+5/-8) =====
+3,5d2
+< /**
+<  * Informations sur une release GitHub disponible.
+<  */
+7c4
+<     /** "2.1"   — version parsée depuis le tag GitHub */
+---
+>     
+9c6
+<     /** "v2.1"  — tag brut de la release */
+---
+>     
+11c8
+<     /** URL de téléchargement directe du fichier .apk */
+---
+>     
+13c10
+<     /** Corps de la release note (tronqué à 400 caractères) */
+---
+>     
+15c12
+<     /** Nombre de versions ignorées depuis la version actuellement installée */
+---
+>     
+
+===== app/src/main/java/com/mg4/control/util/FirmwareHelper.kt (+0/-4) =====
+6,9d5
+< /**
+<  * Lit la version firmware du système d'infodivertissement.
+<  * Propriété système : ro.build.mt2712.version → "SWI133-29176-1300R32"
+<  */
+
+===== app/src/main/java/com/mg4/control/util/FirmwareInfo.kt (+11/-54) =====
+5,17d4
+< /**
+<  * Détecte la génération de firmware à partir de ro.build.mt2712.version.
+<  *
+<  * SWI133 : "SWI133-xxxxx" — ADAS via getMixProperty(0x32), 5 modes, 2 alertes, sièges+volant chauffants
+<  * SWI132 : "SWI132-xxxxx" — ADAS via CarVehicleSettingClient (acc/tja getAccTjaState), alertes via binder
+<  *                            direct IVehicleSettingService (TX 0x128/0x12a), même section UI que SWI68
+<  * SWI68  : "SWI68-xxxxx"  — ADAS via VehicleSettingManager (acc/tja), sièges+volant chauffants
+<  * SWI69  : "SWI69-xxxxx"  — ADAS via VehicleSettingManager "nouvelle gen", sans sièges/volant chauffants
+<  * SWI131 : "SWI131-xxxxx" — Identique SWI69 (même package, même API), sans sièges/volant chauffants
+<  * SWI165 : "SWI165-xxxxx" — ADAS via VehicleSettingManager (même SDK que SWI68), AEB via setFcwAlarmMode
+<  *                            sièges+volant chauffants disponibles
+<  * UNKNOWN : firmware non reconnu — l'utilisateur peut forcer un mode de compatibilité
+<  */
+28,31c15
+<     /**
+<      * À appeler en premier dans MainActivity.onCreate(), avant toute inflation de fragment.
+<      * Lit le choix forcé éventuel depuis les SharedPreferences et l'applique au cache.
+<      */
+---
+>     
+38c22
+<     /** Retourne la génération active (forcée ou détectée automatiquement). */
+---
+>     
+48c32
+<             version.startsWith("SWI132")  -> Gen.SWI132   // avant SWI131 — startsWith("SWI13") serait ambigu
+---
+>             version.startsWith("SWI132")  -> Gen.SWI132
+58,61c42
+<     /**
+<      * Chaîne brute lue depuis les propriétés système (ex: "SWI131-12345-xxx").
+<      * Utile pour afficher la version exacte à l'utilisateur dans le dialog de warning.
+<      */
+---
+>     
+67,70c48
+<     /**
+<      * Force le mode de compatibilité manuellement.
+<      * Le choix est persisté dans les SharedPreferences et survit aux redémarrages.
+<      */
+---
+>     
+77,80c55
+<     /**
+<      * Retourne true si le mode de compatibilité a été forcé manuellement
+<      * (par opposition à une détection automatique réussie).
+<      */
+---
+>     
+85,92c60
+<     // ── Helpers de capacités ─────────────────────────────────────────────────
+< 
+<     /**
+<      * SWI69 et SWI131 utilisent la même API "nouvelle génération" VSM :
+<      *   package com.saicmotor.vehiclesetting.service
+<      *   constructeur IBinder-direct
+<      *   méthodes : setAccTjaState, setFcwState, setLasWarningSound…
+<      */
+---
+>     
+98,102c66
+<     /**
+<      * SWI68, SWI69, SWI131 et SWI165 utilisent tous le VehicleSettingManager SAIC
+<      * pour l'ADAS (ACC/TJA) et les alertes sonores.
+<      * SWI133 utilise VehiclePropertyManager (getMixProperty).
+<      */
+---
+>     
+108,111c72
+<     /**
+<      * SWI133, SWI68 et SWI165 ont les sièges chauffants et le volant chauffant.
+<      * SWI69 et SWI131 sont des finitions Standard/SE sans ces équipements.
+<      */
+---
+>     
+114c75
+<         return gen == Gen.SWI133 || gen == Gen.SWI68 || gen == Gen.SWI165
+---
+>         return gen == Gen.SWI133 || gen == Gen.SWI68 || gen == Gen.SWI165 || gen == Gen.SWI69
+117,121c78
+<     /**
+<      * SWI165 utilise le même SDK VehicleSettingManager que SWI68.
+<      * L'AEB est contrôlé par setFcwAlarmMode() (même API que SWI68).
+<      * setAutoEmergencyBraking() existe dans le SDK mais n'est pas utilisé par l'app officielle.
+<      */
+---
+>     
+
+===== app/src/main/java/com/mg4/control/util/LocaleHelper.kt (+4/-4) =====
+13c13
+<     /** Retourne "fr" ou "en" (défaut : "fr"). */
+---
+>     
+18c18
+<     /** Sauvegarde le choix et marque le premier lancement comme fait. */
+---
+>     
+26c26
+<     /** True si l'utilisateur n'a pas encore choisi de langue. */
+---
+>     
+31c31
+<     /** Applique la locale sauvegardée au contexte fourni et retourne le contexte modifié. */
+---
+>     
+
+===== app/src/main/java/com/mg4/control/util/ThemeHelper.kt (+6/-51) =====
+7,28d6
+< /**
+<  * Gestion du thème de l'application (sombre / clair / auto-sync launcher).
+<  *
+<  * Le mode "auto" est disponible sur TOUS les firmwares, mais fonctionne différemment :
+<  *
+<  * ─ SWI69 / SWI131 / SWI132 ──────────────────────────────────────────────────────
+<  *   Clé Settings.System : "SKIN_THEME_CONFIG"  (0 = sombre, 1 = clair)
+<  *   Broadcast launcher  : "com.saicmotor.changeSkin" (sans extra → relire Settings.System)
+<  *   → On lit la valeur explicitement et on passe MODE_NIGHT_YES/NO + recreate().
+<  *
+<  * ─ SWI133 / SWI68 ───────────────────────────────────────────────────────────────
+<  *   Le launcher appelle UiModeManager.setNightMode() qui change le uiMode Android
+<  *   global (0x13 = clair, 0x23 = sombre). Le SkinManager SWI133 lit isNightMode()
+<  *   depuis Configuration.uiMode.
+<  *   → On utilise MODE_NIGHT_FOLLOW_SYSTEM : AppCompat suit automatiquement le
+<  *     uiMode système et recrée l'activité lorsqu'il change.
+<  *
+<  * Préférence stockée : "theme_mode" dans "mg4_settings"
+<  *   "auto"  → sync avec le launcher MG (mécanisme adapté au firmware)
+<  *   "dark"  → toujours sombre
+<  *   "light" → toujours clair
+<  */
+36,40c14
+<     /**
+<      * Callback invoqué (sur le thread principal) lorsque le launcher change de thème
+<      * sur SWI69/131/132. MainActivity l'utilise pour déclencher recreate().
+<      * Sur SWI133/68, AppCompat appelle recreate() automatiquement via FOLLOW_SYSTEM.
+<      */
+---
+>     
+43,48c17
+<     // ── Détection du mécanisme ───────────────────────────────────────────────
+< 
+<     /**
+<      * Retourne true si ce firmware expose SKIN_THEME_CONFIG dans Settings.System
+<      * (SWI69 / SWI131 / SWI132). Sur SWI68/133, utilise FOLLOW_SYSTEM à la place.
+<      */
+---
+>     
+57,62c26
+<     // ── Lecture du thème launcher (SWI69/131/132 uniquement) ─────────────────
+< 
+<     /**
+<      * Lit SKIN_THEME_CONFIG et retourne MODE_NIGHT_YES ou MODE_NIGHT_NO.
+<      * À n'appeler que si hasSkinThemeConfig() == true.
+<      */
+---
+>     
+72,79c36
+<     // ── Résolution du mode à appliquer ───────────────────────────────────────
+< 
+<     /**
+<      * Retourne le night mode AppCompat à appliquer selon la préférence "theme_mode".
+<      *
+<      * "auto" sur SWI69/131/132 → YES ou NO selon SKIN_THEME_CONFIG
+<      * "auto" sur SWI133/68    → MODE_NIGHT_FOLLOW_SYSTEM (suit le uiMode Android)
+<      */
+---
+>     
+86c43
+<             else    -> AppCompatDelegate.MODE_NIGHT_YES   // "dark" + fallback
+---
+>             else    -> AppCompatDelegate.MODE_NIGHT_YES
+90,92c47
+<     // ── Notification de changement (SWI69/131/132) ───────────────────────────
+< 
+<     /** Appelé depuis le service (déjà sur le main thread) pour déclencher recreate(). */
+---
+>     
+
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index de01039..fe90e38 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -1,11 +1,10 @@
 plugins {
     alias(libs.plugins.android.application)
-    alias(libs.plugins.kotlin.android)
 }
 
 android {
     namespace = "com.mg4.control"
-    compileSdk = 34
+    compileSdk = 36
 
     defaultConfig {
         applicationId = "com.mg4.control"
@@ -63,9 +62,7 @@ android {
         targetCompatibility = JavaVersion.VERSION_17
     }
 
-    kotlinOptions {
-        jvmTarget = "17"
-    }
+
 
     buildFeatures {
         viewBinding = true
@@ -84,14 +81,13 @@ android {
         }
     }
 
-    applicationVariants.all {
-        val variant = this
-        outputs.all {
-            val output = this as com.android.build.gradle.internal.api.BaseVariantOutputImpl
-            if (variant.buildType.name == "release") {
-                output.outputFileName = "MG4Control-${variant.flavorName}-${variant.versionName}.apk"
-            }
-        }
+    // AGP 9 removed the legacy applicationVariants output API. Release APK naming is
+    // handled by the release workflow (renames app-<flavor>-release.apk on collect).
+}
+
+kotlin {
+    compilerOptions {
+        jvmTarget.set(org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17)
     }
 }
 
diff --git a/build.gradle.kts b/build.gradle.kts
index 7629126..cf2c1fb 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,4 +1,4 @@
 plugins {
+    // AGP 9 provides built-in Kotlin; no separate Kotlin plugin.
     alias(libs.plugins.android.application) apply false
-    alias(libs.plugins.kotlin.android) apply false
 }
diff --git a/gradle.properties b/gradle.properties
index f55b0ed..ea76c66 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,3 +1,2 @@
 android.useAndroidX=true
-android.enableJetifier=true
 org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index c387ecc..7f2a7ce 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -1,5 +1,5 @@
 [versions]
-agp = "8.5.2"
+agp = "9.1.1"
 kotlin = "2.0.21"
 coreKtx = "1.13.1"
 appcompat = "1.7.0"
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 2a84e18..37f78a6 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.0.0-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.3.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
diff --git a/mise.toml b/mise.toml
index a3d6ced..b6848d4 100644
--- a/mise.toml
+++ b/mise.toml
@@ -47,7 +47,8 @@ BUILD_TOOLS = "34.0.0"
 #                    Pour l'UI, les layouts et la densité.
 #
 # Rien de tout cela ne remplace un essai sur le véhicule.
-# 12,8" HD : 1920x1080 ≈ 172 dpi réels, arrondi au bucket 160 (mdpi).
+# Densité CONFIRMÉE depuis la ROM (vendor/build.prop : ro.sf.lcd_density=160).
+# Écran 12,8" 1920x1080. Firmware de référence : SWI68-29958-1300R69.
 
 EMU_CAR_AVD = "mg4control-car"
 EMU_CAR_IMAGE = "system-images;android-33;android-automotive;x86_64"

From 11216933004ffb9036f0835953edf72ec679a09c Mon Sep 17 00:00:00 2001
From: Malys <malys.training@gmail.com>
Date: Thu, 23 Jul 2026 15:46:38 +0200
Subject: [PATCH 07/13] chore: bump MG4Hardware submodule (minSdk 27)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 MG4Hardware | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/MG4Hardware b/MG4Hardware
index 650c571..903313c 160000
--- a/MG4Hardware
+++ b/MG4Hardware
@@ -1 +1 @@
-Subproject commit 650c57106933184ce51b9a5e329a88b3433f21e6
+Subproject commit 903313c1dc7beeea9bdb081ea4d215832c84fa5a

From f2eda20b7c101f637a2b4d725410b9326db19f8a Mon Sep 17 00:00:00 2001
From: Malys <malys.training@gmail.com>
Date: Thu, 23 Jul 2026 15:49:45 +0200
Subject: [PATCH 08/13] chore: bump MG4Hardware submodule (AAR publishing +
 suite docs)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 MG4Hardware | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/MG4Hardware b/MG4Hardware
index 903313c..8a20f6a 160000
--- a/MG4Hardware
+++ b/MG4Hardware
@@ -1 +1 @@
-Subproject commit 903313c1dc7beeea9bdb081ea4d215832c84fa5a
+Subproject commit 8a20f6a4352c796480fe5a6e00fc882eaa723176

From abf3a5551d6ed83b0d7aa11e4dc6efa0e6ee0470 Mon Sep 17 00:00:00 2001
From: Malys <malys.training@gmail.com>
Date: Thu, 23 Jul 2026 16:10:10 +0200
Subject: [PATCH 09/13] security: harden manifest + scope SAST to source
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- allowBackup=false / fullBackupContent=false and taskAffinity="" on the
  launcher activity (StrandHogg / android_task_hijacking2, allow-backup).
- SAST (mobsfscan/semgrep) now scans source only, not build/ artifacts or
  the vendored submodule — removes stale build-manifest and duplicate
  submodule findings from code scanning.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .github/workflows/security.yml   | 2 +-
 app/src/main/AndroidManifest.xml | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/security.yml b/.github/workflows/security.yml
index 2d84da6..c81f272 100644
--- a/.github/workflows/security.yml
+++ b/.github/workflows/security.yml
@@ -50,7 +50,7 @@ jobs:
             printf '%s' '{"version":"2.1.0","$schema":"https://json.schemastore.org/sarif-2.1.0.json","runs":[{"tool":{"driver":{"name":"'"$1"'","rules":[]}},"results":[]}]}' > "$2"
           }
           pip install mobsfscan semgrep
-          mobsfscan --sarif -o mobsfscan.sarif . || true
+          mobsfscan --sarif -o mobsfscan.sarif app/src || true
           [ -s mobsfscan.sarif ] || empty_sarif mobsfscan mobsfscan.sarif
           semgrep --config p/kotlin --config p/security-audit --sarif -o semgrep.sarif . || true
           [ -s semgrep.sarif ] || empty_sarif semgrep semgrep.sarif
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index a63cd47..b762edc 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -47,6 +47,8 @@
         android:icon="@mipmap/ic_launcher"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:theme="@style/Theme.MG4Control"
+        android:allowBackup="false"
+        android:fullBackupContent="false"
         android:supportsRtl="true">
 
         <!-- API Car AOSP (CarDoorLockManager pour la détection d'ouverture de porte) -->
@@ -55,6 +57,7 @@
         <activity
             android:name=".MainActivity"
             android:exported="true"
+            android:taskAffinity=""
             android:screenOrientation="landscape"
             android:windowSoftInputMode="adjustPan">
             <intent-filter>

From 023c8a35394d6b3c7225eae690795251cf093ecb Mon Sep 17 00:00:00 2001
From: Malys <malys.training@gmail.com>
Date: Thu, 23 Jul 2026 16:42:11 +0200
Subject: [PATCH 10/13] chore: remove the dead MG4Tasker ignition broadcast

MG4Tasker is now independent and listens for ignition itself, so
MG4Control's ignition notification broadcast had no receiver. Remove
notifyTaskerOnIgnition(), the ACTION_IGNITION_ON constant, the TASKER_*
constants, and MG4Control's own use of the TASKER_BRIDGE permission (it
still declares the permission to protect the profile bridge service).

Build + tests green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 app/src/main/AndroidManifest.xml              |  7 ++--
 .../mg4/control/service/MG4ControlService.kt  | 32 -------------------
 .../mg4/control/tasker/TaskerBridgeService.kt |  2 --
 3 files changed, 3 insertions(+), 38 deletions(-)

diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index b762edc..96f3bb9 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -30,13 +30,12 @@
         android:protectionLevel="signature" />
 
     <!-- Pont MG4Tasker. En protectionLevel="signature", seule une app signée avec la même
-         clé plateforme peut se lier au service ou recevoir la notification d'allumage.
-         MG4Control la déclare ET la demande : il l'exige des clients du service, et il en a
-         besoin lui-même pour émettre le broadcast vers MG4Tasker. -->
+         clé plateforme peut se lier au TaskerBridgeService. MG4Control la déclare pour
+         protéger ce service ; MG4Tasker (signé avec la même clé) l'obtient et l'utilise
+         uniquement pour l'action « appliquer un profil ». -->
     <permission
         android:name="com.mg4.control.permission.TASKER_BRIDGE"
         android:protectionLevel="signature" />
-    <uses-permission android:name="com.mg4.control.permission.TASKER_BRIDGE" />
 
     <!-- Réseau / auto-update : déclarés UNIQUEMENT dans le flavor online
          (src/online/AndroidManifest.xml). Le flavor offline n'en a aucun, par construction. -->
diff --git a/app/src/main/java/com/mg4/control/service/MG4ControlService.kt b/app/src/main/java/com/mg4/control/service/MG4ControlService.kt
index 1d5e8cf..d66452a 100644
--- a/app/src/main/java/com/mg4/control/service/MG4ControlService.kt
+++ b/app/src/main/java/com/mg4/control/service/MG4ControlService.kt
@@ -29,7 +29,6 @@ import com.mg4.hardware.model.RegenLevel
 import com.mg4.control.profile.ProfileApplier
 import com.mg4.control.profile.ProfileManager
 import com.mg4.control.shortcut.ShortcutAction
-import com.mg4.control.tasker.TaskerBridgeService
 import com.mg4.hardware.FirmwareInfo
 import com.mg4.hardware.VehicleWriteGate
 import com.mg4.control.util.ThemeHelper
@@ -45,11 +44,7 @@ class MG4ControlService : Service() {
         private const val NOTIF_ID     = 1
         private const val PREFS_SHORTCUTS = "mg4_shortcuts"
 
-        /** Destinataire du broadcast d'allumage. Absent = broadcast sans effet, pas d'erreur. */
-        private const val TASKER_PACKAGE = "com.mg4.tasker"
 
-        /** Marge laissée à l'application du profil par défaut (HVAC scrute jusqu'à ~7 s). */
-        private const val TASKER_NOTIFY_DELAY_MS = 8_000L
 
         // Intent action broadcast par le système SAIC pour les touches physiques
         private const val HARDKEY_ACTION   = "com.saic.keyevent.hardkey.report"
@@ -464,7 +459,6 @@ class MG4ControlService : Service() {
                     Handler(Looper.getMainLooper()).postDelayed({
                         applyDefaultProfileOnIgnition()
                     }, 500L)
-                    notifyTaskerOnIgnition()
                 }
                 MG4Hardware.CarIgnitionItem.OFF -> {
                     // Extinction → on oublie le choix manuel : le prochain cycle repart sur le défaut/BT
@@ -480,32 +474,6 @@ class MG4ControlService : Service() {
         AppLogger.i(TAG, "Listener Katman5 enregistré")
     }
 
-    /**
-     * Prévient MG4Tasker qu'un cycle d'allumage vient de commencer.
-     *
-     * Le délai n'est pas cosmétique : [applyDefaultProfileOnIgnition] démarre à +500 ms et
-     * ses écritures HVAC scrutent l'état jusqu'à ~7 s. Réveiller le tasker plus tôt le
-     * ferait écrire pendant qu'un profil est en cours d'application — ces écritures
-     * unitaires ne passent pas par le mutex de ProfileApplier et s'entrelaceraient avec
-     * les séquences ADAS multi-étapes. On laisse donc le profil se poser d'abord.
-     *
-     * Broadcast explicite (package ciblé) + permission signature : aucune app tierce ne
-     * peut ni le recevoir ni s'y substituer.
-     */
-    private fun notifyTaskerOnIgnition() {
-        Handler(Looper.getMainLooper()).postDelayed({
-            val intent = Intent(TaskerBridgeService.ACTION_IGNITION_ON).apply {
-                setPackage(TASKER_PACKAGE)
-            }
-            try {
-                sendBroadcast(intent, TaskerBridgeService.PERMISSION_BRIDGE)
-                AppLogger.i(TAG, "IGNITION → notification MG4Tasker envoyée")
-            } catch (e: Exception) {
-                AppLogger.w(TAG, "IGNITION → notification MG4Tasker échouée : ${e.message}")
-            }
-        }, TASKER_NOTIFY_DELAY_MS)
-    }
-
     /**
      * [BT-PROFILES] Enregistre les receivers ACL Bluetooth pour maintenir
      * la liste des appareils connectés dans BluetoothProfileManager.
diff --git a/app/src/main/java/com/mg4/control/tasker/TaskerBridgeService.kt b/app/src/main/java/com/mg4/control/tasker/TaskerBridgeService.kt
index e48eeeb..fd42816 100644
--- a/app/src/main/java/com/mg4/control/tasker/TaskerBridgeService.kt
+++ b/app/src/main/java/com/mg4/control/tasker/TaskerBridgeService.kt
@@ -37,8 +37,6 @@ class TaskerBridgeService : Service() {
     companion object {
         private const val TAG = "MG4_TASKER_BRIDGE"
 
-        /** Broadcast émis vers MG4Tasker quand l'allumage passe à ON. */
-        const val ACTION_IGNITION_ON = "com.mg4.control.tasker.IGNITION_ON"
 
         /** Permission signature exigée du récepteur du broadcast ci-dessus. */
         const val PERMISSION_BRIDGE = "com.mg4.control.permission.TASKER_BRIDGE"

From 2bb82243b9727cf30fd611cfe28fd70fbf144e99 Mon Sep 17 00:00:00 2001
From: Malys <malys.training@gmail.com>
Date: Thu, 23 Jul 2026 21:17:50 +0200
Subject: [PATCH 11/13] refactor: trim the Tasker bridge to profile-only
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

MG4Tasker is now independent and reads/writes the vehicle itself, so the
bridge's readSnapshot() and applyAction() had no caller. Reduce the AIDL
contract and the service to what MG4Tasker actually uses — listProfiles()
and applyProfile() — and correct the now-false docstring (it claimed
MG4Tasker never touches the vehicle and needs no privileges).

Removes the snapshot builder, the action dispatch, the snapshot keys and
the PARAM_VALUE constant. Build + tests green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../com/mg4/control/tasker/ITaskerBridge.aidl |  35 +--
 .../mg4/control/tasker/TaskerBridgeService.kt | 224 ++----------------
 2 files changed, 28 insertions(+), 231 deletions(-)

diff --git a/app/src/main/aidl/com/mg4/control/tasker/ITaskerBridge.aidl b/app/src/main/aidl/com/mg4/control/tasker/ITaskerBridge.aidl
index a2b3b5e..11434cc 100644
--- a/app/src/main/aidl/com/mg4/control/tasker/ITaskerBridge.aidl
+++ b/app/src/main/aidl/com/mg4/control/tasker/ITaskerBridge.aidl
@@ -1,37 +1,24 @@
 package com.mg4.control.tasker;
 
 /**
- * Pont IPC exposé par MG4Control à MG4Tasker.
+ * Narrow IPC surface exposed by MG4Control to MG4Tasker — profiles only.
  *
- * Contrat volontairement ÉTROIT : 4 méthodes, jamais une par réglage véhicule.
- * Ajouter une action au catalogue ne change pas cette interface, seulement le
- * dispatch interne de applyAction(). Toute écriture véhicule reste exécutée
- * dans le processus MG4Control, donc soumise à VehicleWriteGate.
+ * MG4Tasker is an independent system app: it reads and writes the vehicle itself through
+ * the shared MG4Hardware layer. The one thing it cannot do on its own is apply an
+ * MG4Control *profile* (those live in MG4Control), so this bridge exposes exactly that and
+ * nothing else. There is no vehicle read or raw property write here.
  *
- * Protégé par la permission signature com.mg4.control.permission.TASKER_BRIDGE.
+ * Guarded by the signature permission com.mg4.control.permission.TASKER_BRIDGE.
  */
 interface ITaskerBridge {
 
-    /**
-     * Instantané de l'état véhicule pour l'évaluation des conditions.
-     * Toutes les clés sont optionnelles : une valeur absente = donnée illisible.
-     * Voir TaskerBridgeService.KEY_* pour la liste.
-     */
-    Bundle readSnapshot();
-
-    /** Profils MG4Control. Bundle : "ids" String[], "names" String[], "defaultId" String. */
+    /** MG4Control profiles. Bundle: "ids" String[], "names" String[], "defaultId" String. */
     Bundle listProfiles();
 
-    /** Applique un profil complet. Bundle résultat : voir applyAction. */
-    Bundle applyProfile(String profileId);
-
     /**
-     * Exécute une action unitaire du catalogue.
-     * @param actionType identifiant stable, ex. "SET_MEDIA_VOLUME"
-     * @param params arguments typés ("int", "bool", "string" selon l'action)
-     * @return Bundle : "ok" boolean, "verdict" String
-     *         (ALLOWED | REFUSED_MOVING | REFUSED_UNKNOWN_SPEED | UNSUPPORTED | ERROR),
-     *         "detail" String optionnel.
+     * Applies a whole profile. Bundle result: "ok" boolean, "verdict" String
+     * (ALLOWED | REFUSED_MOVING | REFUSED_UNKNOWN_SPEED | UNSUPPORTED | ERROR),
+     * "detail" String optional.
      */
-    Bundle applyAction(String actionType, in Bundle params);
+    Bundle applyProfile(String profileId);
 }
diff --git a/app/src/main/java/com/mg4/control/tasker/TaskerBridgeService.kt b/app/src/main/java/com/mg4/control/tasker/TaskerBridgeService.kt
index fd42816..638d320 100644
--- a/app/src/main/java/com/mg4/control/tasker/TaskerBridgeService.kt
+++ b/app/src/main/java/com/mg4/control/tasker/TaskerBridgeService.kt
@@ -7,81 +7,29 @@ import android.os.IBinder
 import com.mg4.hardware.AppLogger
 import com.mg4.hardware.MG4Hardware
 import com.mg4.hardware.VehicleWriteGate
-import com.mg4.hardware.model.DriveMode
-import com.mg4.hardware.model.RegenLevel
 import com.mg4.control.profile.ProfileApplier
 import com.mg4.control.profile.ProfileManager
-import com.mg4.hardware.FirmwareInfo
-import com.mg4.control.bluetooth.BluetoothProfileManager
 
 /**
- * Pont IPC pour MG4Tasker (voir [ITaskerBridge]).
+ * Profile bridge for MG4Tasker (see [ITaskerBridge]).
  *
- * Principe : MG4Tasker ne touche JAMAIS le véhicule. Il lit un instantané et demande des
- * actions nommées ; l'écriture réelle se fait ici, dans le processus qui détient
- * android.uid.system et [VehicleWriteGate]. Conséquences voulues :
- *   • un seul processus écrit → pas d'entrelacement de commandes ADAS
- *   • le verrou 0 km/h reste appliqué à un seul endroit
- *   • MG4Tasker n'a pas besoin de privilèges véhicule
+ * MG4Tasker is an independent system app: it reads and writes the vehicle itself through
+ * the shared MG4Hardware layer. The one thing it cannot do alone is apply an MG4Control
+ * *profile* — those live in MG4Control — so this service exposes exactly that: list the
+ * profiles and apply one. There is no vehicle read and no raw property write here.
  *
- * Le catalogue d'actions est une liste fermée. Il n'existe volontairement aucune méthode
- * « écris la propriété 0xNNNN » : un appelant compromis ne peut solliciter que ce que
- * l'utilisateur peut déjà faire depuis l'UI de MG4Control.
- *
- * [VEHICLE_POWER_OFF] est délibérément ABSENT du catalogue. Couper le véhicule est une
- * action irréversible pour le conducteur ; elle reste réservée à un geste humain explicite
- * (raccourci volant), jamais à une règle automatique.
+ * Guarded by the signature permission com.mg4.control.permission.TASKER_BRIDGE: only an app
+ * signed with the same platform key can bind.
  */
 class TaskerBridgeService : Service() {
 
     companion object {
         private const val TAG = "MG4_TASKER_BRIDGE"
 
-
-        /** Permission signature exigée du récepteur du broadcast ci-dessus. */
+        /** Signature permission required to bind this service. */
         const val PERMISSION_BRIDGE = "com.mg4.control.permission.TASKER_BRIDGE"
 
-        // ── Clés de l'instantané ────────────────────────────────────────────
-        // Une clé ABSENTE signifie « illisible ». Ne jamais écrire de valeur
-        // sentinelle (-1) : le tasker la prendrait pour une vraie mesure.
-        const val KEY_SPEED_KMH        = "speedKmh"          // float
-        const val KEY_SPEED_READABLE   = "speedReadable"     // boolean (toujours présent)
-        const val KEY_IGNITION         = "ignition"          // int
-        const val KEY_IN_PARK          = "inPark"            // boolean
-        const val KEY_OUTSIDE_TEMP     = "outsideTempC"      // float
-        const val KEY_DRIVE_MODE       = "driveMode"         // int (DriveMode.value)
-        const val KEY_REGEN_LEVEL      = "regenLevel"        // int (RegenLevel.value)
-        const val KEY_SEAT_HEAT_L      = "seatHeatLeft"      // int
-        const val KEY_SEAT_HEAT_R      = "seatHeatRight"     // int
-        const val KEY_STEERING_HEAT    = "steeringHeat"      // boolean
-        const val KEY_MEDIA_VOLUME     = "mediaVolume"       // int
-        const val KEY_MEDIA_VOLUME_MAX = "mediaVolumeMax"    // int
-        const val KEY_BRIGHTNESS       = "brightnessPct"     // int
-        const val KEY_OVERSPEED_ALARM  = "overspeedAlarm"    // boolean
-        const val KEY_SPEED_LIMIT_TONE = "speedLimitTone"    // boolean
-        const val KEY_SOUND_WARNING    = "soundWarning"      // boolean
-        const val KEY_AEB_ENABLED      = "aebEnabled"        // boolean
-        const val KEY_AEB_MODE         = "aebMode"           // int
-        const val KEY_AEB_SENSITIVITY  = "aebSensitivity"    // int
-        const val KEY_ELK_MODE         = "elkMode"           // int
-        const val KEY_ELK_SENSITIVITY  = "elkSensitivity"    // int
-        const val KEY_TSR              = "tsr"               // boolean
-        const val KEY_ENERGY_SAVING    = "energySaving"      // boolean
-        const val KEY_ACC_TJA_MODE     = "accTjaMode"        // int
-        const val KEY_LIMITER_MODE     = "limiterMode"       // int
-        // Climate + windows — read only, unverified (see MG4Hardware). Absent = unreadable.
-        const val KEY_AC_ON            = "acOn"              // boolean
-        const val KEY_HVAC_AUTO        = "hvacAuto"          // boolean
-        const val KEY_RECIRC           = "recirc"            // boolean
-        const val KEY_FAN_SPEED        = "fanSpeed"          // int
-        const val KEY_TEMPERATURE_SET  = "temperatureSetC"   // float
-        const val KEY_WINDOW_OPEN      = "windowOpen"        // boolean
-        const val KEY_FIRMWARE_GEN     = "firmwareGen"       // String
-        const val KEY_BT_MACS          = "btConnectedMacs"   // String[]
-        const val KEY_HAS_AUDIO        = "hasAudioControl"   // boolean
-        const val KEY_HAS_BRIGHTNESS   = "hasBrightness"     // boolean
-
-        // ── Clés du résultat ────────────────────────────────────────────────
+        // Result keys (shared with MG4Tasker's BridgeContract).
         const val KEY_OK      = "ok"
         const val KEY_VERDICT = "verdict"
         const val KEY_DETAIL  = "detail"
@@ -92,15 +40,10 @@ class TaskerBridgeService : Service() {
         const val VERDICT_UNSUPPORTED   = "UNSUPPORTED"
         const val VERDICT_ERROR         = "ERROR"
 
-        /** Clé unique des paramètres d'action (int, boolean ou String selon l'action). */
-        const val PARAM_VALUE = "value"
-
         /**
-         * Traduit la décision du verrou en verdict transmissible au tasker.
-         *
-         * Fonction pure et exhaustive : si [VehicleWriteGate.Decision] gagne un cas, la
-         * compilation casse ici plutôt que d'envoyer un verdict inventé au tasker, qui
-         * l'afficherait à l'utilisateur comme un motif de refus.
+         * Translates the gate decision into a verdict string. Pure and exhaustive: if
+         * [VehicleWriteGate.Decision] gains a case, compilation breaks here rather than
+         * sending an invented verdict to the caller.
          */
         fun verdictOf(decision: VehicleWriteGate.Decision): String = when (decision) {
             VehicleWriteGate.Decision.ALLOWED               -> VERDICT_ALLOWED
@@ -115,55 +58,6 @@ class TaskerBridgeService : Service() {
 
     private val binder = object : ITaskerBridge.Stub() {
 
-        override fun readSnapshot(): Bundle = Bundle().apply {
-            val speed = MG4Hardware.getVehicleSpeedKmh()
-            putBoolean(KEY_SPEED_READABLE, speed != null)
-            speed?.let { putFloat(KEY_SPEED_KMH, it) }
-
-            MG4Hardware.getCurrentIgnitionState().takeIf { it > 0 }?.let { putInt(KEY_IGNITION, it) }
-            MG4Hardware.isVehicleInPark()?.let { putBoolean(KEY_IN_PARK, it) }
-            MG4Hardware.getOutsideTempCelsius()?.let { putFloat(KEY_OUTSIDE_TEMP, it) }
-
-            MG4Hardware.getDriveMode()?.let { putInt(KEY_DRIVE_MODE, it.value) }
-            MG4Hardware.getRegenLevel()?.let { putInt(KEY_REGEN_LEVEL, it.value) }
-
-            putIfReadable(KEY_SEAT_HEAT_L, MG4Hardware.getSeatHeatLeft())
-            putIfReadable(KEY_SEAT_HEAT_R, MG4Hardware.getSeatHeatRight())
-            putBoolean(KEY_STEERING_HEAT, MG4Hardware.isSteeringHeatOn())
-
-            putIfReadable(KEY_MEDIA_VOLUME, MG4Hardware.getMediaVolume())
-            putIfReadable(KEY_MEDIA_VOLUME_MAX, MG4Hardware.getMediaVolumeMax())
-
-            putBoolean(KEY_HAS_BRIGHTNESS, MG4Hardware.hasBrightnessControl())
-            if (MG4Hardware.hasBrightnessControl()) {
-                putIfReadable(KEY_BRIGHTNESS, MG4Hardware.getScreenBrightnessPercent())
-            }
-
-            putBoolean(KEY_OVERSPEED_ALARM, MG4Hardware.isOverspeedAlarmOn())
-            putBoolean(KEY_SPEED_LIMIT_TONE, MG4Hardware.isSpeedLimitToneOn())
-            putBoolean(KEY_SOUND_WARNING, MG4Hardware.isSoundWarningOn())
-            putBoolean(KEY_AEB_ENABLED, MG4Hardware.isAebEnabled())
-            putIfReadable(KEY_AEB_MODE, MG4Hardware.getAebMode())
-            putIfReadable(KEY_AEB_SENSITIVITY, MG4Hardware.getAebSensitivity())
-            putIfReadable(KEY_ELK_MODE, MG4Hardware.getElkMode())
-            putIfReadable(KEY_ELK_SENSITIVITY, MG4Hardware.getElkSensitivity())
-            putBoolean(KEY_TSR, MG4Hardware.isTsrOn())
-            putBoolean(KEY_ENERGY_SAVING, MG4Hardware.isEnergySavingOn())
-            putIfReadable(KEY_ACC_TJA_MODE, MG4Hardware.getAccTjaMode())
-            putIfReadable(KEY_LIMITER_MODE, MG4Hardware.getSpeedLimiterMode())
-
-            MG4Hardware.getAcOn()?.let { putBoolean(KEY_AC_ON, it) }
-            MG4Hardware.getHvacAutoOn()?.let { putBoolean(KEY_HVAC_AUTO, it) }
-            MG4Hardware.getRecircOn()?.let { putBoolean(KEY_RECIRC, it) }
-            MG4Hardware.getFanSpeed()?.let { putInt(KEY_FAN_SPEED, it) }
-            MG4Hardware.getTemperatureSetCelsius()?.let { putFloat(KEY_TEMPERATURE_SET, it) }
-            MG4Hardware.isAnyWindowOpen()?.let { putBoolean(KEY_WINDOW_OPEN, it) }
-
-            putString(KEY_FIRMWARE_GEN, FirmwareInfo.getGeneration().name)
-            putBoolean(KEY_HAS_AUDIO, MG4Hardware.hasAudioControl())
-            putStringArray(KEY_BT_MACS, BluetoothProfileManager.getConnectedMacs().toTypedArray())
-        }
-
         override fun listProfiles(): Bundle {
             val profiles = profileManager.getAll()
             return Bundle().apply {
@@ -175,105 +69,21 @@ class TaskerBridgeService : Service() {
 
         override fun applyProfile(profileId: String?): Bundle {
             val profile = profileId?.let { profileManager.getById(it) }
-                ?: return result(false, VERDICT_UNSUPPORTED, "profil introuvable: $profileId")
+                ?: return result(false, VERDICT_UNSUPPORTED, "profile not found: $profileId")
 
-            // Le gate est ré-évalué réglage par réglage dans ProfileApplier ; on renvoie
-            // ici le verdict courant pour que le tasker sache s'il faut s'attendre à des
-            // refus partiels. L'application elle-même est asynchrone.
-            val verdict = gateVerdict()
+            // The gate is re-evaluated setting-by-setting inside ProfileApplier; the current
+            // verdict is returned here so the caller knows whether to expect partial
+            // refusals. Application itself is asynchronous.
+            val verdict = verdictOf(VehicleWriteGate.decide(MG4Hardware.getVehicleSpeedKmh()))
             ProfileApplier.apply(profile, autoStart = true)
             AppLogger.i(TAG, "applyProfile(${profile.name}) verdict=$verdict")
             return result(true, verdict, profile.name)
         }
-
-        override fun applyAction(actionType: String?, params: Bundle?): Bundle {
-            val type = actionType ?: return result(false, VERDICT_UNSUPPORTED, "action nulle")
-            val args = params ?: Bundle()
-            return try {
-                dispatch(type, args)
-            } catch (e: Exception) {
-                AppLogger.w(TAG, "applyAction($type) exception: ${e.message}")
-                result(false, VERDICT_ERROR, e.message)
-            }
-        }
-    }
-
-    // -------------------------------------------------------------------------
-    // Catalogue d'actions
-    // -------------------------------------------------------------------------
-
-    /**
-     * [gated] = écriture qui change le comportement routier → soumise au verrou 0 km/h.
-     * On calcule le verdict AVANT d'appeler MG4Hardware, uniquement pour pouvoir le
-     * rapporter au tasker. Le refus effectif reste celui de MG4Hardware/VehicleWriteGate :
-     * cette pré-lecture n'est pas la garde, elle l'observe.
-     */
-    private fun dispatch(type: String, args: Bundle): Bundle {
-        val i = { args.getInt(PARAM_VALUE) }
-        val b = { args.getBoolean(PARAM_VALUE) }
-
-        return when (type) {
-            // ── Confort : pas de gate (n'altère pas le comportement routier) ──
-            "SET_SEAT_HEAT_LEFT"       -> ungated { MG4Hardware.setSeatHeatLeft(i()) }
-            "SET_SEAT_HEAT_RIGHT"      -> ungated { MG4Hardware.setSeatHeatRight(i()) }
-            "SET_STEERING_HEAT"        -> ungated { MG4Hardware.setSteeringHeat(b()) }
-            "SET_MEDIA_VOLUME"         -> ungated { MG4Hardware.setMediaVolume(i()) }
-            "SET_SCREEN_BRIGHTNESS"    -> ungated { MG4Hardware.setScreenBrightnessPercent(i()) }
-            "SET_AUDIO_BALANCE"        -> ungated { MG4Hardware.setAudioBalance(i()) }
-            "SET_AUDIO_FADER"          -> ungated { MG4Hardware.setAudioFader(i()) }
-            "SET_BOSE_SOUND_TYPE"      -> ungated { MG4Hardware.setBoseSoundType(i()) }
-            "SET_3D_EFFECT"            -> ungated { MG4Hardware.set3dEffectType(i()) }
-            "SET_TONE_CONTROL"         -> ungated { MG4Hardware.setToneControl(i()) }
-            "SET_SOUND_FIELD"          -> ungated { MG4Hardware.setSoundFieldType(i()) }
-            "SET_SPEED_VOLUME"         -> ungated { MG4Hardware.setSpeedVolumeLevel(i()) }
-            "SET_LAS_WARNING_SOUND"    -> ungated { MG4Hardware.setLasWarningSound(b()) }
-            "SET_LAS_WARNING_VIBRATION"-> ungated { MG4Hardware.setLasWarningVibration(b()) }
-
-            // ── Comportement routier : gated ──────────────────────────────────
-            "SET_DRIVE_MODE"      -> gated { MG4Hardware.setDriveMode(DriveMode.fromValue(i())) }
-            "SET_REGEN_LEVEL"     -> gated { MG4Hardware.setRegenLevel(RegenLevel.fromValue(i())) }
-            "SET_ONE_PEDAL"       -> gated { MG4Hardware.setOnePedal(b()) }
-            "SET_OVERSPEED_ALARM" -> gated { MG4Hardware.setOverspeedAlarm(b()) }
-            "SET_SPEED_LIMIT_TONE"-> gated { MG4Hardware.setSpeedLimitTone(b()) }
-            "SET_SOUND_WARNING"   -> gated { MG4Hardware.setSoundWarning(b()) }
-            "SET_AEB_ENABLED"     -> gated { MG4Hardware.setAebEnabled(b()) }
-            "SET_AEB_MODE"        -> gated { MG4Hardware.setAebMode(i()) }
-            "SET_AEB_SENSITIVITY" -> gated { MG4Hardware.setAebSensitivity(i()) }
-            "SET_ELK_MODE"        -> gated { MG4Hardware.setElkMode(i()) }
-            "SET_ELK_SENSITIVITY" -> gated { MG4Hardware.setElkSensitivity(i()) }
-            "SET_TSR"             -> gated { MG4Hardware.setTsrMode(b()) }
-            "SET_ENERGY_SAVING"   -> gated { MG4Hardware.setEnergySavingMode(b()) }
-            "SET_ACC_TJA_MODE"    -> gated { MG4Hardware.setAccTjaMode(i()) }
-            "SET_LIMITER_MODE"    -> gated { MG4Hardware.setSpeedLimiterMode(i()) }
-            "SET_INTELLIGENT_DRIVE"-> gated { MG4Hardware.setMixedIntelligentDrive(i()) }
-
-            else -> result(false, VERDICT_UNSUPPORTED, "action inconnue: $type")
-        }
-    }
-
-    private inline fun ungated(write: () -> Boolean): Bundle {
-        val ok = write()
-        return result(ok, if (ok) VERDICT_ALLOWED else VERDICT_ERROR)
-    }
-
-    private inline fun gated(write: () -> Boolean): Bundle {
-        val verdict = gateVerdict()
-        if (verdict != VERDICT_ALLOWED) return result(false, verdict)
-        val ok = write()
-        return result(ok, if (ok) VERDICT_ALLOWED else VERDICT_ERROR)
     }
 
-    private fun gateVerdict(): String =
-        verdictOf(VehicleWriteGate.decide(MG4Hardware.getVehicleSpeedKmh()))
-
     private fun result(ok: Boolean, verdict: String, detail: String? = null) = Bundle().apply {
         putBoolean(KEY_OK, ok)
         putString(KEY_VERDICT, verdict)
         detail?.let { putString(KEY_DETAIL, it) }
     }
-
-    /** Les getters MG4Hardware renvoient -1 quand la couche n'est pas prête : on n'écrit rien. */
-    private fun Bundle.putIfReadable(key: String, value: Int) {
-        if (value >= 0) putInt(key, value)
-    }
 }

From 69f7fe5c15e63420172c62a2985b87a618963274 Mon Sep 17 00:00:00 2001
From: Malys <malys.training@gmail.com>
Date: Thu, 23 Jul 2026 21:34:33 +0200
Subject: [PATCH 12/13] refactor: generalize the Tasker bridge into a
 caller-agnostic profile API
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The IPC surface was named for one caller (MG4Tasker), but it is just
MG4Control's external control API — list and apply driving profiles, nothing
else. Rename it so any app signed with the platform key can use it without the
naming implying a single client:

- com.mg4.control.tasker.ITaskerBridge      -> com.mg4.control.api.IProfileControl
- TaskerBridgeService                       -> ProfileControlService
- permission …TASKER_BRIDGE                 -> …CONTROL_PROFILES

No behaviour change: same two methods, same signature-level protection, same
0 km/h gate verdicts. Manifest, proguard keep rules, permission allowlist and
the verdict test move with it; French bridge comments translated to English.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .github/security/permission-allowlist.txt     |  4 +-
 app/proguard-rules.pro                        |  8 ++--
 app/src/main/AndroidManifest.xml              | 21 ++++----
 .../com/mg4/control/api/IProfileControl.aidl  | 23 +++++++++
 .../com/mg4/control/tasker/ITaskerBridge.aidl | 24 ----------
 .../ProfileControlService.kt}                 | 25 +++++-----
 .../control/api/ProfileControlVerdictTest.kt  | 48 +++++++++++++++++++
 .../control/tasker/TaskerBridgeVerdictTest.kt | 48 -------------------
 8 files changed, 99 insertions(+), 102 deletions(-)
 create mode 100644 app/src/main/aidl/com/mg4/control/api/IProfileControl.aidl
 delete mode 100644 app/src/main/aidl/com/mg4/control/tasker/ITaskerBridge.aidl
 rename app/src/main/java/com/mg4/control/{tasker/TaskerBridgeService.kt => api/ProfileControlService.kt} (78%)
 create mode 100644 app/src/test/java/com/mg4/control/api/ProfileControlVerdictTest.kt
 delete mode 100644 app/src/test/java/com/mg4/control/tasker/TaskerBridgeVerdictTest.kt

diff --git a/.github/security/permission-allowlist.txt b/.github/security/permission-allowlist.txt
index 23f507a..2e0061d 100644
--- a/.github/security/permission-allowlist.txt
+++ b/.github/security/permission-allowlist.txt
@@ -23,10 +23,10 @@ android.car.permission.CONTROL_CAR_CLIMATE
 # seule une app signée avec la clé plateforme peut l'obtenir. Elle restreint un accès,
 # elle n'en accorde pas.
 com.mg4.control.permission.RECEIVE_HARDKEY
-# Pont MG4Tasker : ferme l'accès au TaskerBridgeService et au broadcast d'allumage.
+# External control API: signature-level permission protecting ProfileControlService.
 # protectionLevel="signature" → réservée aux apps signées avec la clé plateforme.
 # Déclarée ET demandée par MG4Control : demandée pour pouvoir émettre le broadcast.
-com.mg4.control.permission.TASKER_BRIDGE
+com.mg4.control.permission.CONTROL_PROFILES
 # --- network / auto-update (online variant only) ---
 android.permission.INTERNET
 android.permission.ACCESS_NETWORK_STATE
diff --git a/app/proguard-rules.pro b/app/proguard-rules.pro
index 07e699a..908bb41 100644
--- a/app/proguard-rules.pro
+++ b/app/proguard-rules.pro
@@ -9,10 +9,10 @@
 # ServiceManager, which was already listed.
 -keep class android.os.SystemProperties { *; }
 
-# Contrat IPC avec MG4Tasker. Le Stub/Proxy AIDL est résolu par nom côté client :
-# renommer ces classes casserait le bind au lieu d'échouer à la compilation.
--keep interface com.mg4.control.tasker.ITaskerBridge { *; }
--keep class com.mg4.control.tasker.ITaskerBridge$* { *; }
+# External control IPC contract. The AIDL Stub/Proxy is resolved by name on the client
+# side: renaming these classes would break the bind instead of failing at compile time.
+-keep interface com.mg4.control.api.IProfileControl { *; }
+-keep class com.mg4.control.api.IProfileControl$* { *; }
 
 # Gson (profils + sauvegarde). Sans Signature, le type générique de
 # TypeToken<List<DrivingProfile>> est effacé et la désérialisation rend une liste de
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 96f3bb9..d29a3d2 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -29,12 +29,11 @@
         android:name="com.mg4.control.permission.RECEIVE_HARDKEY"
         android:protectionLevel="signature" />
 
-    <!-- Pont MG4Tasker. En protectionLevel="signature", seule une app signée avec la même
-         clé plateforme peut se lier au TaskerBridgeService. MG4Control la déclare pour
-         protéger ce service ; MG4Tasker (signé avec la même clé) l'obtient et l'utilise
-         uniquement pour l'action « appliquer un profil ». -->
+    <!-- External control API. In protectionLevel="signature", only an app signed with the
+         same platform key can bind ProfileControlService. MG4Control declares the permission
+         to protect that service; any such app may list and apply MG4Control profiles. -->
     <permission
-        android:name="com.mg4.control.permission.TASKER_BRIDGE"
+        android:name="com.mg4.control.permission.CONTROL_PROFILES"
         android:protectionLevel="signature" />
 
     <!-- Réseau / auto-update : déclarés UNIQUEMENT dans le flavor online
@@ -76,14 +75,14 @@
             android:directBootAware="true"
             android:foregroundServiceType="connectedDevice" />
 
-        <!-- Pont IPC MG4Tasker. exported=true car le client est une autre app, mais l'accès
-             est fermé par la permission signature : seule une app signée avec la clé
-             plateforme de la ROM peut se lier. Le service n'expose aucune écriture de
-             propriété brute — uniquement le catalogue d'actions de TaskerBridgeService. -->
+        <!-- External control API (profiles). exported=true because the caller is another
+             app, but access is closed by the signature permission: only an app signed with
+             the ROM platform key can bind. The service exposes no raw property write —
+             only listing and applying MG4Control profiles. -->
         <service
-            android:name=".tasker.TaskerBridgeService"
+            android:name=".api.ProfileControlService"
             android:exported="true"
-            android:permission="com.mg4.control.permission.TASKER_BRIDGE" />
+            android:permission="com.mg4.control.permission.CONTROL_PROFILES" />
 
         <!-- FileProvider + InstallReceiver (auto-update) : déclarés UNIQUEMENT dans
              le flavor online (src/online/AndroidManifest.xml). Déplacer le FileProvider
diff --git a/app/src/main/aidl/com/mg4/control/api/IProfileControl.aidl b/app/src/main/aidl/com/mg4/control/api/IProfileControl.aidl
new file mode 100644
index 0000000..1ca27ef
--- /dev/null
+++ b/app/src/main/aidl/com/mg4/control/api/IProfileControl.aidl
@@ -0,0 +1,23 @@
+package com.mg4.control.api;
+
+/**
+ * MG4Control's external control API — driving profiles.
+ *
+ * Any app signed with the same platform key can bind this and list or apply MG4Control's
+ * driving profiles. It is deliberately narrow: profiles only, no vehicle read and no raw
+ * property write. It is not tied to any particular caller.
+ *
+ * Guarded by the signature permission com.mg4.control.permission.CONTROL_PROFILES.
+ */
+interface IProfileControl {
+
+    /** MG4Control profiles. Bundle: "ids" String[], "names" String[], "defaultId" String. */
+    Bundle listProfiles();
+
+    /**
+     * Applies a whole profile. Bundle result: "ok" boolean, "verdict" String
+     * (ALLOWED | REFUSED_MOVING | REFUSED_UNKNOWN_SPEED | UNSUPPORTED | ERROR),
+     * "detail" String optional.
+     */
+    Bundle applyProfile(String profileId);
+}
diff --git a/app/src/main/aidl/com/mg4/control/tasker/ITaskerBridge.aidl b/app/src/main/aidl/com/mg4/control/tasker/ITaskerBridge.aidl
deleted file mode 100644
index 11434cc..0000000
--- a/app/src/main/aidl/com/mg4/control/tasker/ITaskerBridge.aidl
+++ /dev/null
@@ -1,24 +0,0 @@
-package com.mg4.control.tasker;
-
-/**
- * Narrow IPC surface exposed by MG4Control to MG4Tasker — profiles only.
- *
- * MG4Tasker is an independent system app: it reads and writes the vehicle itself through
- * the shared MG4Hardware layer. The one thing it cannot do on its own is apply an
- * MG4Control *profile* (those live in MG4Control), so this bridge exposes exactly that and
- * nothing else. There is no vehicle read or raw property write here.
- *
- * Guarded by the signature permission com.mg4.control.permission.TASKER_BRIDGE.
- */
-interface ITaskerBridge {
-
-    /** MG4Control profiles. Bundle: "ids" String[], "names" String[], "defaultId" String. */
-    Bundle listProfiles();
-
-    /**
-     * Applies a whole profile. Bundle result: "ok" boolean, "verdict" String
-     * (ALLOWED | REFUSED_MOVING | REFUSED_UNKNOWN_SPEED | UNSUPPORTED | ERROR),
-     * "detail" String optional.
-     */
-    Bundle applyProfile(String profileId);
-}
diff --git a/app/src/main/java/com/mg4/control/tasker/TaskerBridgeService.kt b/app/src/main/java/com/mg4/control/api/ProfileControlService.kt
similarity index 78%
rename from app/src/main/java/com/mg4/control/tasker/TaskerBridgeService.kt
rename to app/src/main/java/com/mg4/control/api/ProfileControlService.kt
index 638d320..00ef968 100644
--- a/app/src/main/java/com/mg4/control/tasker/TaskerBridgeService.kt
+++ b/app/src/main/java/com/mg4/control/api/ProfileControlService.kt
@@ -1,4 +1,4 @@
-package com.mg4.control.tasker
+package com.mg4.control.api
 
 import android.app.Service
 import android.content.Intent
@@ -11,25 +11,24 @@ import com.mg4.control.profile.ProfileApplier
 import com.mg4.control.profile.ProfileManager
 
 /**
- * Profile bridge for MG4Tasker (see [ITaskerBridge]).
+ * MG4Control's external control API — driving profiles (see [IProfileControl]).
  *
- * MG4Tasker is an independent system app: it reads and writes the vehicle itself through
- * the shared MG4Hardware layer. The one thing it cannot do alone is apply an MG4Control
- * *profile* — those live in MG4Control — so this service exposes exactly that: list the
- * profiles and apply one. There is no vehicle read and no raw property write here.
+ * Lets any app signed with the same platform key list and apply MG4Control's driving
+ * profiles over IPC. Deliberately narrow: profiles only, no vehicle read and no raw
+ * property write. It is not tied to any particular caller.
  *
- * Guarded by the signature permission com.mg4.control.permission.TASKER_BRIDGE: only an app
- * signed with the same platform key can bind.
+ * Guarded by the signature permission com.mg4.control.permission.CONTROL_PROFILES: only an
+ * app signed with the same platform key can bind.
  */
-class TaskerBridgeService : Service() {
+class ProfileControlService : Service() {
 
     companion object {
-        private const val TAG = "MG4_TASKER_BRIDGE"
+        private const val TAG = "MG4_PROFILE_API"
 
         /** Signature permission required to bind this service. */
-        const val PERMISSION_BRIDGE = "com.mg4.control.permission.TASKER_BRIDGE"
+        const val PERMISSION = "com.mg4.control.permission.CONTROL_PROFILES"
 
-        // Result keys (shared with MG4Tasker's BridgeContract).
+        // Result keys (shared with callers).
         const val KEY_OK      = "ok"
         const val KEY_VERDICT = "verdict"
         const val KEY_DETAIL  = "detail"
@@ -56,7 +55,7 @@ class TaskerBridgeService : Service() {
 
     override fun onBind(intent: Intent?): IBinder = binder
 
-    private val binder = object : ITaskerBridge.Stub() {
+    private val binder = object : IProfileControl.Stub() {
 
         override fun listProfiles(): Bundle {
             val profiles = profileManager.getAll()
diff --git a/app/src/test/java/com/mg4/control/api/ProfileControlVerdictTest.kt b/app/src/test/java/com/mg4/control/api/ProfileControlVerdictTest.kt
new file mode 100644
index 0000000..89ec6e5
--- /dev/null
+++ b/app/src/test/java/com/mg4/control/api/ProfileControlVerdictTest.kt
@@ -0,0 +1,48 @@
+package com.mg4.control.api
+
+import com.mg4.hardware.VehicleWriteGate
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * The verdict is the only explanation an external caller can surface to the user when a
+ * profile write is refused. If it were wrong or empty, the user would see "nothing happened"
+ * without knowing that the speed gate declined the write.
+ */
+class ProfileControlVerdictTest {
+
+    @Test
+    fun `each gate decision has a distinct, non-empty verdict`() {
+        val verdicts = VehicleWriteGate.Decision.values()
+            .map { ProfileControlService.verdictOf(it) }
+
+        verdicts.forEach { assertTrue("empty verdict", it.isNotBlank()) }
+        assertEquals(
+            "two decisions must never produce the same verdict",
+            verdicts.size, verdicts.toSet().size
+        )
+    }
+
+    @Test
+    fun `zero speed allows, non-zero speed refuses`() {
+        assertEquals(
+            ProfileControlService.VERDICT_ALLOWED,
+            ProfileControlService.verdictOf(VehicleWriteGate.decide(0f))
+        )
+        assertEquals(
+            ProfileControlService.VERDICT_MOVING,
+            ProfileControlService.verdictOf(VehicleWriteGate.decide(42f))
+        )
+    }
+
+    @Test
+    fun `unreadable speed refuses instead of letting the write through`() {
+        // Fail closed: an unknown speed must never open the gate to an external caller,
+        // which would then write unsupervised on a potentially moving vehicle.
+        assertEquals(
+            ProfileControlService.VERDICT_UNKNOWN_SPEED,
+            ProfileControlService.verdictOf(VehicleWriteGate.decide(null))
+        )
+    }
+}
diff --git a/app/src/test/java/com/mg4/control/tasker/TaskerBridgeVerdictTest.kt b/app/src/test/java/com/mg4/control/tasker/TaskerBridgeVerdictTest.kt
deleted file mode 100644
index 3e8ea92..0000000
--- a/app/src/test/java/com/mg4/control/tasker/TaskerBridgeVerdictTest.kt
+++ /dev/null
@@ -1,48 +0,0 @@
-package com.mg4.control.tasker
-
-import com.mg4.hardware.VehicleWriteGate
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
-import org.junit.Test
-
-/**
- * Le verdict est la seule explication que MG4Tasker peut donner à l'utilisateur quand une
- * règle ne s'applique pas. S'il est faux ou vide, l'utilisateur voit « rien ne s'est passé »
- * sans savoir que c'est le verrou de vitesse qui a refusé.
- */
-class TaskerBridgeVerdictTest {
-
-    @Test
-    fun `chaque decision du verrou a un verdict distinct et non vide`() {
-        val verdicts = VehicleWriteGate.Decision.values()
-            .map { TaskerBridgeService.verdictOf(it) }
-
-        verdicts.forEach { assertTrue("verdict vide", it.isNotBlank()) }
-        assertEquals(
-            "deux décisions ne doivent jamais produire le même verdict",
-            verdicts.size, verdicts.toSet().size
-        )
-    }
-
-    @Test
-    fun `vitesse nulle autorise, vitesse non nulle refuse`() {
-        assertEquals(
-            TaskerBridgeService.VERDICT_ALLOWED,
-            TaskerBridgeService.verdictOf(VehicleWriteGate.decide(0f))
-        )
-        assertEquals(
-            TaskerBridgeService.VERDICT_MOVING,
-            TaskerBridgeService.verdictOf(VehicleWriteGate.decide(42f))
-        )
-    }
-
-    @Test
-    fun `vitesse illisible refuse au lieu de laisser passer`() {
-        // Fail closed : une vitesse inconnue ne doit jamais ouvrir la porte au tasker,
-        // qui écrirait alors sans supervision humaine sur un véhicule potentiellement roulant.
-        assertEquals(
-            TaskerBridgeService.VERDICT_UNKNOWN_SPEED,
-            TaskerBridgeService.verdictOf(VehicleWriteGate.decide(null))
-        )
-    }
-}

From fa4f48534de7b766d68a2fb4415d01de6cd8ddd0 Mon Sep 17 00:00:00 2001
From: malys <malys.training@gmail.com>
Date: Fri, 24 Jul 2026 18:11:24 +0200
Subject: [PATCH 13/13] build: let debug builds install on a stock emulator
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The app declares sharedUserId="android.uid.system" for vehicle access, which
requires the platform signature. A stock emulator is signed with Google's own
platform key (not the public AOSP test key — verified: signing with the AOSP
key still fails INSTALL_FAILED_SHARED_USER_INCOMPATIBLE on both the API 33
automotive and API 28 images), so neither a platform-signed nor a debug-key APK
with sharedUserId can install.

A debug-only manifest overlay (app/src/debug/AndroidManifest.xml) removes
sharedUserId with tools:remove, so debug builds install with the ordinary debug
key on any emulator. Release builds keep sharedUserId untouched — the src/main
manifest is unchanged and still declares it for the car.

This costs nothing on the emulator: the SAIC vehicle services are absent there,
so the vehicle calls fail regardless; the UI, layouts and navigation render,
which is the point of an emulator preview. The mise `run` task documents the
arrangement.

Verified by installing and launching the sibling MG4Tasker debug APK (same
sharedUserId, same overlay) on an API 33 automotive emulator: installs,
launches, renders at 1920x1080, no crash.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 app/src/debug/AndroidManifest.xml | 17 +++++++++++++++++
 mise.toml                         |  7 +++++--
 2 files changed, 22 insertions(+), 2 deletions(-)
 create mode 100644 app/src/debug/AndroidManifest.xml

diff --git a/app/src/debug/AndroidManifest.xml b/app/src/debug/AndroidManifest.xml
new file mode 100644
index 0000000..74cf911
--- /dev/null
+++ b/app/src/debug/AndroidManifest.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Debug-only overlay: remove sharedUserId so the debug APK installs on a stock
+  emulator with the ordinary debug key.
+
+  The app declares sharedUserId="android.uid.system" for vehicle access on the car,
+  which needs the platform signature. Emulators are signed with Google's own
+  (non-public) platform key, so neither a platform-signed nor a debug-key APK with
+  sharedUserId can install (INSTALL_FAILED_SHARED_USER_INCOMPATIBLE).
+
+  Stripping it here (debug only) costs nothing on the emulator: the SAIC vehicle
+  services are absent there, so vehicle calls fail regardless — UI, layouts and
+  navigation still render. Release builds keep sharedUserId untouched.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    tools:remove="android:sharedUserId" />
diff --git a/mise.toml b/mise.toml
index b6848d4..34d93ee 100644
--- a/mise.toml
+++ b/mise.toml
@@ -58,6 +58,7 @@ EMU_WIDTH = "1920"
 EMU_HEIGHT = "1080"
 EMU_DENSITY = "160"
 
+
 [tasks.bootstrap]
 description = "Installe le SDK Android (platform + build-tools) s'il manque"
 run = """
@@ -187,10 +188,12 @@ run = '''
 set -e
 ADB="$ANDROID_HOME/platform-tools/adb"
 if [ -z "$($ADB devices | sed '1d' | grep -w device || true)" ]; then
-  echo "Aucun appareil connecté. Lancer d'abord 'mise run emulator-car' ou 'mise run emulator-screen'," >&2
-  echo "ou brancher le véhicule en ADB." >&2
+  echo "Aucun appareil. Lancer 'mise run emulator-car'/'emulator-screen' ou brancher le véhicule." >&2
   exit 1
 fi
+# Les builds debug retirent sharedUserId (overlay src/debug/AndroidManifest.xml), donc la
+# clé debug suffit pour installer sur un émulateur. La release garde sharedUserId + signature
+# plateforme pour le véhicule.
 APK=$(ls -t app/build/outputs/apk/online/debug/*.apk | head -1)
 echo "Installation de $APK"
 $ADB install -r -g "$APK"