O que vamos construir
O Android 13 redesenhou a barra de busca da notificação de mídia: a parte
já reproduzida da faixa é desenhada como uma onda senoidal ondulada em vez
de uma linha reta, o restante ainda não reproduzido permanece plano, e o
conjunto todo se estabiliza de volta em uma linha reta assim que a
reprodução é pausada. Qualquer app que publique uma notificação
MediaStyle, incluindo Spotify e YouTube Music, recebe a mesma aparência
de graça, vinda do sistema.
Não existe nenhum Composable pronto para nada disso. O LinearProgressIndicator
desenha uma única faixa reta. Isso exige um traço em forma de onda que faça
loop de forma contínua e seja cortado em uma posição exata conforme a
reprodução avança. Também precisa achatar sob demanda e manter uma ponta
bem arredondada em vez de uma borda cortada.
Código-fonte completo: WavyLoaderScreen.kt.
A intuição
- A onda não precisa de
sin(). Cada semiperíodo é uma única curva de Bézier quadrática em um , com ambas as extremidades na linha central e um ponto de controle puxando-a para cima ou para baixo. As quatro etapas abaixo reutilizam essa mesma elevação de duas curvas. - Cortar a onda para uma ponta exata e dividi-la entre reproduzido/não-reproduzido se reduzem à mesma pergunta: "onde essa curva de Bézier realmente termina, agora?" A etapa 3 responde isso uma vez com uma fórmula de divisão de curva. A etapa 4 reutiliza essa resposta com uma posição de reprodução em movimento no lugar de uma fixa como ponto final.
- O
StrokeCap.Roundsó arredonda a extremidade real de um path. Cortar uma onda em uma janela recorta pixels e deixa um corte plano por trás; cortar a própria curva é o que dá ao cap arredondado um fim de curva de fato para arredondar.
- →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.
Etapa 1: Amostrando a onda como curvas de Bézier quadráticas pareadas
// 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)
)
}Cada onda é duas chamadas de quadraticTo. Ambas as curvas começam e
terminam em center.y, apenas o ponto de controle difere:
- O ponto de controle da primeira curva fica em
center.y - amplitude * 2. Oyda tela cresce para baixo, então essa metade se projeta para cima. - O ponto de controle da segunda curva fica em
center.y + amplitude * 2, então ela se projeta para baixo e cai de volta emcenter.ynoendX.
O deslocamento y do ponto de controle é amplitude * 2, não amplitude.
O ponto médio de uma Bézier quadrática fica em metade do deslocamento do
ponto de controle em relação às suas extremidades, então dobrar o
deslocamento do controle é o que faz o pico visual real da curva ser
igual a amplitude.
São construídas WAVE_COUNT + 1 ondas, uma mais do que cabe dentro do
clipRect. Essa onda extra fica pendendo pela borda direita, cortada por
enquanto, de modo que sempre há uma onda completa pronta para deslizar
para dentro assim que a etapa 2 começar a rolar esse path.
Etapa 2: Fazendo a onda entrar em loop com um deslocamento de fase animado
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
}
}Subtrair um valor animado de shift de cada x amostrado desliza todo o
padrão de onda para a esquerda. Animar shift de 0 até um waveLength
com infiniteRepeatable/RepeatMode.Restart faz com que ele volte a 0
a cada 1000ms.
A onda se repete a cada waveLength, então, dentro da janela do
clipRect, shift = 0 e shift = waveLength desenham curvas
pixel-idênticas. O salto é invisível porque é um salto entre dois quadros
que têm a mesma aparência. Fora da janela, as extremidades do path se
movem de fato, que é exatamente o que o clip está ali para esconder.
Etapa 3: Cortando a ponta com exatidão, sem recortar
// 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)
}As etapas 1 e 2 terminam a onda com clipRect, e um clip só recorta
pixels. O próprio path continua além da janela, então o StrokeCap.Round
nunca vê uma extremidade para arredondar. O traço simplesmente para de
imediato na borda reta da janela, no meio da curva, com um corte plano.
Conseguir uma ponta de fato arredondada significa que a própria curva
precisa terminar exatamente no limite, o que significa que ela precisa
ser uma curva diferente, mais curta, não uma recortada. Aplicar
repetidamente
entre os próprios pontos de uma Bézier em um parâmetro t é o , e é assim que se divide uma curva em duas
curvas que ainda são Béziers válidas, com um ponto compartilhado exato em
t.
trimQuadratic aplica essa divisão duas vezes: uma em t0 para
descartar a parte antes dele, outra em t1 para descartar a parte depois
dele.
A segunda divisão, porém, não pode reutilizar t1 como está. t1 era
uma fração da curva original, mas, no momento em que a segunda divisão
roda, a primeira já a encurtou para (tailP0, q1, p2). t1Prime
reescala t1 em relação a esse remanescente mais curto antes de a
segunda divisão ser executada sobre ele, e a função retorna os três
pontos desse remanescente.
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 e P2 na demonstração são os mesmos parâmetros, com o mesmo
nome, que trimQuadratic recebe: o início, o controle e o fim fixos da
curva. Arraste qualquer um dos manipuladores ao longo da curva para
escolher t0 ou t1.
A linha fina que se acende durante o arraste é Q0-Q1, o segmento ao
longo do qual roda o segundo lerp. O próprio manipulador é onde esse lerp
cai, tailP0 ou headP2, dependendo de qual manipulador se moveu. O
segmento sólido do meio é o valor de retorno real de trimQuadratic, não
uma cópia recortada da curva original.
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)
}
}O loop de desenho percorre cada semi-onda e calcula t0/t1 como a
fração dessa metade que realmente cai dentro de [leftBound, rightBound]. Uma metade inteiramente dentro da janela recebe t0 = 0,
t1 = 1, o que significa "use a metade inteira, não corte nada". Apenas
a uma ou duas metades que um limite realmente atravessa recebem um corte
de verdade.
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
Esta versão descarta o clipRect por completo. O path agora de fato
termina em leftBound e rightBound, então o StrokeCap.Round arredonda
ambas as extremidades com exatidão, em qualquer fase do loop.
Como o algoritmo de De Casteljau realmente divide uma curva
Para uma Bézier quadrática, avaliar a curva em qualquer t se reduz a
três lerps, executados nesta ordem:
lerp(p0, c, t), chame o resultado deq0lerp(c, p2, t), chame o resultado deq1lerp(q0, q1, t), a posição real da curva emt
Os dois primeiros não dependem um do outro; ambos apenas misturam entre
os três pontos originais. O terceiro é o que de fato os usa, misturando
q0 e q1 juntos.
trimQuadratic executa esses mesmos dois primeiros lerps, nomeando os
resultados de q0 e q1. A demonstração arrastável acima já os mostra:
Q0-Q1 é o segmento fino que se acende durante o arraste.
A diferença está no que acontece depois. Avaliar a curva colapsa q0 e
q1 em um único ponto final e os descarta. Dividi-la para um lerp antes
e os mantém, porque q0, q1 e esse ponto final misturado, tailP0,
são eles próprios os três pontos de controle de uma nova Bézier, mais
curta.
Dois desses trios existem para cada divisão: (p0, q0, tailP0) cobre a
curva de 0 a t, e (tailP0, q1, p2) cobre de t a 1. Eles se
encontram exatamente em tailP0 porque esse ponto foi construído
misturando ambas as metades juntas desde o início, não escolhendo um
ponto na curva original e esperando que ele se alinhe. trimQuadratic
só mantém o segundo trio, já que toda chamada está descartando tudo
antes de algum t, seja esse o t0 real ou o t1Prime reescalado.
Etapa 4: Separando reproduzido/não-reproduzido e achatando ao pausar
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))
}
}Isso reutiliza o corte exato da etapa 3 sem alterações. A única troca é
o limite do corte: o rightBound fixo do loop se torna um progressX
em movimento, controlado por seu próprio Animatable. A mesma matemática
de ponta arredondada agora produz uma ponta que visivelmente cresce
conforme a reprodução avança, não apenas uma borda estática de loop.
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
)
}O restante não reproduzido é apenas um drawLine plano de progressX
até rightBound com um alpha mais baixo. Ele é pulado assim que
progressX alcança rightBound, porque uma linha de comprimento zero
ainda renderiza seu StrokeCap.Round como um ponto preenchido. Esse
ponto fica fixo em uma posição de tela enquanto a parte ondulada
continua fazendo loop além dele, o que soa visualmente como o traço
encaixando no lugar.
Pausar desmonta o loop de shift (LaunchedEffect(isPlaying) cancela sua
coroutine anterior no instante em que a chave muda) e suaviza a
amplitude em direção a 0 ao longo de um tween curto. As extremidades
de cada curva já ficam fixas em center.y, apenas os pontos de controle
se movem, então encolher amplitude até 0 degenera toda a parte
ondulada na mesma linha plana que o restante não reproduzido já era.
Nenhum caminho de achatamento separado é necessário.
Retomando um infiniteRepeatable
animateTo(targetValue, infiniteRepeatable(...)) fixa qualquer par
inicial/alvo que estiver ativo no momento em que é chamado, e
RepeatMode.Restart reproduz esse par exato para sempre, voltando ao
valor inicial da chamada, não a 0. Um alvo literal waveLength
funciona na primeira vez, já que o shift começa em 0. Toda retomada
após uma pausa começa de onde o shift ficou congelado, então o alvo
precisa acompanhar shiftAnimatable.value + waveLength, não um literal
fixo, ou todo loop retomado se encaixa em qualquer fase arbitrária em que
tenha pausado.
Variações e contrapartidas
- Recortar vs. cortar. O
clipRectda etapa 2 é uma única chamada e não custa nada extra por curva. É uma boa escolha quando as extremidades da onda ficam escondidas de qualquer forma, sob um polegar ou alinhadas à borda de um container. Nunca pode produzir uma ponta arredondada, porém, por isso as etapas 3 e 4 cortam a curva em vez disso. - A resolução de amostragem é fixa no nível da onda, não no nível do
pixel. Como cada semi-onda é uma única curva quadrática, não uma
sequência de segmentos de linha,
WAVE_COUNTcontrola quantas elevações cabem, não quão suave é qualquer uma delas. Cada onda extra custa duas chamadas adicionais detrimQuadraticpor quadro (uma por metade), não centenas de pontos de amostra extras como aconteceria numa abordagem baseada emlineTo. PLAYBACK_DURATION_MILLISe a velocidade do loop de shift são controles independentes. O tween de ondulação de 1000ms por comprimento de onda nunca lêPLAYBACK_DURATION_MILLIS. A velocidade de reprodução e a velocidade de deslocamento da própria onda podem ser ajustadas separadamente sem afetar a matemática uma da outra.- Retomar faz a onda crescer de volta antes de se mover.
LaunchedEffect(isPlaying)espera o tween de amplitude de 300ms terminar antes de iniciar o loop de shift e o tween de progresso. Então, ao retomar, a onda cresce de volta congelada no lugar e só então começa a rolar. Inicie o tween de amplitude em seu próprio blocolaunchtambém, se os três devem começar juntos. - O ponto de linha de comprimento zero só aparece no progresso total.
Isso faz com que seja fácil publicar e fácil de passar despercebido em
uma verificação rápida, já que a maior parte dos testes manuais
acontece no meio da reprodução. Vale a pena verificar deliberadamente
ambos os extremos de progresso,
0e1, não apenas o meio, sempre que uma barra como essa divide um traço em dois segmentos com estilos diferentes.



