Recomposed
Recomposition

Recomposition, Layout und DrawScope: Eine Idee, drei Phasen

Oct 4, 2026 · 4 min read

Recomposition, Layout und DrawScope: Eine Idee, drei Phasen

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

BildwiederholrateBudget pro Frame
60 Hz16,6 ms
90 Hz11,1 ms
120 Hz8,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.

// ❌ 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 ruft drawContent() 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 einen onDrawBehind { }- oder onDrawWithContent { }-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/opacity zu animieren springt direkt zum Composite, ohne Reflow oder Repaint; width/top zu 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() und markNeedsPaint() als den drei wörtlichen Invalidierungs-Schaltern eines RenderObject. 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) versus requestLayout() (Measure und Layout, dann Draw) ist der direkte Vorfahre der Unterscheidung aus Tipp 2 und 3, minus einer Composition-Phase, da das View-System von Anfang an nicht deklarativ war.
  • UIKit: setNeedsDisplay() versus setNeedsLayout() zieht dieselbe Trennlinie, minus einer Composition-Phase, genau wie das klassische View-System oben.
  • SwiftUI: derselbe Dreiphasen-Split, genannt Body-Neuauswertung (Composition), das sizeThatFits/placeSubviews des Layout-Protokolls (Layout) und der GraphicsContext von Canvas (Draw), derselbe Pixelraum, Ursprung oben links, derselbe Stolperstein mit zentrierten Strokes wie bei DrawScope. Tipp 1s „spät lesen, nicht früh“ hat ein direktes Gegenstück in Animatable: ein Shape oder ViewModifier deklariert var animatableData, und SwiftUI interpoliert und rendert es bei jedem Frame durch Layout/Draw neu, ohne body je erneut aufzurufen.
Keep reading

Related reads

Neue Beiträge direkt in dein Postfach