Recomposed
Draw

Draw : la barre de progression ondulée des médias d'Android

Oct 24, 2026 · 11 min read

Draw : la barre de progression ondulée des médias d'Android

Ce que nous construisons

Android 13 a redessiné la barre de défilement des notifications médias : la portion déjà jouée de la piste se dessine comme une onde sinusoïdale ondulée au lieu d'une ligne droite, le reste non joué reste plat, et l'ensemble revient à une ligne droite dès que la lecture est en pause. Toute application qui publie une notification MediaStyle, Spotify et YouTube Music inclus, obtient gratuitement le même rendu grâce au système.

FIG. 01
La vraie version : la barre de défilement des notifications médias d'Android dessinée comme une onde sinueuse pendant la lecture d'une piste.

Il n'existe aucun Composable natif pour tout cela. LinearProgressIndicator dessine une seule piste droite. Il faut ici un trait en forme d'onde qui boucle de façon continue et se rogne à une position exacte à mesure que la lecture avance. Il doit aussi s'aplatir à la demande tout en gardant une pointe proprement arrondie plutôt qu'un bord coupé.

Code source complet : WavyLoaderScreen.kt.

L'intuition

  • L'onde n'a pas besoin de sin(). Chaque demi-période est une courbe de Bézier quadratique dans un , avec les deux extrémités sur la ligne centrale et un point de contrôle qui la tire vers le haut ou vers le bas. Les quatre étapes ci-dessous réutilisent toutes cette même bosse à deux courbes.
  • Rogner l'onde jusqu'à une pointe exacte et la diviser en portion jouée/non jouée se résument tous deux à la même question : « où cette courbe de Bézier se termine-t-elle réellement, à cet instant précis ? » L'étape 3 y répond une fois pour toutes avec une formule de découpe de courbe. L'étape 4 réutilise cette réponse avec une position de lecture mobile comme extrémité, au lieu d'une position fixe.
  • StrokeCap.Round n'arrondit que le véritable point final d'un path. Rogner une onde dans une fenêtre découpe des pixels et laisse une coupe plate derrière ; c'est le fait de rogner la courbe elle-même qui donne à la pointe arrondie une véritable extrémité de courbe à arrondir.

Étape 1 : échantillonner l'onde avec des paires de courbes de Bézier quadratiques

// crop the drawing to exactly WAVE_COUNT waves wide
clipRect(
    left = 0f,
    top = center.y - (amplitude * 2),
    right = (waveLength * WAVE_COUNT),
    bottom = center.y + (amplitude * 2)
) {
    val path = Path().apply {
        moveTo(0f, center.y)
 
        repeat(WAVE_COUNT + 1) { idx ->
            val quarterWaveLength = waveLength / 4
            val startX = (waveLength * idx)
            val endX = waveLength * (idx + 1)
            val midPointX = startX + (endX - startX) / 2
            val controlPoint1 = Offset(
                x = startX + quarterWaveLength,
                y = center.y - (amplitude * 2)
            )
            val controlPoint2 = Offset(
                x = midPointX + quarterWaveLength,
                y = center.y + (amplitude * 2)
            )
            quadraticTo(x1 = controlPoint1.x, y1 = controlPoint1.y, x2 = midPointX, y2 = center.y)
            quadraticTo(x1 = controlPoint2.x, y1 = controlPoint2.y, x2 = endX, y2 = center.y)
        }
    }
 
    drawPath(
        path = path,
        color = theme.primary,
        style = Stroke(width = WAVE_WIDTH.toPx(), cap = StrokeCap.Round)
    )
}
FIG. 02
WaveStatic : un seul Path, deux appels à quadraticTo par bosse, rien d'animé encore.

Chaque onde est constituée de deux appels à quadraticTo. Les deux courbes commencent et finissent sur center.y, seul le point de contrôle diffère :

  • Le point de contrôle de la première courbe se situe à center.y - amplitude * 2. Le y de l'écran augmente vers le bas, donc cette moitié bombe vers le haut.
  • Le point de contrôle de la seconde courbe se situe à center.y + amplitude * 2, donc elle bombe vers le bas et retombe sur center.y à endX.

