Recomposed
Draw

그리기: 안드로이드의 꿈틀거리는 미디어 진행 바

Oct 24, 2026 · 3 min read

그리기: 안드로이드의 꿈틀거리는 미디어 진행 바

우리가 만드는 것

안드로이드 13은 미디어 알림 탐색 바를 다시 그렸습니다. 트랙의 재생된 부분은 직선 대신 꿈틀거리는 사인파로 그려지고, 아직 재생되지 않은 나머지 부분은 평평하게 유지되며, 재생이 일시 중지되는 즉시 전체가 직선으로 되돌아갑니다. MediaStyle 알림을 게시하는 모든 앱, Spotify와 YouTube Music을 포함해서, 시스템으로부터 같은 모습을 공짜로 얻게 됩니다.

FIG. 01
실제 모습: 트랙이 재생되는 동안 꿈틀거리는 파형으로 그려진 안드로이드의 미디어 알림 탐색 바.

이것을 구현해 줄 기본 Composable은 없습니다. LinearProgressIndicator는 하나의 직선 트랙만 그립니다. 이번에는 매끄럽게 반복되고 재생이 진행됨에 따라 정확한 위치로 트리밍되는 파형 스트로크가 필요합니다. 또한 필요에 따라 평평해져야 하고, 잘려나간 가장자리 대신 깔끔하게 둥근 끝을 유지해야 합니다.

전체 소스: WavyLoaderScreen.kt.

직관적인 이해

  • 파형에 sin()이 필요하지 않습니다. 각 반주기는 안의 하나의 2차 베지어 곡선이며, 양 끝점은 중심선 위에 있고 하나의 제어점이 그것을 위나 아래로 끌어당깁니다. 아래의 네 단계 모두 이 동일한 두 곡선짜리 봉우리를 재사용합니다.
  • 파형을 정확한 끝으로 트리밍하는 것과 재생됨/재생안됨으로 나누는 것은 둘 다 같은 질문으로 귀결됩니다: "이 베지어 곡선은 바로 지금, 실제로 어디서 끝나는가?" 3단계는 곡선 분할 공식으로 그 질문에 한 번 답합니다. 4단계는 고정된 끝 대신 움직이는 재생 위치를 끝으로 사용해 그 답을 재사용합니다.
  • StrokeCap.Round는 경로의 실제 끝점만 둥글게 만듭니다. 파형을 윈도우로 클리핑하면 픽셀만 잘려나가고 뒤에 평평한 절단면이 남습니다. 곡선 자체를 트리밍해야 둥근 캡이 실제로 둥글게 처리할 곡선 끝을 갖게 됩니다.

1단계: 짝지은 2차 베지어로 파형 샘플링하기

// 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: 하나의 Path, 봉우리마다 두 번의 quadraticTo 호출, 아직 애니메이션은 없음.

모든 파형은 두 번의 quadraticTo 호출입니다. 두 곡선 모두 center.y에서 시작하고 끝나며, 제어점만 다릅니다:

  • 첫 번째 곡선의 제어점은 center.y - amplitude * 2에 위치합니다. 화면의 y는 아래로 증가하므로, 이 절반은 위로 부풀어 오릅니다.
  • 두 번째 곡선의 제어점은 center.y + amplitude * 2에 위치하므로, 아래로 부풀어 오르다가 endX에서 다시 center.y로 돌아옵니다.

제어점의 y 오프셋은 amplitude가 아니라 amplitude * 2입니다. 2차 베지어 곡선의 중간점은 제어점이 끝점으로부터 벗어난 거리의 절반에 위치하므로, 제어 오프셋을 두 배로 하는 것이 곡선의 실제 시각적 정점을 amplitude와 같게 만드는 방법입니다.

WAVE_COUNT + 1개의 파형이 만들어지며, clipRect 안에 들어가는 개수보다 하나 더 많습니다. 그 여분의 파형은 오른쪽 가장자리에 걸쳐 있으며, 지금은 잘려나가지만, 2단계가 이 경로를 스크롤하기 시작하면 항상 미끄러져 들어올 완전한 파형이 준비되어 있게 됩니다.

