Was wir bauen
Android 13 hat die Seek-Bar der Media-Benachrichtigung neu gezeichnet: Der
bereits abgespielte Teil der Spur wird als wellenförmige Sinuskurve
gezeichnet statt als gerade Linie, der noch nicht abgespielte Rest bleibt
flach, und das Ganze pendelt sich wieder zu einer geraden Linie ein,
sobald die Wiedergabe pausiert. Jede App, die eine MediaStyle-Benachrichtigung
postet, Spotify und YouTube Music eingeschlossen, bekommt dieselbe Optik
automatisch vom System.
Dafür gibt es keine fertige Composable. LinearProgressIndicator zeichnet
nur eine gerade Spur. Hier braucht es einen wellenförmigen Strich, der
nahtlos in einer Schleife läuft und sich mit fortschreitender Wiedergabe
auf eine exakte Position zuschneidet. Außerdem muss er sich auf Wunsch
abflachen lassen und dabei eine saubere, abgerundete Spitze behalten statt
einer abgeschnittenen Kante.
Vollständiger Quellcode: WavyLoaderScreen.kt.
Die Grundidee
- Die Welle braucht kein
sin(). Jede Halbperiode ist eine quadratische Bézier-Kurve in einem , bei der beide Endpunkte auf der Mittellinie liegen und ein Kontrollpunkt sie nach oben oder unten zieht. Alle vier Schritte unten nutzen genau diese gleiche Zwei-Kurven-Ausbuchtung wieder. - Das Zuschneiden der Welle auf eine exakte Spitze und das Aufteilen in abgespielten/nicht abgespielten Teil laufen beide auf dieselbe Frage hinaus: "Wo endet diese Bézier-Kurve gerade wirklich?" Schritt 3 beantwortet das einmal mit einer Formel zum Kurvensplitting. Schritt 4 nutzt dieselbe Antwort erneut, nur mit einer sich bewegenden Wiedergabeposition als Endpunkt statt eines festen.
StrokeCap.Roundrundet nur den tatsächlichen Endpunkt eines Pfads ab. Das Zuschneiden einer Welle auf ein Fenster beschneidet nur Pixel und lässt einen flachen Schnitt zurück; erst das Zuschneiden der Kurve selbst gibt der abgerundeten Kappe überhaupt ein echtes Kurvenende zum Abrunden.
- →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.
Schritt 1: Die Welle als Paare quadratischer Bézier-Kurven abtasten
// 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)
)
}Jede Welle besteht aus zwei quadraticTo-Aufrufen. Beide Kurven beginnen
und enden auf center.y, nur der Kontrollpunkt unterscheidet sich:
- Der Kontrollpunkt der ersten Kurve sitzt bei
center.y - amplitude * 2. Der Bildschirm-y-Wert wächst nach unten, also wölbt sich diese Hälfte nach oben. - Der Kontrollpunkt der zweiten Kurve sitzt bei
center.y + amplitude * 2, sie wölbt sich also nach unten und landet beiendXwieder aufcenter.y.
Der y-Versatz des Kontrollpunkts beträgt amplitude * 2, nicht
amplitude. Der Mittelpunkt einer quadratischen Bézier-Kurve liegt bei
der Hälfte des Versatzes des Kontrollpunkts von seinen Endpunkten,
daher führt erst das Verdoppeln des Kontrollpunkt-Versatzes dazu, dass
der tatsächliche visuelle Scheitelpunkt der Kurve amplitude entspricht.
Es werden WAVE_COUNT + 1 Wellen gebaut, eine mehr, als in den
clipRect passt. Diese zusätzliche Welle hängt über den rechten Rand
hinaus und wird vorerst weggeschnitten, sodass immer eine vollständige
Welle bereitsteht, um hereinzurutschen, sobald Schritt 2 diesen Pfad zu
scrollen beginnt.
Schritt 2: Die Welle mit einer animierten Phasenverschiebung in eine Schleife legen
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
}
}Das Subtrahieren eines animierten shift-Werts von jedem abgetasteten
x verschiebt das gesamte Wellenmuster nach links. Wird shift mit
infiniteRepeatable/RepeatMode.Restart von 0 auf eine waveLength
animiert, springt er alle 1000ms wieder auf 0 zurück.
Die Welle wiederholt sich alle waveLength, daher zeichnen shift = 0
und shift = waveLength innerhalb des clipRect-Fensters pixelidentische
Kurven. Der Sprung ist unsichtbar, weil es ein Sprung zwischen zwei
Frames ist, die gleich aussehen. Außerhalb des Fensters bewegen sich die
Enden des Pfads tatsächlich, was genau das ist, was der Clip verdecken
soll.
Schritt 3: Die Spitze exakt zuschneiden, ohne zu clippen
// 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)
}Die Schritte 1 und 2 beenden die Welle mit clipRect, und ein Clip
beschneidet nur Pixel. Der Pfad selbst läuft über das Fenster hinaus
weiter, sodass StrokeCap.Round nie einen Endpunkt zum Abrunden sieht.
Der Strich hört einfach abrupt an der geraden Kante des Fensters auf,
mitten in der Kurve, mit einem flachen Schnitt.
Um eine echte abgerundete Spitze zu bekommen, muss die Kurve selbst
exakt an der Grenze enden, was bedeutet, dass es eine andere, kürzere
Kurve sein muss, nicht eine beschnittene. Wiederholtes
zwischen den eigenen Punkten einer Bézier-Kurve bei einem Parameter t
ist , und so teilt man eine Kurve in zwei Kurven
auf, die jede für sich noch gültige Bézier-Kurven sind, mit einem
exakten gemeinsamen Punkt bei t.
trimQuadratic wendet diesen Split zweimal an: einmal bei t0, um den
Teil davor zu verwerfen, einmal bei t1, um den Teil danach zu
verwerfen.
Der zweite Split kann t1 allerdings nicht einfach so übernehmen. t1
war ein Bruchteil der ursprünglichen Kurve, aber bis der zweite Split
läuft, hat der erste Split sie bereits auf (tailP0, q1, p2) verkürzt.
t1Prime skaliert t1 neu gegen diesen kürzeren Rest, bevor der zweite
Split darauf läuft, und die Funktion gibt die drei Punkte dieses Rests
zurück.
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 und P2 in der Demo sind dieselben, gleichnamigen Parameter,
die trimQuadratic entgegennimmt: der feste Start-, Kontroll- und
Endpunkt der Kurve. Zieh an einem der beiden Griffe entlang der Kurve,
um t0 oder t1 festzulegen.
Die dünne Linie, die beim Ziehen aufleuchtet, ist Q0-Q1, das
Segment, entlang dessen der zweite Lerp läuft. Der Griff selbst ist der
Punkt, an dem dieser Lerp landet, tailP0 oder headP2, je nachdem,
welcher Griff bewegt wurde. Das durchgezogene mittlere Segment ist der
tatsächliche Rückgabewert von trimQuadratic, keine beschnittene Kopie
der ursprünglichen Kurve.
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)
}
}Die Zeichenschleife geht jede Halbwelle durch und berechnet t0/t1
als den Anteil von dieser Hälfte, der tatsächlich innerhalb von
[leftBound, rightBound] liegt. Eine Hälfte, die komplett innerhalb des
Fensters liegt, bekommt t0 = 0, t1 = 1, was bedeutet: "die ganze
Hälfte verwenden, nichts zuschneiden." Nur die eine oder zwei Hälften,
durch die eine Grenze tatsächlich hindurchschneidet, bekommen einen
echten Zuschnitt.
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
Diese Version verzichtet komplett auf clipRect. Der Pfad endet nun
wirklich bei leftBound und rightBound, sodass StrokeCap.Round
beide Enden exakt abrundet, in jeder Phase der Schleife.
Wie De Casteljaus Algorithmus eine Kurve tatsächlich splittet
Für eine quadratische Bézier-Kurve läuft das Auswerten der Kurve an
einem beliebigen t auf drei Lerps hinaus, in dieser Reihenfolge
ausgeführt:
lerp(p0, c, t), das Ergebnis heißtq0lerp(c, p2, t), das Ergebnis heißtq1lerp(q0, q1, t), die tatsächliche Position der Kurve beit
Die ersten beiden hängen nicht voneinander ab; beide blenden nur
zwischen den ursprünglichen drei Punkten. Der dritte ist derjenige, der
sie tatsächlich nutzt, indem er q0 und q1 miteinander blendet.
trimQuadratic führt genau dieselben ersten beiden Lerps aus und nennt
die Ergebnisse q0 und q1. Die ziehbare Demo oben zeigt sie bereits:
Q0-Q1 ist das dünne Segment, das beim Ziehen aufleuchtet.
Der Unterschied liegt darin, was danach passiert. Das Auswerten der
Kurve fasst q0 und q1 zu einem finalen Punkt zusammen und verwirft
sie. Das Splitten hört einen Lerp früher auf und behält sie, denn q0,
q1 und dieser finale geblendete Punkt, tailP0, sind selbst die drei
Kontrollpunkte einer neuen, kürzeren Bézier-Kurve.
Für jeden Split existieren zwei solche Tripel: (p0, q0, tailP0) deckt
die Kurve von 0 bis t ab, und (tailP0, q1, p2) deckt t bis 1
ab. Sie treffen sich exakt bei tailP0, weil dieser Punkt von Anfang an
durch das Zusammenblenden beider Hälften entstanden ist, nicht dadurch,
dass man einen Punkt auf der ursprünglichen Kurve gewählt hat und
gehofft hat, dass er passt. trimQuadratic behält immer nur das zweite
Tripel, da jeder Aufruf alles vor einem bestimmten t wegschneidet,
egal ob das das echte t0 oder das neu skalierte t1Prime ist.
Schritt 4: Abgespielten/nicht abgespielten Teil trennen und beim Pausieren abflachen
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))
}
}Das nutzt Schritt 3s exakten Zuschnitt unverändert weiter. Der einzige
Tausch ist die Zuschnittsgrenze: Die feste rightBound der Schleife
wird zu einer beweglichen progressX, angetrieben von einem eigenen
Animatable. Dieselbe Mathematik für die abgerundete Spitze erzeugt
jetzt eine Spitze, die mit fortschreitender Wiedergabe sichtbar wächst,
nicht nur einen statischen Schleifenrand.
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
)
}Der nicht abgespielte Rest ist einfach ein flaches drawLine von
progressX bis rightBound mit geringerer Alpha. Er wird
übersprungen, sobald progressX rightBound erreicht, denn eine Linie
mit Länge null rendert ihren StrokeCap.Round trotzdem als gefüllten
Punkt. Dieser Punkt bliebe an einer Bildschirmposition fixiert, während
der wellenförmige Teil weiter an ihm vorbeiläuft, was wie ein
Einrasten des Strichs wirken würde.
Das Pausieren beendet die Shift-Schleife (LaunchedEffect(isPlaying)
bricht seine alte Coroutine in dem Moment ab, in dem sich der Key
ändert) und lässt amplitude über ein kurzes Tween sanft gegen 0
laufen. Da die Ankerpunkte jeder Kurve bereits auf center.y liegen und
sich nur die Kontrollpunkte bewegen, degeneriert das Schrumpfen von
amplitude auf 0 den gesamten wellenförmigen Teil zu derselben
flachen Linie, die der nicht abgespielte Rest ohnehin schon war. Kein
separater Abflach-Pfad nötig.
Eine infiniteRepeatable fortsetzen
animateTo(targetValue, infiniteRepeatable(...)) legt das aktive
Initial-/Zielwert-Paar in dem Moment fest, in dem es aufgerufen wird,
und RepeatMode.Restart spielt genau dieses Paar für immer erneut ab
und springt dabei zurück zum initialen Wert des Aufrufs, nicht zu
0. Ein fest geschriebener waveLength-Zielwert funktioniert beim
ersten Mal, weil der Shift bei 0 beginnt. Jedes Fortsetzen nach einer
Pause startet stattdessen von dort, wo der Shift einfroren wurde, daher
muss das Ziel shiftAnimatable.value + waveLength verfolgen, nicht ein
fester Literalwert, sonst springt jede fortgesetzte Schleife auf eine
beliebige Phase, bei der sie zufällig pausiert wurde.
Varianten und Trade-offs
- Clipping vs. Zuschneiden. Schritt 2s
clipRectist ein einzelner Aufruf und kostet pro Kurve nichts zusätzlich. Das ist eine gute Wahl, wenn die Enden der Welle ohnehin verdeckt sind, unter einem Daumen oder bündig mit einer Containerkante. Eine abgerundete Spitze kann es aber nie erzeugen, weshalb die Schritte 3 und 4 stattdessen die Kurve selbst zuschneiden. - Die Abtastauflösung ist auf Wellen-, nicht auf Pixelebene fixiert.
Da jede Halbwelle eine einzige quadratische Kurve ist und keine Reihe
von Liniensegmenten, steuert
WAVE_COUNT, wie viele Ausbuchtungen hineinpassen, nicht wie glatt eine einzelne Ausbuchtung ist. Jede zusätzliche Welle kostet pro Frame zwei weiteretrimQuadratic-Aufrufe (einen pro Hälfte), nicht Hunderte zusätzliche Abtastpunkte, wie es bei einem auflineTobasierenden Ansatz wäre. PLAYBACK_DURATION_MILLISund die Geschwindigkeit der Shift-Schleife sind unabhängige Stellschrauben. Das 1000ms-pro-Wellenlänge-Tween der Welligkeit liestPLAYBACK_DURATION_MILLISnie. Wiedergabegeschwindigkeit und die eigene Laufgeschwindigkeit der Welle lassen sich separat abstimmen, ohne sich gegenseitig in die Mathematik zu pfuschen.- Fortsetzen lässt die Welle erst wieder wachsen, bevor sie sich
bewegt.
LaunchedEffect(isPlaying)wartet das 300ms-Amplituden-Tween ab, bevor es die Shift-Schleife und das Progress-Tween startet. Beim Fortsetzen wächst die Welle also erst eingefroren an Ort und Stelle zurück, bevor sie wieder zu scrollen beginnt. Das Amplituden-Tween in einem eigenenlaunch-Block starten, falls alle drei gleichzeitig starten sollen. - Der Punkt der Linie mit Länge null zeigt sich nur bei vollem
Fortschritt. Das macht es leicht, ihn zu übersehen, da die meisten
manuellen Tests mitten in der Wiedergabe stattfinden. Es lohnt sich,
gezielt beide Fortschrittsenden zu prüfen,
0und1, nicht nur die Mitte, immer wenn eine Leiste wie diese einen Strich in zwei unterschiedlich gestylte Segmente aufteilt.