Le décalage en y du point de contrôle est amplitude * 2, pas amplitude. Le point médian d'une courbe de Bézier quadratique se situe à la moitié du décalage du point de contrôle par rapport à ses extrémités, donc doubler ce décalage est ce qui fait que le véritable sommet visuel de la courbe soit égal à amplitude.

WAVE_COUNT + 1 ondes sont construites, une de plus que ce qui tient dans le clipRect. Cette onde supplémentaire déborde du bord droit, rognée pour l'instant, afin qu'il y ait toujours une onde complète prête à glisser dès que l'étape 2 commencera à faire défiler ce path.

Étape 2 : boucler l'onde avec un déphasage animé

val shiftAnimatable = remember { Animatable(0f) }
 
LaunchedEffect(Unit) {
    shiftAnimatable.animateTo(
        targetValue = waveLength,
        animationSpec = infiniteRepeatable(
            animation = tween(durationMillis = 1000, easing = LinearEasing),
            repeatMode = RepeatMode.Restart
        )
    )
}
 
// same clipRect and path-building loop as Step 1, now offset by the animated shift
val path = Path().apply {
    moveTo(0f - shiftAnimatable.value, center.y)
    repeat(WAVE_COUNT + 1) { idx ->
        val startX = (waveLength * idx) - shiftAnimatable.value
        val endX = waveLength * (idx + 1) - shiftAnimatable.value
        // ...same control points and quadraticTo calls as Step 1
    }
}
FIG. 03
L'onde défile en continu. La boucle de phase est parfaite, il n'y a aucun saut visible au point de raccord.

Soustraire une valeur shift animée à chaque x échantillonné fait glisser tout le motif d'onde vers la gauche. Animer shift de 0 à une waveLength avec infiniteRepeatable/RepeatMode.Restart le fait revenir brusquement à 0 toutes les 1000 ms.

L'onde se répète toutes les waveLength, donc à l'intérieur de la fenêtre du clipRect, shift = 0 et shift = waveLength dessinent des courbes identiques pixel pour pixel. Le saut est invisible parce que c'est un saut entre deux images qui se ressemblent. En dehors de la fenêtre, les extrémités du path bougent bel et bien, ce qui est précisément ce que le clip est censé masquer.

Étape 3 : rogner la pointe exactement, sans découper

// blends a and b by fraction t: t=0 returns a, t=1 returns b
private fun lerp(a: Offset, b: Offset, t: Float): Offset =
    Offset(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t)
 
// De Casteljau split: returns the control points of quadratic Bézier (p0, c, p2)
// restricted to the parameter range [t0, t1], reparameterized back to [0, 1].
private fun trimQuadratic(
    p0: Offset, c: Offset, p2: Offset,
    t0: Float, t1: Float,
): Triple<Offset, Offset, Offset> {
    val q0 = lerp(p0, c, t0)
    val q1 = lerp(c, p2, t0)
    val tailP0 = lerp(q0, q1, t0)
    if (t1 >= 1f) return Triple(tailP0, q1, p2)
 
    val t1Prime = (t1 - t0) / (1f - t0)
    val s0 = lerp(tailP0, q1, t1Prime)
    val s1 = lerp(q1, p2, t1Prime)
    val headP2 = lerp(s0, s1, t1Prime)
    return Triple(tailP0, s0, headP2)
}

Les étapes 1 et 2 terminent l'onde avec clipRect, et un clip ne fait que découper des pixels. Le path lui-même continue au-delà de la fenêtre, donc StrokeCap.Round ne voit jamais d'extrémité à arrondir. Le trait s'arrête net sur le bord droit de la fenêtre, en plein milieu de la courbe, avec une coupe plate.

Obtenir une véritable pointe arrondie suppose que la courbe elle-même se termine exactement à la limite, ce qui signifie qu'il faut une courbe différente, plus courte, pas une courbe rognée. de façon répétée entre les points d'une courbe de Bézier à un paramètre t est , et c'est ainsi qu'on découpe une courbe en deux courbes qui restent chacune des Béziers valides, avec un point partagé exact en t.