2단계: 애니메이션 위상 이동으로 파형 반복시키기

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
계속해서 스크롤되는 파형. 위상 루프는 매끄러워서, 되돌아가는 지점에서 눈에 보이는 점프가 없습니다.

매번 샘플링된 x에서 애니메이션되는 shift 값을 빼면 전체 파형 패턴이 왼쪽으로 미끄러집니다. infiniteRepeatable/RepeatMode.Restart로 shift를 0에서 하나의 waveLength까지 애니메이션시키면 1000ms마다 0으로 되돌아 점프합니다.

파형은 waveLength마다 반복되므로, clipRect 윈도우 안에서는 shift = 0과 shift = waveLength가 픽셀 단위로 동일한 곡선을 그립니다. 그 점프가 보이지 않는 이유는 똑같이 보이는 두 프레임 사이의 점프이기 때문입니다. 윈도우 바깥에서는 경로의 끝이 실제로 움직이는데, 바로 그것을 숨기기 위해 클립이 존재합니다.

3단계: 클리핑 없이 끝을 정확하게 트리밍하기

// 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)
}

1단계와 2단계는 clipRect로 파형을 끝내지만, 클립은 픽셀만 잘라낼 뿐입니다. 경로 자체는 윈도우를 지나서도 계속되므로, StrokeCap.Round는 둥글게 처리할 끝점을 전혀 보지 못합니다. 스트로크는 윈도우의 직선 가장자리에서, 곡선 중간에서, 평평한 절단면과 함께 그냥 멈춰버립니다.

실제로 둥근 끝을 얻으려면 곡선 자체가 경계에서 정확히 끝나야 하며, 이는 잘려나간 것이 아니라 다른, 더 짧은 곡선이어야 한다는 뜻입니다. 매개변수 t에서 베지어 곡선 자체의 점들 사이를 반복적으로 하는 것은 이며, 이것이 바로 곡선을 여전히 유효한 베지어 곡선인 두 개의 곡선으로, t에서 정확히 공유되는 점을 가지고 분할하는 방법입니다.

trimQuadratic은 그 분할을 두 번 적용합니다: 한 번은 t0에서 그 이전 부분을 버리기 위해, 한 번은 t1에서 그 이후 부분을 버리기 위해.

하지만 두 번째 분할은 t1을 그대로 재사용할 수 없습니다. t1은 원래 곡선의 비율이었지만, 두 번째 분할이 실행될 때쯔음에는 첫 번째 분할이 이미 그것을 (tailP0, q1, p2)로 짧게 줄여 놓았습니다. t1Prime은 두 번째 분할이 그 위에서 실행되기 전에 t1을 그 더 짧아진 나머지에 맞춰 재조정하고, 함수는 그 나머지의 세 점을 반환합니다.

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, P2는 trimQuadratic이 받는 동일한 이름의 매개변수, 즉 곡선의 고정된 시작점, 제어점, 끝점입니다. 두 핸들 중 하나를 곡선을 따라 드래그해서 t0 또는 t1을 선택하세요.

드래그하는 동안 밝아지는 얇은 선은 Q0-Q1이며, 두 번째 보간이 따라 움직이는 선분입니다. 핸들 자체는 어느 핸들이 움직였는지에 따라 그 보간이 도달하는 지점, tailP0 또는 headP2입니다. 중간의 굵은 선분이 trimQuadratic의 실제 반환값이며, 원래 곡선을 잘라낸 복사본이 아닙니다.

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)
    }
}

그리기 루프는 각 반파를 순회하며 [leftBound, rightBound] 안에 실제로 들어가는 그 반파의 비율로 t0/t1을 계산합니다. 윈도우 안에 완전히 들어가는 반파는 t0 = 0, t1 = 1을 받는데, 이는 "전체 반파를 사용하고, 아무것도 트리밍하지 않는다"는 뜻입니다. 경계가 실제로 가로지르는 하나 또는 두 개의 반파만 진짜로 트리밍됩니다.

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
정확한 트리밍이 적용된 반복 파형. 2단계의 clipRect가 평평한 절단면을 남겼던 자리에서, 루프의 모든 위상에서 양 끝이 둥글게 유지됩니다.

