Window Screen Redesign + Preparation 2.6.7

Author: SliDeeN

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

@@ -129,25 +129,68 @@ object PowerWindows {
 
     private fun calKey(window: PowerWindow, part: String) = "win_cal_${window.name.lowercase(Locale.ROOT)}_$part"
 
-    fun calibration(context: Context, window: PowerWindow): WindowCalibration? {
+    private const val KEY_COURSE_MS = "win_course_ms"
+    private const val KEY_CAL_ADVANCED = "win_cal_advanced"
+
+    /** Durée de course retenue pour les vitres sans calibrage propre, lue une fois par le worker. */
+    @Volatile
+    private var courseMs = WindowCommand.DEFAULT_COURSE_MS
+
+    fun courseMs(context: Context): Long = WindowCommand.clampCourseMs(
+        context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            .getLong(KEY_COURSE_MS, WindowCommand.DEFAULT_COURSE_MS))
+
+    fun setCourseMs(context: Context, ms: Long) {
+        val valeur = WindowCommand.clampCourseMs(ms)
+        context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE).edit {
+            putLong(KEY_COURSE_MS, valeur)
+        }
+        courseMs = valeur
+        AppLogger.i(TAG, "durée de course : $valeur ms")
+    }
+
+    /**
+     * Calibrage par vitre, option avancée.
+     *
+     * Éteint, chaque vitre sans capteur suit la durée de course générale, **mais les mesures déjà
+     * faites restent enregistrées** : rallumer l'option les remet en service sans refaire
+     * l'assistant. À la première lecture, l'option s'allume d'elle-même si des mesures existent
+     * déjà — personne ne doit perdre sa précision à la mise à jour.
+     */
+    fun advancedCalibration(context: Context): Boolean {
+        val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        if (!prefs.contains(KEY_CAL_ADVANCED)) {
+            val dejaCalibre = PowerWindow.entries.any { storedCalibration(context, it) != null }
+            prefs.edit { putBoolean(KEY_CAL_ADVANCED, dejaCalibre) }
+            if (dejaCalibre) AppLogger.i(TAG, "calibrage existant : option avancée activée d'office")
+            return dejaCalibre
+        }
+        return prefs.getBoolean(KEY_CAL_ADVANCED, false)
+    }
+
+    fun setAdvancedCalibration(context: Context, on: Boolean) {
+        context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE).edit {
+            putBoolean(KEY_CAL_ADVANCED, on)
+        }
+        AppLogger.i(TAG, "calibrage par vitre ${if (on) "activé" else "désactivé"}")
+        // Les estimateurs portent la calibration : ils doivent repartir de la nouvelle règle.
+        reloadEstimators()
+    }
+
+    /** Mesures enregistrées pour cette vitre, sans tenir compte de l'option avancée. */
+    private fun storedCalibration(context: Context, window: PowerWindow): WindowCalibration? {
         if (window.hasPositionSensor) return null
         val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
         val down = prefs.getLong(calKey(window, "down_ms"), 0L)
         val up = prefs.getLong(calKey(window, "up_ms"), 0L)
         return WindowCalibration(down, up).takeIf { WindowCalibration.isValidMeasure(down) && WindowCalibration.isValidMeasure(up) }
     }
 
-    /** Enregistre la calibration ; l'assistant finit sur une montée complète, la vitre est donc fermée. */
-    /**
-     * Vitres sans capteur dont la calibration manque encore.
-     *
-     * Sert de garde-fou à la fermeture automatique : elle ferme au temps mesuré, une vitre non
-     * calibrée partirait sur la course par défaut sans que personne puisse le vérifier depuis
-     * l'extérieur de la voiture.
-     */
-    fun uncalibrated(context: Context): List<PowerWindow> =
-        PowerWindow.entries.filter { !it.hasPositionSensor && calibration(context, it) == null }
+    /** Calibrage réellement appliqué : null quand l'option avancée est éteinte. */
+    fun calibration(context: Context, window: PowerWindow): WindowCalibration? =
+        if (advancedCalibration(context)) storedCalibration(context, window) else null
 