trimQuadratic applique cette découpe deux fois : une fois à t0 pour retirer la partie qui précède, une fois à t1 pour retirer la partie qui suit.

La seconde découpe ne peut cependant pas réutiliser t1 tel quel. t1 était une fraction de la courbe originale, mais au moment où la seconde découpe s'exécute, la première a déjà raccourci la courbe en (tailP0, q1, p2). t1Prime recalibre t1 par rapport à ce reste plus court avant que la seconde découpe ne s'y applique, et la fonction renvoie les trois points de ce reste.

trimQuadratic
0408012016020024028004080120160P0CP2

drag either handle along the curve — trimmed from t=0.25 to t=0.72

trimQuadratic(
    p0 = Offset(20f, 150f), c = Offset(150f, 30f), p2 = Offset(280f, 150f),
    t0 = 0.25f, t1 = 0.72f,
)

P0, C et P2 dans la démo sont les mêmes paramètres que ceux que trimQuadratic reçoit : le point de départ fixe de la courbe, son point de contrôle et son point final. Faites glisser l'une ou l'autre poignée le long de la courbe pour choisir t0 ou t1.

La ligne fine qui s'illumine pendant le glissement est Q0-Q1, le segment le long duquel s'exécute le second lerp. La poignée elle-même est l'endroit où ce lerp aboutit, tailP0 ou headP2 selon la poignée déplacée. Le segment plein au milieu est la valeur réellement renvoyée par trimQuadratic, pas une copie rognée de la courbe originale.

repeat(WAVE_COUNT + 1) { idx ->
    val segmentStart = (waveLength * idx) - shiftAnimatable.value
 
    // each full wave is two quadratic halves: dip down, then rise back up
    for (half in 0..1) {
        val halfStart = segmentStart + half * halfWaveLength
        val halfEnd = halfStart + halfWaveLength
        if (halfEnd <= leftBound || halfStart >= rightBound) continue
 
        val controlYOffset = if (half == 0) -amplitude * 2 else amplitude * 2
        val p0 = Offset(halfStart, center.y)
        val c = Offset(halfStart + quarterWaveLength, center.y + controlYOffset)
        val p2 = Offset(halfEnd, center.y)
 
        val t0 = if (halfStart < leftBound) (leftBound - halfStart) / halfWaveLength else 0f
        val t1 = if (halfEnd > rightBound) (rightBound - halfStart) / halfWaveLength else 1f
 
        val (trimmedP0, trimmedC, trimmedP2) = trimQuadratic(p0, c, p2, t0, t1)
 
        if (!started) {
            path.moveTo(trimmedP0.x, trimmedP0.y)
            started = true
        }
        path.quadraticTo(trimmedC.x, trimmedC.y, trimmedP2.x, trimmedP2.y)
    }
}

La boucle de dessin parcourt chaque demi-onde et calcule t0/t1 comme la fraction de cette moitié-là qui tombe réellement à l'intérieur de [leftBound, rightBound]. Une moitié entièrement à l'intérieur de la fenêtre obtient t0 = 0, t1 = 1, ce qui signifie « utiliser la moitié en entier, ne rien rogner ». Seules la ou les deux moitiés qu'une limite traverse réellement reçoivent un vrai rognage.

trim loop

t0=0 t1=0.22 the highlighted half-wave is the only one actually trimmed; every other curve passes trimQuadratic unchanged

every half-wave above passes through trimQuadratic, but only the highlighted one gets a real trim: the rest come back as t0=0, t1=1, unchanged

FIG. 04
La boucle d'onde avec le rognage exact appliqué. Les deux extrémités restent arrondies à chaque phase de la boucle, là où le clipRect de l'étape 2 laissait une coupe plate.

Cette version abandonne complètement le clipRect. Le path se termine désormais réellement à leftBound et rightBound, donc StrokeCap.Round arrondit exactement les deux extrémités, à n'importe quelle phase de la boucle.