이 버전은 clipRect를 완전히 제거합니다. 경로는 이제 leftBound와 rightBound에서 실제로 끝나므로, StrokeCap.Round는 루프의 어느 위상에서도 양 끝을 정확하게 둥글게 처리합니다.

드 카스텔조 알고리즘이 실제로 곡선을 분할하는 방법

2차 베지어 곡선의 경우, 임의의 t에서 곡선을 평가하는 것은 다음 순서로 실행되는 세 번의 보간으로 귀결됩니다:

  • lerp(p0, c, t), 그 결과를 q0라 부릅니다
  • lerp(c, p2, t), 그 결과를 q1이라 부릅니다
  • lerp(q0, q1, t), t에서 곡선의 실제 위치

처음 두 개는 서로에게 의존하지 않습니다. 둘 다 그냥 원래의 세 점 사이를 혼합할 뿐입니다. 세 번째가 실제로 그것들을 사용하는 것으로, q0와 q1을 함께 혼합합니다.

trimQuadratic은 정확히 같은 처음 두 번의 보간을 실행하며, 그 결과를 q0와 q1로 명명합니다. 위의 드래그 가능한 데모는 이미 그것들을 보여줍니다: Q0-Q1은 드래그하는 동안 밝아지는 얇은 선분입니다.

차이는 그다음에 일어나는 일입니다. 곡선을 평가하는 것은 q0와 q1을 하나의 최종 점으로 합쳐버리고 버립니다. 분할하는 것은 한 번의 보간을 미리 멈추고 그것들을 보존하는데, q0, q1, 그리고 그 최종 혼합된 점인 tailP0가 그 자체로 새로운, 더 짧은 베지어 곡선의 세 제어점이기 때문입니다.

분할할 때마다 이런 세 쌍이 두 개 존재합니다: (p0, q0, tailP0)는 0부터 t까지의 곡선을 다루고, (tailP0, q1, p2)는 t부터 1까지를 다룹니다. 그것들은 정확히 tailP0에서 만나는데, 그 점이 원래 곡선 위의 점을 골라서 맞아떨어지기를 바란 것이 아니라, 처음부터 양쪽 절반을 함께 혼합해서 만들어졌기 때문입니다. trimQuadratic은 항상 두 번째 쌍만 유지하는데, 모든 호출이 실제 t0든 재조정된 t1Prime이든 어떤 t 이전의 모든 것을 잘라내고 있기 때문입니다.

4단계: 재생됨/재생안됨 나누기와 일시정지 시 평평하게 하기

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))
    }
}

이것은 3단계의 정확한 트리밍을 그대로 재사용합니다. 유일하게 바뀌는 것은 트리밍 경계로, 루프의 고정된 rightBound가 자체 Animatable로 구동되는 움직이는 progressX가 됩니다. 똑같은 둥근 끝 수학이 이제 재생이 진행됨에 따라 눈에 보이게 커지는 끝을 만들어내며, 단순히 정적인 루프 가장자리가 아닙니다.

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
    )
}

재생되지 않은 나머지 부분은 그냥 더 낮은 알파값으로 progressX에서 rightBound까지 그려지는 평평한 drawLine입니다. progressX가 rightBound에 도달하면 건너뛰는데, 길이가 0인 선도 여전히 StrokeCap.Round를 채워진 점으로 렌더링하기 때문입니다. 그 점은 꿈틀거리는 부분이 계속 그것을 지나쳐 반복되는 동안 하나의 화면 위치에 고정되어 있는데, 이것은 스트로크가 제자리에서 딱 멈춰버린 것처럼 보입니다.

FIG. 05
재생이 진행되면 꿈틀거리는 끝이 앞으로 나아가고 어두운 나머지 부분이 줄어듭니다. 일시정지하면 바 전체가 평평해지고, 다시 재생하면 다시 커지며 같은 위상에서 루프가 계속됩니다.

