feat(lecteur): régler la vitesse, et la retrouver au lancement suivant

app/src/main/java/app/waveflow/MainActivity.kt

@@ -653,6 +653,7 @@ private fun WaveFlowRoot(
                 onStartSleepTimer = playerViewModel::startSleepTimer,
                 onCancelSleepTimer = playerViewModel::cancelSleepTimer,
                 onSleepTimerRemainingMs = playerViewModel::sleepTimerRemainingMs,
+                onSetPlaybackSpeed = playerViewModel::setPlaybackSpeed,
             )
         }
     }

app/src/main/java/app/waveflow/data/PreferencesStore.kt

@@ -3,12 +3,15 @@ package app.waveflow.data
 import android.content.Context
 import android.util.Log
 import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.MutablePreferences
 import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.edit
 import androidx.datastore.preferences.core.emptyPreferences
+import androidx.datastore.preferences.core.floatPreferencesKey
 import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.datastore.preferences.preferencesDataStore
 import app.waveflow.model.AppPreferences
+import app.waveflow.model.PlaybackSpeed
 import app.waveflow.model.ThemeChoice
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
@@ -32,6 +35,16 @@ interface PreferencesStore {
     val preferences: Flow<AppPreferences>
 
     suspend fun setTheme(choice: ThemeChoice)
+
+    /**
+     * Change la vitesse de lecture.
+     *
+     * Écrite ici et non posée sur le lecteur : c'est le service qui observe la
+     * préférence et l'applique, si bien que le réglage tient même quand aucun
+     * écran n'est ouvert — la lecture démarrée depuis Android Auto ou la
+     * notification part à la bonne vitesse.
+     */
+    suspend fun setPlaybackSpeed(speed: Float)
 }
 
 /**
@@ -87,27 +100,81 @@ class DataStorePreferencesStore(
         .catch { emit(emptyPreferences()) }
         .map { it.toAppPreferences() }
 
-    override suspend fun setTheme(choice: ThemeChoice) {
-        dataStore.edit { it[THEME] = choice.name }
+    override suspend fun setTheme(choice: ThemeChoice) =
+        ecrire("Thème") { it[THEME] = choice.name }
+
+    /**
+     * La vitesse est bornée à l'écriture **et** à la relecture.
+     *
+     * Aux deux bouts et non à un seul : borner en écrivant protège le fichier
+     * de ce que l'appelant apporte, borner en lisant protège l'application de
+     * ce que le fichier contient déjà — une version future aux bornes plus
+     * larges, ou un fichier abîmé.
+     */
+    override suspend fun setPlaybackSpeed(speed: Float) =
+        ecrire("Vitesse de lecture") { it[PLAYBACK_SPEED] = PlaybackSpeed.borner(speed) }
+
+    /**
+     * Écrit une préférence sans faire tomber celui qui la demande.
+     *
+     * L'échec d'écriture est retenu ici, comme l'est déjà celui de lecture. Les
+     * appelants lancent dans la portée de leur ViewModel, laquelle n'a pas de
+     * gestionnaire d'exception : un disque plein y ferait tomber l'application
+     * entière — pour un thème ou une vitesse de lecture. Le choix est alors
+     * simplement perdu, ce que l'écran dit de lui-même en restant sur l'ancienne
+     * valeur, le flux n'ayant rien émis.
+     *
+     * `IOException` et non tout le reste : une annulation traverse elle aussi
+     * `edit`, et l'avaler ferait survivre une écriture à la portée qui l'a
+     * demandée.
+     *
+     * @param quoi ce qu'on tentait d'enregistrer, pour que le journal dise
+     *   lequel des réglages a été perdu.
+     */
+    private suspend fun ecrire(quoi: String, transform: (MutablePreferences) -> Unit) {
+        try {
+            dataStore.edit(transform)
+        } catch (erreur: IOException) {
+            Log.w(TAG, "$quoi non enregistré", erreur)
+        }
     }
 
     /**
-     * Un nom de thème inconnu vaut le défaut.
+     * Ce que le fichier ne sait pas dire vaut le défaut.
      *
-     * Le cas se présente si une version future en ajoute un puis qu'on
-     * redescend : l'ancienne lit une valeur qu'elle ne connaît pas, et lever y
-     * rendrait l'application inutilisable.
+     * Un nom de thème inconnu, une vitesse hors bornes : le cas se présente si
+     * une version future en ajoute puis qu'on redescend, l'ancienne lisant
+     * alors une valeur qu'elle ne connaît pas. Lever ici rendrait
+     * l'application inutilisable pour un réglage d'apparence.
      */