Comment l'algorithme de De Casteljau découpe réellement une courbe

Pour une courbe de Bézier quadratique, évaluer la courbe à un t quelconque revient à trois lerps, exécutés dans cet ordre :

  • lerp(p0, c, t), appelons le résultat q0
  • lerp(c, p2, t), appelons le résultat q1
  • lerp(q0, q1, t), la position réelle de la courbe à t

Les deux premiers ne dépendent pas l'un de l'autre ; ils se contentent tous deux de mélanger les trois points originaux. Le troisième est celui qui les exploite réellement, en mélangeant q0 et q1 ensemble.

trimQuadratic exécute exactement ces deux premiers lerps, en nommant les résultats q0 et q1. La démo interactive ci-dessus les montre déjà : Q0-Q1 est le segment fin qui s'illumine pendant le glissement.

La différence tient à ce qui se passe ensuite. Évaluer la courbe fond q0 et q1 en un seul point final et les jette. La découper s'arrête un lerp plus tôt et les conserve, car q0, q1, et ce point final mélangé, tailP0, sont eux-mêmes les trois points de contrôle d'une nouvelle courbe de Bézier plus courte.

Deux de ces triplets existent pour chaque découpe : (p0, q0, tailP0) couvre la courbe de 0 à t, et (tailP0, q1, p2) couvre de t à 1. Ils se rejoignent exactement en tailP0 parce que ce point a été construit en mélangeant les deux moitiés ensemble dès le départ, et non en choisissant un point sur la courbe originale en espérant qu'il s'aligne. trimQuadratic ne conserve jamais que le second triplet, puisque chaque appel retire tout ce qui précède un certain t, qu'il s'agisse du véritable t0 ou du t1Prime recalibré.

Étape 4 : séparer joué/non joué et aplatir à la pause

var isPlaying by remember { mutableStateOf(true) }
val shiftAnimatable = remember { Animatable(0f) }
val amplitudeAnimatable = remember { Animatable(fullAmplitude) }
val progressAnimatable = remember { Animatable(0f) }
 
LaunchedEffect(isPlaying) {
    if (isPlaying) {
        amplitudeAnimatable.animateTo(fullAmplitude, animationSpec = tween(300))
 
        launch {
            shiftAnimatable.animateTo(
                targetValue = shiftAnimatable.value + waveLength,
                animationSpec = infiniteRepeatable(
                    animation = tween(durationMillis = 1000, easing = LinearEasing),
                    repeatMode = RepeatMode.Restart
                )
            )
        }
 
        val remainingMillis = ((1f - progressAnimatable.value) * PLAYBACK_DURATION_MILLIS).toInt()
        progressAnimatable.animateTo(
            targetValue = 1f,
            animationSpec = tween(durationMillis = remainingMillis.coerceAtLeast(1), easing = LinearEasing)
        )
    } else {
        amplitudeAnimatable.animateTo(0f, animationSpec = tween(300))
    }
}

Ceci réutilise sans changement le rognage exact de l'étape 3. Le seul changement est la limite de rognage : le rightBound fixe de la boucle devient un progressX mobile, piloté par son propre Animatable. Les mêmes mathématiques de pointe arrondie produisent désormais une pointe qui grandit visiblement à mesure que la lecture avance, pas seulement un bord de boucle statique.

val progressX = leftBound + progressAnimatable.value * (rightBound - leftBound)
 
// ...same trimQuadratic loop as Step 3, culled and trimmed against
// progressX instead of rightBound...
 
drawPath(path = wavyPath, color = theme.primary, style = Stroke(WAVE_WIDTH.toPx(), cap = StrokeCap.Round))
 
// Skipped once progress reaches the end: a zero-length line still
// renders its StrokeCap.Round as a filled dot, pinned at rightBound
// forever while the wavy portion keeps animating past it.
if (progressX < rightBound) {
    drawLine(
        color = theme.primary.copy(alpha = 0.3f),
        start = Offset(progressX, center.y),
        end = Offset(rightBound, center.y),
        strokeWidth = WAVE_WIDTH.toPx(),
        cap = StrokeCap.Round
    )
}