+    /** Enregistre la calibration ; l'assistant finit sur une montée complète, la vitre est donc fermée. */
     fun saveCalibration(context: Context, window: PowerWindow, cal: WindowCalibration) {
         context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE).edit {
             putLong(calKey(window, "down_ms"), cal.downMs)
@@ -161,9 +204,19 @@ object PowerWindows {
      * Sur [worker] : charge une fois les calibrations enregistrées. Chaque vitre calibrée part fermée
      * (0 %) : cas le plus courant, sans exiger de course complète au démarrage de l'app.
      */
+    /** Relit calibrations et durée de course après un changement de réglage. */
+    private fun reloadEstimators() {
+        worker.post {
+            estimators.clear()
+            estimatorsLoaded = false
+            loadEstimators()
+        }
+    }
+
     private fun loadEstimators() {
         if (estimatorsLoaded) return
         val context = MG4Hardware.appContext() ?: return
+        courseMs = courseMs(context)
         PowerWindow.entries.forEach { w ->
             val cal = calibration(context, w) ?: return@forEach
             estimators[w] = WindowEstimator(cal).apply { setClosed() }
@@ -231,7 +284,7 @@ object PowerWindows {
      */
     fun closeForCalibration(window: PowerWindow) {
         lastAutoMs.remove(window)
-        worker.post { startAuto(window, Direction.UP, "calibration", minEmulatedMs = WindowCommand.EMULATED_COURSE_MS) }
+        worker.post { startAuto(window, Direction.UP, "calibration", minEmulatedMs = courseMs) }
     }
 
     /** Sur [worker]. Course automatique : native pour le conducteur, émulée pour les autres vitres. */
@@ -251,7 +304,7 @@ object PowerWindows {
      */
     private fun startEmulatedCourse(window: PowerWindow, direction: Direction, origin: String, minMs: Long = 0L) {
         loadEstimators()
-        val ms = maxOf(minMs, WindowCommand.emulatedCourseMs(direction, estimators[window]?.calibration))
+        val ms = maxOf(minMs, WindowCommand.emulatedCourseMs(direction, estimators[window]?.calibration, courseMs))
         val what = if (direction == Direction.UP) "fermeture" else "ouverture"
         startRepeat(window, WindowCommand.manual(direction), ms, finger = false, label = "$origin, $what auto émulée")
     }
@@ -354,7 +407,7 @@ object PowerWindows {
                     // Ajout APRÈS le démarrage : remplacer une course d'une séquence précédente ne
                     // doit pas compter comme l'interruption de celle-ci.
                     startRepeat(w, WindowCommand.MANUAL_UP,
-                        WindowCommand.emulatedCourseMs(Direction.UP, estimators[w]?.calibration),
+                        WindowCommand.emulatedCourseMs(Direction.UP, estimators[w]?.calibration, courseMs),
                         finger = false, label = origin, autoClose = true)
                     autoClosePending += w
                 }

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

@@ -49,8 +49,22 @@ object WindowCommand {
 
     /** Au-delà, un appui court n'est plus pris pour un « stop » : la course auto native est finie. */
     const val AUTO_TRAVEL_MS = 6_000L
-    /** Durée d'une course auto émulée tant que la vitre n'est pas calibrée. */
-    const val EMULATED_COURSE_MS = AUTO_TRAVEL_MS
+
+    /**
+     * Durée d'une course auto émulée pour une vitre sans calibrage propre — le cas normal.
+     *
+     * Cinq secondes : la valeur qu'emploie winclose sur MG4 sans jamais rien mesurer. Réglable par
+     * l'utilisateur, parce qu'une vitre arrière fatiguée est plus lente ; trop courte, elle reste
+     * entrouverte, et rien ne peut le signaler puisque l'application croit avoir fini.
+     */
+    const val DEFAULT_COURSE_MS = 5_000L
+    const val MIN_COURSE_MS = 2_000L
+    const val MAX_COURSE_MS = 10_000L
+    const val COURSE_STEP_MS = 500L
+
+    /** Ramène une durée saisie dans les bornes, sur un pas entier. */
+    fun clampCourseMs(ms: Long): Long =
+        (ms / COURSE_STEP_MS * COURSE_STEP_MS).coerceIn(MIN_COURSE_MS, MAX_COURSE_MS)
     /**
      * Plus grande position valide. Le service véhicule SWI68 rejette toute lecture au-delà
      * (`max_vehicle_window_get` = 100) ; en voiture, 127.5 et 255 restent figés sur les vitres
@@ -82,11 +96,15 @@ object WindowCommand {
     /** Position utilisable, ou null (illisible, ou valeur de remplacement d'une vitre sans capteur). */
     fun position(raw: Float?): Float? = raw?.takeIf { it in 0f..POSITION_MAX }
 
-    /** Durée d'une course émulée : la course calibrée dans ce sens si elle existe, sinon la valeur par défaut. */
-    fun emulatedCourseMs(direction: Direction, calibration: WindowCalibration?): Long = when (direction) {
+    /** Durée d'une course émulée : la course calibrée dans ce sens si elle existe, sinon [defaultMs]. */
+    fun emulatedCourseMs(
+        direction: Direction,
+        calibration: WindowCalibration?,
+        defaultMs: Long = DEFAULT_COURSE_MS,
+    ): Long = when (direction) {
         Direction.DOWN -> calibration?.emulatedOpenMs
         Direction.UP   -> calibration?.emulatedCloseMs
-    } ?: EMULATED_COURSE_MS
+    } ?: defaultMs
 
     /**
      * Une fermeture émulée n'a pas l'anti-pincement de la course native : elle ne continue que

app/src/main/java/com/mg4/control/ui/WindowAutoClosePanel.kt

@@ -22,7 +22,6 @@ class WindowAutoClosePanel {
 
     private var root: View? = null
     private var enableSwitch: Switch? = null
-    private var calNotice: TextView? = null
     private var paramsGroup: View? = null
     private var speedSwitch: Switch? = null
     private var timeSwitch: Switch? = null
@@ -59,18 +58,14 @@ class WindowAutoClosePanel {
         anyButton = view.findViewById(R.id.btn_win_auto_any)
         allButton = view.findViewById(R.id.btn_win_auto_all)
 
-        calNotice = view.findViewById(R.id.win_auto_cal_notice)
         paramsGroup = view.findViewById(R.id.row_win_auto_config)
         enableSwitch = view.findViewById<Switch>(R.id.switch_win_autoclose).apply {
             isChecked = WindowAutoClose.isEnabled(context)
             setOnCheckedChangeListener { sw, on ->
                 WindowAutoClose.setEnabled(sw.context, on)
-                // Option relâchée sans calibration complète : le verrou reprend la main.
-                refreshCalibrationGate()
                 render()
             }
         }
-        refreshCalibrationGate()
 
         val s = WindowAutoClose.settings(view.context)
         requireBoth = s.requireBoth
@@ -132,25 +127,6 @@ class WindowAutoClosePanel {
         beepVolume = beepSlider?.value?.toInt() ?: WindowAutoClose.BEEP_VOLUME_DEFAULT,
     )
 
-    /**
-     * Verrouille l'activation tant que les vitres sans capteur ne sont pas calibrées : la
-     * fermeture en quittant ne connaît la durée de course que par la calibration.
-     *
-     * Le verrou ne porte que sur l'ACTIVATION. Une option déjà active reste débrayable — sinon
-     * un utilisateur l'ayant activée avant ce garde-fou se retrouverait sans moyen de l'arrêter.
-     */
-    fun refreshCalibrationGate() {
-        val ctx = root?.context ?: return
-        val manquantes = PowerWindows.uncalibrated(ctx)
-        calNotice?.visibility = if (manquantes.isEmpty()) View.GONE else View.VISIBLE
-        if (manquantes.isNotEmpty()) calNotice?.text = ctx.getString(
-            R.string.win_auto_need_cal,
-            manquantes.joinToString(", ") { ctx.getString(WindowsPanel.nameRes(it)) })
-        val sw = enableSwitch ?: return
-        sw.isEnabled = manquantes.isEmpty() || sw.isChecked
-        sw.alpha = if (sw.isEnabled) 1f else 0.4f
-    }
-
     /** Un Slider refuse une valeur qui ne tombe pas sur un pas : on l'y ramène. */
     private fun beepStep(volume: Int): Int =
         (volume / WindowAutoClose.BEEP_VOLUME_STEP * WindowAutoClose.BEEP_VOLUME_STEP)

app/src/main/java/com/mg4/control/ui/WindowCalibrationPanel.kt

@@ -46,7 +46,6 @@ class WindowCalibrationPanel {
     private var save: MaterialButton? = null
 
     /** Prévenu après un enregistrement : la fermeture automatique en dépend pour se déverrouiller. */
-    var onCalibrationSaved: (() -> Unit)? = null
 
     private var window: PowerWindow? = null
     private var step = Step.CLOSE
@@ -110,7 +109,7 @@ class WindowCalibrationPanel {
             }
             val cal = PowerWindows.calibration(ctx, row.window)
             row.status.text = cal?.let { ctx.getString(R.string.win_cal_done, seconds(it.downMs), seconds(it.upMs)) }
-                ?: ctx.getString(R.string.win_cal_none)
+                ?: ctx.getString(R.string.win_cal_general)
             row.start.setText(if (cal != null) R.string.win_cal_redo_row else R.string.win_cal_start)
         }
     }
@@ -218,7 +217,6 @@ class WindowCalibrationPanel {
         Toast.makeText(ctx, R.string.win_cal_saved, Toast.LENGTH_SHORT).show()
         closeWizard("enregistrée")
         refreshRows()
-        onCalibrationSaved?.invoke()
     }
 
     private fun closeWizard(reason: String) {