Die Intuition
Ein Composable, das bei jedem gescrollten Pixel neu komponiert, und eines, das nur neu vermisst, können in der Preview identisch aussehen. Auf dem Bildschirm hält nur eines der beiden mit der Anzeige Schritt, und der Unterschied liegt nie im State selbst, sondern darin, in welcher Phase er gelesen wird.
Jeder Frame durchläuft drei Phasen, jede mit ihrem eigenen Snapshot-Observer, der nur für State-Reads erneut läuft, die innerhalb dieser Phase stattgefunden haben:
- Composition: was existiert (am teuersten)
- Layout: wo/wie groß (mittel)
- Draw: welche Pixel (am günstigsten)
Die Kosten sind nicht über alle drei gleich verteilt: Composition erneut auszuführen ist die teuerste Phase, Layout ist mittel, Draw ist am günstigsten.
Die entscheidende Frage ist also nicht wo wird dieser Wert verwendet,
sondern in welcher Phase lese ich ihn, denn das beantwortet welches ist die günstigste Phase, in der dieser Read landen kann.
Diese Kostenreihenfolge ist nur deshalb wichtig, weil alle drei Phasen eine gemeinsame Deadline teilen: den Refresh-Takt der Anzeige. Composition, Layout und Draw müssen alle vor dem nächsten -Tick fertig sein, sonst wird der vorherige Frame erneut angezeigt (ein verpasster Frame, sichtbar als Jank/Ruckeln).
| Bildwiederholrate | Budget pro Frame |
|---|---|
| 60 Hz | 16,6 ms |
| 90 Hz | 11,1 ms |
| 120 Hz | 8,3 ms |
Dieses gemeinsame Budget wird auch ungleich verteilt: eine unnötige Recomposition kostet am meisten, ein unnötiges Re-Layout kostet weniger, und ein unnötiges Redraw kostet am wenigsten.
Bei 120 Hz stehen für alle drei Phasen plus die GPU insgesamt nur 8,3 ms zur Verfügung, sodass ein Composable, das bei jedem gescrollten Pixel neu komponiert, als Erstes das Budget sprengt und ein Stottern verursacht.
Tipp 1: Recomposition, spät lesen statt früh
// ❌ offsetPx wird zur Composition-Zeit in die Modifier-Chain eingebacken →
// jede Änderung baut die Chain neu auf → recomposiert bei jedem gescrollten Pixel
Modifier.offset(x = offsetPx.dp)
// ✅ offsetPx wird innerhalb der Placement-Lambda gelesen, nicht als Wert übergeben →
// die Identität des Modifiers bleibt stabil, nur das Placement läuft erneut
Modifier.offset { IntOffset(0, offsetPx.roundToInt()) }Modifier.offset(x: Dp, y: Dp) nimmt einfache Werte entgegen, daher muss
offsetPx.dp bevor die Modifier-Chain existiert aufgelöst werden,
während der Composition. Jede Änderung erzeugt einen neuen Modifier und
erzwingt eine Recomposition.
Modifier.offset { IntOffset(...) } speichert stattdessen die Lambda selbst
und ruft sie erst während des Placements auf, einem Teil der Layout-Phase,
sodass sich die Identität des Modifiers nie ändert und die Composition nie
erneut läuft. Gleicher State, gleicher Effekt auf dem Bildschirm, andere
Phase, die die Rechnung trägt.
Die eine Ausnahme
Ob ein Node überhaupt existiert (AnimatedVisibilitys visible), muss in
der Composition entschieden werden; Layout und Draw können nur verschieben
oder neu zeichnen, was die Composition bereits ausgegeben hat.
Tipp 2: Layout, Constraints nach unten, Größen nach oben, Parent entscheidet die Position
// ❌ im Composable-Body gelesen → Änderung von heightPx recomposiert
val heightPx = lerp(maxHeightPx, minHeightPx, collapseFraction()).roundToInt()
Modifier.layout { measurable, constraints ->
val placeable = measurable.measure(constraints.copy(maxHeight = heightPx))
layout(placeable.width, heightPx) {
placeable.placeRelative(0, 0)
}
}
// ✅ innerhalb der eigenen Lambda des Modifiers gelesen → nur Re-Measure, keine Recomposition
Modifier.layout { measurable, constraints -> // constraints: die Box, die ich erfüllen muss
val heightPx = lerp(maxHeightPx, minHeightPx, collapseFraction()).roundToInt()
val placeable = measurable.measure( // measurable: noch offen, erst nach diesem Aufruf bemessen
constraints.copy(maxHeight = heightPx) // ich wähle, was ich nach unten weitergebe (Höhe fixiert)
)
layout(placeable.width, heightPx) { // ich melde MEINE Größe nach oben an meinen Parent
placeable.placeRelative(0, 0) // ich allein entscheide, wo das Child sitzt
}
}Ein Child darf eine Größe nur innerhalb der [min, max]-Box wählen, die ihm
sein Parent vorgibt; seine eigene Position wählt es nie selbst.
Modifier.layout liest State in der Layout-Phase, mittlere Kosten,
günstiger als Composition, aber teurer als Draw. heightPx muss also
innerhalb der Lambda gelesen werden, dieselbe Lektion wie bei Tipp 1, sonst
recomposiert jeder Pixel des Collapse-Drags, statt nur neu zu vermessen.
Tipp 3: DrawScope, Pixel, Ursprung oben links, und zentrierte Strokes
// ❌ im Composable-Body gelesen → Änderung von progress recomposiert
val progress = scrollProgress()
Modifier.drawBehind {
val stroke = 8.dp.toPx()
// um die halbe Strichbreite einrücken, sonst wird die äußere Hälfte abgeschnitten
drawCircle(Color.Blue.copy(alpha = progress),
radius = size.minDimension / 2 - stroke / 2, style = Stroke(stroke))
}
// ✅ innerhalb der eigenen Lambda von drawBehind gelesen → nur Redraw, keine Recomposition
Modifier.drawBehind {
val stroke = 8.dp.toPx()
val progress = scrollProgress()
drawCircle(Color.Blue.copy(alpha = progress),
radius = size.minDimension / 2 - stroke / 2, style = Stroke(stroke))
}Innerhalb von DrawScope ist bereits alles in Pixeln, der Ursprung liegt
oben links, +y geht nach unten. Strokes werden auf dem Pfad
zentriert, nicht innerhalb davon, daher die halbe Einrückung oben, sonst wird
die äußere Hälfte abgeschnitten.
drawBehind: zeichnet nur vor dem eigenen Inhalt des Nodes, bei jedem Zeichendurchgang, ohne Caching. Die einfachste Option, wenn man nur etwas darunter braucht.drawWithContent: man ruftdrawContent()selbst auf, kontrolliert also die Reihenfolge: davor, danach oder beides, indem man diesen Aufruf relativ zur eigenen Zeichnung platziert.drawWithCache: die äußere Lambda läuft nur erneut, wenn sich Größe/Layout ändern, nicht bei jedem Frame; teure Objekte (Brush,Path,Shader) dort einmal erzeugen und dann einenonDrawBehind { }- oderonDrawWithContent { }-Block zurückgeben, der sie bei jedem tatsächlichen Zeichenvorgang wiederverwendet.
Draw ist von den drei Phasen am günstigsten erneut auszuführen, daher muss
progress innerhalb von welcher dieser Optionen man auch verwendet gelesen
werden, dieselbe Lektion wie bei Tipp 1 und 2: ein Read hier erzwingt nie ein
Re-Measure, geschweige denn eine Recomposition.
Anderswo: dasselbe Grundprinzip, anderes Framework
- Browser-Rendering-Pipeline (CSS): Style-Recalc, Layout (Reflow),
Paint, Composite, dieselbe Kostenreihenfolge unter anderem Namen.
transform/opacityzu animieren springt direkt zum Composite, ohne Reflow oder Repaint;width/topzu animieren erzwingt die gesamte Pipeline. Der Ratschlag „auf dem Compositor-Thread bleiben“ ist Tipp 1 und 3 dieses Beitrags, nur als Performance-Tipp für die Browser-DevTools statt für Compose formuliert. - Flutter: derselbe Dreiphasen-Split, genannt build, layout, paint, mit
markNeedsBuild(),markNeedsLayout()undmarkNeedsPaint()als den drei wörtlichen Invalidierungs-Schaltern einesRenderObject. Den günstigsten korrekten davon aufzurufen ist exakt dieselbe Disziplin wie State in der richtigen Compose-Phase zu lesen. - Klassisches Android-
View-System:invalidate()(nur Draw) versusrequestLayout()(Measure und Layout, dann Draw) ist der direkte Vorfahre der Unterscheidung aus Tipp 2 und 3, minus einer Composition-Phase, da dasView-System von Anfang an nicht deklarativ war. - UIKit:
setNeedsDisplay()versussetNeedsLayout()zieht dieselbe Trennlinie, minus einer Composition-Phase, genau wie das klassischeView-System oben. - SwiftUI: derselbe Dreiphasen-Split, genannt Body-Neuauswertung
(Composition), das
sizeThatFits/placeSubviewsdesLayout-Protokolls (Layout) und derGraphicsContextvonCanvas(Draw), derselbe Pixelraum, Ursprung oben links, derselbe Stolperstein mit zentrierten Strokes wie beiDrawScope. Tipp 1s „spät lesen, nicht früh“ hat ein direktes Gegenstück inAnimatable: einShapeoderViewModifierdeklariertvar animatableData, und SwiftUI interpoliert und rendert es bei jedem Frame durch Layout/Draw neu, ohnebodyje erneut aufzurufen.