-    private fun Preferences.toAppPreferences(): AppPreferences = AppPreferences(
-        theme = this[THEME]
-            ?.let { name -> ThemeChoice.entries.firstOrNull { it.name == name } }
-            ?: AppPreferences().theme,
-    )
+    private fun Preferences.toAppPreferences(): AppPreferences {
+        // Lues par la carte et non par `this[cle]`, dont le cast n'est pas
+        // vérifié : une clé portant un autre type que le sien y lève une
+        // `ClassCastException`. Elle surviendrait **après** le `catch`, posé en
+        // amont de cette conversion, et emporterait l'application dans la
+        // portée du ViewModel — pour une préférence. `as?` retombe sur le
+        // défaut sans rien lever, et sans terminer le flux : le fichier reste
+        // relu, si bien qu'un autre réglage change encore.
+        //
+        // Le cas se présente si une version future change le type d'une clé
+        // puis qu'on redescend.
+        val valeurs = asMap()
+
+        return AppPreferences(
+            theme = (valeurs[THEME] as? String)
+                ?.let { name -> ThemeChoice.entries.firstOrNull { it.name == name } }
+                ?: AppPreferences().theme,
+            playbackSpeed = (valeurs[PLAYBACK_SPEED] as? Float)
+                ?.let(PlaybackSpeed::borner)
+                ?: AppPreferences().playbackSpeed,
+        )
+    }
 
     private companion object {
         const val TAG = "PreferencesStore"
 
         val THEME = stringPreferencesKey("theme")
+        val PLAYBACK_SPEED = floatPreferencesKey("playback_speed")
 
         /** Trois reprises : de quoi passer un incident, pas une corruption. */
         const val MAX_TENTATIVES = 3L

app/src/main/java/app/waveflow/model/AppPreferences.kt

@@ -1,8 +1,15 @@
 package app.waveflow.model
 
-/** Ce que l'utilisateur a choisi, et qui survit à la fermeture de l'application. */
+/**
+ * Ce que l'utilisateur a choisi, et qui survit à la fermeture de l'application.
+ *
+ * @property playbackSpeed la vitesse de lecture. Elle se persiste parce qu'elle
+ *   décrit une habitude et non un geste : qui écoute ses podcasts à ×1,5 ne
+ *   veut pas le redire à chaque lancement. Voir [PlaybackSpeed] pour ses bornes.
+ */
 data class AppPreferences(
     val theme: ThemeChoice = ThemeChoice.System,
+    val playbackSpeed: Float = PlaybackSpeed.NORMALE,
 )
 
 /**

app/src/main/java/app/waveflow/model/PlaybackSpeed.kt

@@ -0,0 +1,80 @@
+package app.waveflow.model
+
+/**
+ * La vitesse de lecture, et ce qui la tient dans des limites raisonnables.
+ *
+ * Un nombre et non une énumération comme [ThemeChoice] : la vitesse est une
+ * grandeur continue, pas un choix parmi des noms. En faire un jeu de constantes
+ * obligerait à baptiser chaque palier, et interdirait d'ajouter un réglage plus
+ * fin sans réécrire ce qui est déjà sur le disque. [PROPOSEES] dit ce que
+ * l'interface offre aujourd'hui ; le format persisté, lui, ne s'y limite pas.
+ */
+object PlaybackSpeed {
+
+    /** La vitesse d'origine, celle du disque tel qu'il a été gravé. */
+    const val NORMALE = 1f
+
+    /**
+     * Les bornes du réglage.
+     *
+     * En dessous de la moitié, l'étirement temporel de Media3 rend une bouillie
+     * plutôt qu'un ralenti ; au-delà du double, plus personne ne suit une
+     * parole, et la musique n'y survit pas du tout.
+     */
+    const val MIN = 0.5f
+    const val MAX = 2f
+
+    /**
+     * Ce que la feuille de réglage propose.
+     *
+     * Des quarts entre l'unité et le double, là où se joue l'écoute d'une
+     * parole ; la moitié et les trois quarts en dessous, utiles pour repiquer
+     * un passage à l'instrument. Un pas plus fin ajouterait des lignes sans
+     * ajouter de choix : personne ne distingue ×1,4 de ×1,45.
+     */
+    val PROPOSEES = listOf(0.5f, 0.75f, 1f, 1.25f, 1.5f, 1.75f, 2f)
+
+    /**
+     * Ramène [speed] dans les bornes, et rend [NORMALE] de ce qui n'est pas un
+     * nombre.
+     *
+     * Ce n'est pas une précaution de style : la valeur vient du disque, donc
+     * potentiellement d'une version future qui aurait élargi les bornes, ou
+     * d'un fichier abîmé. Une vitesse nulle figerait la lecture sans rien dire,
+     * et un `NaN` — que `coerceIn` laisse passer tel quel — ferait lever Media3
+     * au moment de l'appliquer, loin de l'endroit où il a été lu.
+     */
+    fun borner(speed: Float): Float =
+        if (speed.isFinite()) speed.coerceIn(MIN, MAX) else NORMALE
+
+    /**
+     * La vitesse telle qu'elle s'écrit : « ×1 », « ×1,5 », « ×0,75 ».
+     *
+     * Formatée à la main plutôt qu'avec `String.format` : celui-ci suit la
+     * locale de l'appareil, qui décide aussi bien du séparateur décimal que du
+     * jeu de chiffres. L'interface est en français, la virgule y est donc
+     * constante — et les chiffres doivent le rester.
+     *
+     * Les zéros inutiles tombent : « ×1 » et non « ×1,00 », qui suggérerait une
+     * précision que le réglage n'offre pas.
+     */
+    fun format(speed: Float): String {
+        val centiemes = Math.round(borner(speed) * CENTIEMES)
+        val entier = centiemes / CENTIEMES
+        val reste = centiemes % CENTIEMES
+
+        val decimales = when {
+            reste == 0 -> ""
+            // ×1,50 s'écrit « ×1,5 » : le zéro final ne dit rien de plus.
+            reste % DIXIEMES == 0 -> ",${reste / DIXIEMES}"
+            // ×1,05 garde le sien, sans quoi il se lirait « ×1,5 ».
+            reste < DIXIEMES -> ",0$reste"
+            else -> ",$reste"
+        }
+
+        return "×$entier$decimales"
+    }
+
+    private const val CENTIEMES = 100
+    private const val DIXIEMES = 10
+}

app/src/main/java/app/waveflow/playback/PlaybackService.kt

@@ -13,12 +13,15 @@ import androidx.media3.session.MediaLibraryService
 import androidx.media3.session.MediaSession
 import app.waveflow.WaveFlowApp
 import app.waveflow.data.PlayHistoryRepository
+import app.waveflow.data.PreferencesStore
 import coil.imageLoader
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
 
 /**
@@ -106,6 +109,7 @@ class PlaybackService : MediaLibraryService() {
 
         player.addListener(historyListener(container.playHistoryRepository))
         observeSleepTimer(container.sleepTimer, player)
+        observePlaybackSpeed(container.preferencesStore, player)
 
         // Après la session, et pas avant : la première valeur du flux arrive
         // sans délai, et elle a des abonnés à prévenir.
@@ -130,6 +134,28 @@ class PlaybackService : MediaLibraryService() {
         }
     }
 
+    /**
+     * Applique la vitesse de lecture choisie, et la réapplique quand elle change.
+     *
+     * Observée ici plutôt que posée par l'écran de lecture : le service joue
+     * aussi quand aucun écran n'est ouvert — en voiture, depuis la notification
+     * — et une vitesse qui n'existerait qu'une fois le lecteur affiché
+     * retomberait à ×1 précisément dans ces cas-là. Le flux rend sa valeur
+     * courante dès l'abonnement, si bien que la lecture démarre à la bonne
+     * vitesse sans que personne ait à la redemander.
+     *
+     * `distinctUntilChanged` sur la seule vitesse : le flux porte toutes les
+     * préférences, et changer de thème n'a pas à traverser jusqu'au lecteur.
+     */
+    private fun observePlaybackSpeed(preferences: PreferencesStore, player: Player) {
+        artworkScope.launch {
+            preferences.preferences
+                .map { it.playbackSpeed }
+                .distinctUntilChanged()
+                .collect { player.setPlaybackSpeed(it) }
+        }
+    }
+
     /**
      * Note ce qu'on écoute, mais pas ce qu'on saute.
      *

app/src/main/java/app/waveflow/ui/player/NowPlayingScreen.kt

@@ -54,6 +54,7 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import app.waveflow.model.PlaybackSpeed
 import app.waveflow.model.orUnknownArtist
 import app.waveflow.playback.PlayingTrack
 import app.waveflow.playback.RepeatMode
@@ -83,6 +84,7 @@ fun NowPlayingScreen(
     onStartSleepTimer: (Long) -> Unit,
     onCancelSleepTimer: () -> Unit,
     onSleepTimerRemainingMs: () -> Long?,
+    onSetPlaybackSpeed: (Float) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     // Local et non remonté : voir la file est une façon de regarder le lecteur,
@@ -91,6 +93,7 @@ fun NowPlayingScreen(
 
     // Même raison : la feuille est un geste en cours, pas un état à conserver.
     var sleepSheetShown by rememberSaveable { mutableStateOf(false) }
+    var speedSheetShown by rememberSaveable { mutableStateOf(false) }
 
     // La file peut se vider pendant l'animation de fermeture : on continue
     // d'afficher le dernier morceau connu le temps que l'écran redescende,
@@ -125,6 +128,8 @@ fun NowPlayingScreen(
                 onToggleQueue = { queueShown = !queueShown },
                 sleepTimerActive = state.sleepTimerActive,
                 onOpenSleepTimer = { sleepSheetShown = true },
+                playbackSpeed = state.playbackSpeed,
+                onOpenPlaybackSpeed = { speedSheetShown = true },
             )
 
             if (queueShown) {
@@ -195,6 +200,17 @@ fun NowPlayingScreen(
                 onDismiss = { sleepSheetShown = false },
             )
         }
+
+        if (speedSheetShown) {
+            PlaybackSpeedSheet(
+                speed = state.playbackSpeed,
+                onPick = { vitesse ->
+                    onSetPlaybackSpeed(vitesse)
+                    speedSheetShown = false
+                },
+                onDismiss = { speedSheetShown = false },
+            )
+        }
     }
 }
 
@@ -207,6 +223,8 @@ private fun PlayerHeader(
     onToggleQueue: () -> Unit,
     sleepTimerActive: Boolean,
     onOpenSleepTimer: () -> Unit,
+    playbackSpeed: Float,
+    onOpenPlaybackSpeed: () -> Unit,
 ) {
     Row(
         modifier = Modifier.fillMaxWidth(),
@@ -238,6 +256,8 @@ private fun PlayerHeader(
             )
         }
 
+        PlaybackSpeedButton(speed = playbackSpeed, onClick = onOpenPlaybackSpeed)
+
         IconButton(onClick = onOpenSleepTimer) {
             Icon(
                 imageVector = Icons.Filled.Bedtime,
@@ -432,6 +452,42 @@ private fun PlayerControls(
     }
 }
 
+/**
+ * La vitesse de lecture : le bouton **est** son affichage.
+ *
+ * Le chiffre plutôt qu'une icône, contrairement à ses voisins. Une vitesse
+ * active et invisible est un défaut qu'on cherche longtemps — « pourquoi cette
+ * voix est-elle pressée ? » — et aucune icône ne dit ×1,5. Elle tient dans la
+ * même empreinte que les autres boutons de la rangée : `IconButton` et non
+ * `TextButton`, dont la largeur minimale creuserait un trou dans l'alignement.
+ *
+ * La teinte reprend la grammaire du reste de l'en-tête : accentuée quand le
+ * réglage s'écarte de l'ordinaire, éteinte sinon.
+ */
+@Composable
+private fun PlaybackSpeedButton(speed: Float, onClick: () -> Unit) {
+    val libelle = PlaybackSpeed.format(speed)
+    val ordinaire = speed == PlaybackSpeed.NORMALE
+
+    IconButton(
+        onClick = onClick,
+        // Le texte seul se lirait « fois un virgule cinq » sans qu'on sache de
+        // quoi ; la description dit la grandeur, et prend le pas sur lui.
+        modifier = Modifier.semantics { contentDescription = "Vitesse de lecture : $libelle" },
+    ) {
+        Text(
+            text = libelle,
+            style = MaterialTheme.typography.labelLarge,
+            maxLines = 1,
+            color = if (ordinaire) {
+                MaterialTheme.colorScheme.onSurfaceVariant
+            } else {
+                MaterialTheme.colorScheme.primary
+            },
+        )
+    }
+}
+
 /** Bouton secondaire dont la teinte signale l'état actif. */
 @Composable
 private fun ToggleControl(