일시정지는 shift 루프를 중단시키고(LaunchedEffect(isPlaying)는 키가 바뀌는 순간 이전 코루틴을 취소합니다) amplitude를 짧은 tween에 걸쳐 0으로 완화시킵니다. 모든 곡선의 고정점은 이미 center.y 위에 있고, 제어점만 움직이므로, amplitude를 0으로 줄이면 꿈틀거리는 부분 전체가 재생되지 않은 나머지 부분이 이미 그랬던 것과 똑같은 평평한 선으로 퇴화합니다. 별도의 평평화 경로가 필요하지 않습니다.

infiniteRepeatable 재개하기

animateTo(targetValue, infiniteRepeatable(...))는 호출되는 순간 활성화된 초기값/목표값 쌍을 그대로 고정하고, RepeatMode.Restart는 그 정확한 쌍을 영원히 반복 재생하며, 호출의 초기 값으로 되돌아가는 것이지 0으로 되돌아가는 것이 아닙니다. 리터럴 waveLength 목표값은 shift가 0에서 시작하기 때문에 처음에는 작동합니다. 일시정지 이후의 모든 재개는 shift가 멈춰 있던 위치에서 시작하므로, 목표값은 고정된 리터럴이 아니라 shiftAnimatable.value + waveLength를 추적해야 하며, 그렇지 않으면 재개된 모든 루프가 일시정지했던 임의의 위상으로 튀어버립니다.

변형과 트레이드오프

  • 클리핑 vs. 트리밍. 2단계의 clipRect는 호출 한 번이며 곡선당 추가 비용이 들지 않습니다. 파형의 끝이 어차피 가려지는 경우, 즉 엄지 아래에 있거나 컨테이너 가장자리와 나란한 경우에는 괜찮은 선택입니다. 하지만 그 방법으로는 절대 둥근 끝을 만들 수 없는데, 그래서 3단계와 4단계는 대신 곡선 자체를 트리밍합니다.
  • 샘플링 해상도는 픽셀 단위가 아니라 파형 단위로 고정됩니다. 각 반파가 선분들의 연속이 아니라 하나의 2차 곡선이기 때문에, WAVE_COUNT는 얼마나 많은 봉우리가 들어가는지를 제어할 뿐, 하나의 봉우리가 얼마나 매끄러운지는 제어하지 않습니다. 파형이 하나 추가될 때마다 프레임당 trimQuadratic 호출이 두 번(반파마다 한 번) 더 들 뿐이며, lineTo 기반 접근 방식이 그러는 것처럼 수백 개의 추가 샘플 점이 드는 것이 아닙니다.
  • PLAYBACK_DURATION_MILLIS와 shift 루프의 속도는 독립적인 노브입니다. 파장당 1000ms인 물결 tween은 PLAYBACK_DURATION_MILLIS를 전혀 읽지 않습니다. 재생 속도와 파형 자체의 이동 속도는 서로의 수학을 건드리지 않고 별도로 조정할 수 있습니다.
  • 재개는 움직이기 전에 파형을 먼저 다시 키웁니다. LaunchedEffect(isPlaying)는 shift 루프와 progress tween을 실행하기 전에 300ms amplitude tween을 기다립니다. 그래서 재개 시 파형은 제자리에 고정된 채로 다시 커진 다음, 스크롤을 시작합니다. 세 가지 모두 함께 시작해야 한다면 amplitude tween도 자체 launch 블록에서 실행하세요.
  • 길이가 0인 선의 점은 진행률이 최대일 때만 나타납니다. 그래서 내보내기는 쉽지만 빠른 확인에서는 놓치기 쉬운데, 대부분의 수동 테스트가 재생 중간에 일어나기 때문입니다. 이런 식으로 스트로크를 스타일이 다른 두 부분으로 나누는 바라면, 중간뿐 아니라 0과 1이라는 양쪽 진행률 끝점도 의도적으로 확인해 볼 가치가 있습니다.
Keep reading

Related reads

새 글을 이메일로 받아보세요