Recomposed
Draw

Zeichnen: Androids wellenförmige Media-Fortschrittsanzeige

Oct 24, 2026 · 10 min read

Zeichnen: Androids wellenförmige Media-Fortschrittsanzeige

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.

FIG. 01
Das Original: Androids Seek-Bar in der Media-Benachrichtigung, gezeichnet als wellenförmige Kurve, während ein Track abgespielt wird.

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.Round rundet 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.

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)
    )
}
FIG. 02
WaveStatic: ein Path, zwei quadraticTo-Aufrufe pro Ausbuchtung, noch nichts animiert.

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 bei endX wieder auf center.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
    }
}
FIG. 03
Die kontinuierlich scrollende Welle. Die Phasenschleife ist nahtlos, am Umbruchpunkt ist kein Sprung sichtbar.

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.

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 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.

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
Die in der Schleife laufende Welle mit angewendetem exaktem Zuschnitt. Beide Enden bleiben in jeder Phase der Schleife abgerundet, wo Schritt 2s clipRect einen flachen Schnitt zurückließ.

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ßt q0
  • lerp(c, p2, t), das Ergebnis heißt q1
  • lerp(q0, q1, t), die tatsächliche Position der Kurve bei t

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.

FIG. 05
Die Wiedergabe lässt die wellenförmige Spitze vorrücken und der gedimmte Rest schrumpft; Pausieren flacht die ganze Leiste ab; Fortsetzen lässt sie wieder wachsen, und die Schleife läuft ab derselben Phase weiter.

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 clipRect ist 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 weitere trimQuadratic-Aufrufe (einen pro Hälfte), nicht Hunderte zusätzliche Abtastpunkte, wie es bei einem auf lineTo basierenden Ansatz wäre.
  • PLAYBACK_DURATION_MILLIS und die Geschwindigkeit der Shift-Schleife sind unabhängige Stellschrauben. Das 1000ms-pro-Wellenlänge-Tween der Welligkeit liest PLAYBACK_DURATION_MILLIS nie. 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 eigenen launch-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, 0 und 1, nicht nur die Mitte, immer wenn eine Leiste wie diese einen Strich in zwei unterschiedlich gestylte Segmente aufteilt.
Keep reading

Related reads

Neue Beiträge direkt in dein Postfach