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.
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.Roundn'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.
- →Traveling Wave Phase: Turning Position and Time Into One AngleThe phase math (position + time → one angle) the shift-as-phase trick in Step 2 is built on, generalized beyond a single scrolling line.
- →Quadratic vs Cubic Bezier vs Arc: Picking the Right Path CurveWhy quadraticTo is the right curve type for a wave's dip-then-rise shape, and when a cubic or arc would be the better call instead.
- →animate*AsState vs Animatable: Animation Is Just an Interpolated ValueWhy this post calls Animatable.animateTo directly inside a coroutine instead of animate*AsState, letting amplitude, shift, and progress stage and cancel independently.
É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)
)
}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. Leyde 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 surcenter.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
}
}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.
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.
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
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ésultatq0lerp(c, p2, t), appelons le résultatq1lerp(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.
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
clipRectde 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_COUNTcontrôle combien de bosses tiennent, pas à quel point une bosse donnée est lisse. Chaque onde supplémentaire coûte deux appels de plus àtrimQuadraticpar image (un par moitié), pas des centaines de points d'échantillonnage supplémentaires comme le ferait une approche basée surlineTo. PLAYBACK_DURATION_MILLISet 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 jamaisPLAYBACK_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 bloclaunchsi 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,
0et1, pas seulement le milieu, chaque fois qu'une barre comme celle-ci divise un trait en deux segments stylisés différemment.