Le reste non joué n'est qu'un drawLine plat allant de progressX à rightBound, avec une alpha plus faible. Il est ignoré dès que progressX atteint rightBound, car une ligne de longueur nulle rend quand même son StrokeCap.Round sous forme de point plein. Ce point resterait figé à une position fixe de l'écran tandis que la portion ondulée continuerait de boucler devant lui, ce qui se lirait comme un trait qui se téléporte en place.

FIG. 05
La lecture fait avancer la pointe ondulée et le reste atténué se réduit ; la mise en pause aplatit toute la barre ; la reprise la fait regrandir et la boucle continue à partir de la même phase.

La mise en pause arrête la boucle de décalage (LaunchedEffect(isPlaying) annule son ancienne coroutine dès que la clé change) et fait glisser l'amplitude vers 0 via un court tween. Les points d'ancrage de chaque courbe se trouvent déjà tous sur center.y, seuls les points de contrôle se déplacent, donc réduire amplitude à 0 fait dégénérer toute la portion ondulée vers la même ligne plate que le reste non joué l'était déjà. Aucun chemin d'aplatissement séparé n'est nécessaire.

Reprendre un infiniteRepeatable

animateTo(targetValue, infiniteRepeatable(...)) fige la paire valeur initiale/cible active au moment de l'appel, et RepeatMode.Restart rejoue cette paire exacte indéfiniment, en revenant à la valeur initiale de l'appel, pas à 0. Une cible littérale waveLength fonctionne la première fois, puisque le shift démarre à 0. Chaque reprise après une pause repart de l'endroit où le shift était figé, donc la cible doit suivre shiftAnimatable.value + waveLength, pas un littéral fixe, sous peine que chaque boucle reprise ne saute brusquement vers la phase arbitraire sur laquelle elle s'était mise en pause.

Variantes et compromis

  • Découpage vs rognage. Le clipRect de l'étape 2 ne coûte qu'un seul appel et rien de plus par courbe. C'est un bon choix quand les extrémités de l'onde sont cachées de toute façon, sous un pouce ou à ras du bord d'un conteneur. Il ne peut en revanche jamais produire une pointe arrondie, ce pour quoi les étapes 3 et 4 rognent plutôt la courbe.
  • La résolution d'échantillonnage est fixée au niveau de l'onde, pas du pixel. Comme chaque demi-onde est une seule courbe quadratique, pas une suite de segments de ligne, WAVE_COUNT contrôle combien de bosses tiennent, pas à quel point une bosse donnée est lisse. Chaque onde supplémentaire coûte deux appels de plus à trimQuadratic par image (un par moitié), pas des centaines de points d'échantillonnage supplémentaires comme le ferait une approche basée sur lineTo.
  • PLAYBACK_DURATION_MILLIS et la vitesse de la boucle de décalage sont des réglages indépendants. Le tween d'ondulation de 1000 ms par longueur d'onde ne lit jamais PLAYBACK_DURATION_MILLIS. La vitesse de lecture et la vitesse de déplacement propre à l'onde peuvent être ajustées séparément sans que l'une touche aux calculs de l'autre.
  • La reprise fait regrandir l'onde avant qu'elle ne se déplace. LaunchedEffect(isPlaying) attend la fin du tween d'amplitude de 300 ms avant de lancer la boucle de décalage et le tween de progression. Donc, à la reprise, l'onde regrandit figée sur place, puis commence à défiler. Lancez aussi le tween d'amplitude dans son propre bloc launch si les trois doivent démarrer ensemble.
  • Le point de ligne de longueur nulle n'apparaît qu'à la progression complète. Cela le rend facile à livrer et facile à manquer lors d'une vérification rapide, puisque la plupart des tests manuels se déroulent en milieu de lecture. Il vaut la peine de vérifier délibérément les deux extrémités de la progression, 0 et 1, pas seulement le milieu, chaque fois qu'une barre comme celle-ci divise un trait en deux segments stylisés différemment.
Keep reading

Related reads

Recevez les nouveaux articles par e-mail