@@ -239,7 +239,7 @@ class MainActivity : AppCompatActivity() {
         val btnProfiles  = findViewById<MaterialButton>(R.id.btn_nav_profiles)
         val btnSettings  = findViewById<MaterialButton>(R.id.btn_nav_settings)
 
-        // Bouton Audio : contrôle vendor caradapter dispo uniquement sur A9 → masqué ailleurs.
+        // Bouton Audio : visible partout où le volume média est pilotable (ancien SDK et A9).
         if (MG4Hardware.hasAudioControl()) {
             btnAudio.setOnClickListener {
                 when (navController.currentDestination?.id) {
 
@@ -365,7 +365,7 @@ object MG4Hardware {
         // 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()
+        if (hasDoorDetection()) connectCarProperty()
 
         AppLogger.i(TAG, "========================================")
     }
@@ -3565,7 +3565,7 @@ object MG4Hardware {
         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. */
+    /** Onglet Audio (baisse de volume en quittant la voiture) : partout où le volume est pilotable. */
     fun hasAudioControl(): Boolean = hasDoorVolumeFeature()
 
     private const val DESCRIPTOR_CARADAPTER = "com.saicmotor.carapi.ICarAdapterService"
@@ -4741,13 +4741,20 @@ object MG4Hardware {
         }
     }
 
-    /** 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 {
+    /** Détection réelle de l'ouverture des portes (DLOCK_DOOR_OPEN_STS via CarPropertyManager) :
+     *  lisible uniquement sur SWI132 et SWI133 ; ailleurs le prop n'est pas exposé à l'app. */
+    fun hasDoorDetection(): Boolean {
         val gen = FirmwareInfo.getGeneration()
         return gen == FirmwareInfo.Gen.SWI132 || gen == FirmwareInfo.Gen.SWI133
     }
 
+    /**
+     * Baisse du volume en quittant la voiture : partout où le volume média est pilotable (ancien SDK
+     * et A9). Déclencheur : la porte là où elle est lisible ([hasDoorDetection]), sinon la sortie du
+     * mode READY en P ([ReadyWatcher]), qui correspond sur MG4 à l'ouverture de la porte conducteur.
+     */
+    fun hasDoorVolumeFeature(): Boolean = isOldSdkSound() || isA9Sound()
+
     private fun doorVolumeEnabled(): Boolean {
         // Mode Garage : une portière qui fait chuter le volume est exactement le genre de
         // comportement inexpliqué qu'on ne veut pas laisser observer.
@@ -4779,19 +4786,79 @@ object MG4Hardware {
     fun startDoorVolumeWatcher() {
         if (!hasDoorVolumeFeature()) return
         sDoorWatcherOn = true
-        connectCarProperty()
+        if (hasDoorDetection()) connectCarProperty() else ReadyWatcher.add(readyVolumeListener)   // add idempotent
     }
 
     fun stopDoorVolumeWatcher() {
         sDoorWatcherOn = false           // poll conservé ; on ne déclenche plus la baisse
+        if (!hasDoorDetection()) ReadyWatcher.remove(readyVolumeListener)
         AppLogger.i(TAG, "  DoorVolumeWatcher: déclenchement désactivé")
     }
 
+    /**
+     * Firmwares sans porte lisible : sortie de READY en P = départ du conducteur → baisse ; retour en
+     * READY → restauration si l'utilisateur l'a choisie. La sortie à l'extinction voiture occupée baisse
+     * aussi le volume (accepté). Rapport illisible : on baisse quand même (aucun risque, au contraire
+     * des vitres). Le premier état connu n'est pas une transition, sauf pour une restauration en
+     * attente (écran redémarré entre la baisse et le retour en READY).
+     */
+    private val readyVolumeListener = ReadyWatcher.Listener { ready, firstRead ->
+        if (!sDoorWatcherOn) return@Listener
+        if (ready) {
+            restoreMediaVolumeAfterDrop(if (firstRead) "READY à l'activation" else "retour en READY")
+            return@Listener
+        }
+        if (firstRead) return@Listener
+        if (!doorVolumeEnabled()) return@Listener   // inclut le Mode Garage
+        val inPark = isVehicleInPark()
+        if (inPark == false) {
+            AppLogger.i(DOORWATCH_TAG, "sortie de READY hors P → volume inchangé")
+            return@Listener
+        }
+        dropMediaVolumeForExit("sortie de READY (P=${inPark ?: "illisible"})")
+    }
+
+    /** Volume avant la baisse, gardé en préférences : la restauration survit à un redémarrage de l'écran. */
+    private const val KEY_VOLUME_BEFORE_DROP = "door_volume_before_drop"
+
+    private fun dropMediaVolumeForExit(origin: String) {
+        val level = doorVolumeLevel()
+        CoroutineScope(Dispatchers.IO).launch {
+            val before = getMediaVolume()
+            sVolumeBeforeDrop = before
+            if (before >= 0) sAppContext?.getSharedPreferences("mg4_settings", 0)?.edit()
+                ?.putInt(KEY_VOLUME_BEFORE_DROP, before)?.apply()
+            val ok = setMediaVolume(level)
+            AppLogger.i(DOORWATCH_TAG, "$origin → vol $before→$level = $ok")
+        }
+    }
+
+    private fun restoreMediaVolumeAfterDrop(origin: String) {
+        val prefs = sAppContext?.getSharedPreferences("mg4_settings", 0)
+        val restore = sVolumeBeforeDrop.takeIf { it >= 0 } ?: prefs?.getInt(KEY_VOLUME_BEFORE_DROP, -1) ?: -1
+        sVolumeBeforeDrop = -1
+        prefs?.edit()?.remove(KEY_VOLUME_BEFORE_DROP)?.apply()
+        if (restore < 0) return
+        if (!doorRestoreEnabled()) {
+            AppLogger.i(DOORWATCH_TAG, "$origin → restauration désactivée (volume laissé tel quel)")
+            return
+        }
+        CoroutineScope(Dispatchers.IO).launch {
+            val ok = setMediaVolume(restore)
+            AppLogger.i(DOORWATCH_TAG, "$origin → restauration vol $restore = $ok")
+        }
+    }
+
     /** 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()
+        if (!hasDoorDetection()) {
+            AppLogger.i(DOORWATCH_TAG, "DIAG pas de porte lisible sur ${FirmwareInfo.getGeneration()} → READY brut = " +
+                "${readEptReadyRaw() ?: "illisible"} (surveillance ${if (ReadyWatcher.ready != null) "active" else "inactive"})")
+            return
+        }
         connectCarProperty()   // idempotent ; normalement déjà connecté depuis l'init
         registerDoorCallback() // re-tente la souscription si pas encore posée
         probeDoorSnapshot()
@@ -5562,21 +5629,9 @@ object MG4Hardware {
         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")
-            }
+            dropMediaVolumeForExit("porte ouverte")
         } 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")
-                }
-            }
+            restoreMediaVolumeAfterDrop("porte fermée")
         }
         sAnyFrontOpenPrev = anyOpen
     }
 
@@ -0,0 +1,85 @@
+package com.mg4.control.hardware
+
+import android.os.Handler
+import android.os.Looper
+import com.mg4.control.debug.AppLogger
+import com.mg4.control.model.WindowAutoCloseTrigger
+import com.mg4.control.util.FirmwareInfo
+
+/**
+ * Observateur partagé de l'état READY (`SENSOR_EPTRDY`), lisible sur les 6 firmwares
+ * ([MG4Hardware.readEptReadyRaw]). Sur MG4, la voiture sort de READY quand la porte conducteur
+ * s'ouvre en P (et à l'extinction) : c'est le signal de « départ du conducteur » là où la porte
+ * elle-même n'est pas lisible.
+ *
+ * Une seule lecture par seconde, quel que soit le nombre d'abonnés (fermeture auto des vitres,
+ * baisse de volume) ; la lecture s'arrête sans abonné. Tout se passe sur le fil principal.
+ * Journal : tag [TAG], valeur brute à chaque changement.
+ */
+object ReadyWatcher {
+
+    const val TAG = "MG4_READY"
+    private const val TICK_MS = 1_000L
+
+    fun interface Listener {
+        /**
+         * [firstRead] vrai pour le premier état connu (lecture initiale, ou abonnement alors que l'état
+         * est déjà connu) : ce n'est pas une transition, l'abonné décide s'il en tient compte.
+         */
+        fun onReadyChanged(ready: Boolean, firstRead: Boolean)
+    }
+
+    private val main = Handler(Looper.getMainLooper())
+    private val listeners = LinkedHashSet<Listener>()
+    private var rawRead = false
+    private var lastRaw: Int? = null
+
+    /** Dernier état connu ; null tant que READY n'a pas été lu (ou si la surveillance est arrêtée). */
+    @Volatile var ready: Boolean? = null
+        private set
+
+    fun add(listener: Listener) {
+        main.post {
+            if (!listeners.add(listener)) return@post
+            ready?.let { listener.onReadyChanged(it, firstRead = true) }
+            if (listeners.size == 1) {
+                main.post(tick)
+                AppLogger.i(TAG, "surveillance READY active (${FirmwareInfo.getGeneration()})")
+            }
+        }
+    }
+
+    fun remove(listener: Listener) {
+        main.post {
+            if (!listeners.remove(listener) || listeners.isNotEmpty()) return@post
+            main.removeCallbacks(tick)
+            ready = null
+            rawRead = false
+            lastRaw = null
+            AppLogger.i(TAG, "surveillance READY arrêtée (plus d'abonné)")
+        }
+    }
+
+    private val tick = object : Runnable {
+        override fun run() {
+            if (listeners.isEmpty()) return
+            poll()
+            main.postDelayed(this, TICK_MS)
+        }
+    }
+
+    private fun poll() {
+        val raw = MG4Hardware.readEptReadyRaw()
+        if (!rawRead || raw != lastRaw) {
+            AppLogger.i(TAG, "READY brut ${if (rawRead) lastRaw ?: "illisible" else "?"} → ${raw ?: "illisible"}")
+            rawRead = true
+            lastRaw = raw
+        }
+        // Illisible ou hors 0/1 : on garde le dernier état connu, sans fausse transition.
+        val newReady = WindowAutoCloseTrigger.readyFromRaw(raw) ?: return
+        val previous = ready
+        if (previous == newReady) return
+        ready = newReady
+        listeners.toList().forEach { it.onReadyChanged(newReady, firstRead = previous == null) }
+    }
+}
@@ -16,10 +16,10 @@ import com.mg4.control.util.GarageMode
  * Option « Fermer les vitres en quittant la voiture » : branche [WindowAutoCloseTrigger] (logique
  * de winclose) sur les signaux du véhicule, et lance [PowerWindows.closeAllAutomatically].
  *
- * Signaux, lus chaque seconde sur le fil principal (l'état du déclencheur n'a donc qu'un fil) :
- * état READY ([MG4Hardware.readEptReadyRaw], disponible sur les 6 firmwares — la porte conducteur,
- * elle, ne l'est pas), vitesse (tant que non armé), rapport P (seulement à la sortie de READY et
- * pendant le délai : sa lecture journalise).
+ * Signaux, sur le fil principal (l'état du déclencheur n'a donc qu'un fil) : état READY via
+ * l'observateur partagé [ReadyWatcher] (6 firmwares — la porte conducteur, elle, ne l'est pas),
+ * vitesse lue chaque seconde tant que non armé, rapport P (seulement à la sortie de READY et pendant
+ * le délai : sa lecture journalise).
  *
  * Démarré par le service au boot si l'option est active, ou par l'onglet Vitres à l'activation.
  * Respecte le Mode Garage. Journal : tag [PowerWindows.TAG].
@@ -69,8 +69,6 @@ object WindowAutoClose {
     private val main = Handler(Looper.getMainLooper())
     private val trigger = WindowAutoCloseTrigger()
     private var running = false
-    private var lastReadyRaw: Int? = null
-    private var ready: Boolean? = null
     private var lastResult: Result? = null
     private var lastResultAt = 0L
 
@@ -119,7 +117,7 @@ object WindowAutoClose {
     }
 
     fun status(context: Context): Status =
-        Status(isEnabled(context), trigger.isArmed, ready, lastResult, lastResultAt)
+        Status(isEnabled(context), trigger.isArmed, ReadyWatcher.ready, lastResult, lastResultAt)
 
     private fun apply(s: Settings) {
         trigger.arming = s.toArming()
@@ -152,9 +150,8 @@ object WindowAutoClose {
             if (running) return@post
             running = true
             apply(s)
-            lastReadyRaw = null
-            ready = null
             PowerWindows.prepare()
+            ReadyWatcher.add(readyListener)
             main.post(tick)
             AppLogger.i(TAG, "fermeture auto : surveillance active sur ${FirmwareInfo.getGeneration()} (${describe(s)})")
         }
@@ -165,6 +162,7 @@ object WindowAutoClose {
             if (!running) return@post
             running = false
             main.removeCallbacks(tick)
+            ReadyWatcher.remove(readyListener)
             if (trigger.cancelPending()) {
                 setResult(Result.CANCELLED)
                 AppLogger.i(TAG, "fermeture auto : attente abandonnée (option désactivée)")
@@ -174,7 +172,6 @@ object WindowAutoClose {
 
     private fun onTick() {
         val now = SystemClock.elapsedRealtime()
-        readReady(now)
         val wasArmed = trigger.isArmed
         // Vitesse inutile une fois armé ; rapport lu seulement pendant l'attente (sa lecture journalise).
         val speed = if (wasArmed) null else MG4Hardware.getVehicleSpeedKmh()
@@ -184,25 +181,18 @@ object WindowAutoClose {
         handle(outcome)
     }
 
-    /** Lit READY et transmet ses changements au déclencheur ; la valeur brute est journalisée à chaque changement. */
-    private fun readReady(now: Long) {
-        val raw = MG4Hardware.readEptReadyRaw()
-        if (raw != lastReadyRaw) {
-            AppLogger.i(TAG, "fermeture auto : READY brut ${lastReadyRaw ?: "?"} → ${raw ?: "illisible"}")
-            lastReadyRaw = raw
-        }
-        val newReady = WindowAutoCloseTrigger.readyFromRaw(raw) ?: return   // illisible / invalide : on garde l'état connu
-        val previous = ready
-        ready = newReady
-        if (previous == newReady) return
+    /** Changements de READY (valeur brute journalisée par [ReadyWatcher], tag MG4_READY). */
+    private val readyListener = ReadyWatcher.Listener { ready, firstRead ->
+        if (!running) return@Listener
+        val now = SystemClock.elapsedRealtime()
         when {
-            newReady -> {
+            ready -> {
                 val outcome = trigger.onReady(now)
                 AppLogger.i(TAG, "fermeture auto : passage en READY → ${outcome.action} (${outcome.reason})")
                 handle(outcome)
             }
-            // Première lecture hors READY (option activée voiture éteinte) : pas une sortie de READY.
-            previous == null -> AppLogger.i(TAG, "fermeture auto : voiture hors READY à l'activation")
+            // Premier état connu hors READY (option activée voiture éteinte) : pas une sortie de READY.
+            firstRead -> AppLogger.i(TAG, "fermeture auto : voiture hors READY à l'activation")
             else -> onReadyLost(now)
         }
     }
 
@@ -7,6 +7,7 @@ import android.view.View
 import android.view.ViewGroup
 import android.widget.CheckBox
 import android.widget.Switch
+import android.widget.TextView
 import androidx.fragment.app.Fragment
 import androidx.lifecycle.lifecycleScope
 import com.google.android.material.slider.Slider
@@ -25,7 +26,7 @@ class AudioFragment : Fragment() {
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
         super.onViewCreated(view, savedInstanceState)
 
-        // ── Volume à l'ouverture d'une porte (SWI132/133) ───────────────────
+        // ── Volume en quittant la voiture : porte (SWI132/133) ou sortie de READY (autres) ──
         setupDoorVolume(view)
     }
 
@@ -43,6 +44,15 @@ class AudioFragment : Fragment() {
         val cbLeft  = view.findViewById<CheckBox>(R.id.cb_door_left)
         val cbRight = view.findViewById<CheckBox>(R.id.cb_door_right)
 
+        // Sans porte lisible, le déclencheur est la sortie de READY : il ne concerne que le conducteur
+        // (pas de choix de porte) et la restauration se fait au retour en READY.
+        if (!MG4Hardware.hasDoorDetection()) {
+            view.findViewById<TextView>(R.id.door_volume_desc_text).setText(R.string.door_volume_desc_ready)
+            view.findViewById<TextView>(R.id.door_volume_restore_label).setText(R.string.door_volume_restore_ready_title)
+            view.findViewById<View>(R.id.door_volume_doors_label).visibility = View.GONE
+            view.findViewById<View>(R.id.door_volume_doors_row).visibility = View.GONE
+        }
+
         val enabled = prefs.getBoolean("door_volume_enabled", false)
         toggle.isChecked  = enabled
         restore.isChecked = prefs.getBoolean("door_volume_restore", false)