Recomposed
Recomposition

Recomposition, Layout et DrawScope : une seule idée, trois phases

Oct 4, 2026 · 5 min read

Recomposition, Layout et DrawScope : une seule idée, trois phases

L'intuition

Un composable qui se recompose à chaque pixel de défilement et un autre qui se contente de se re-mesurer peuvent sembler identiques dans l'aperçu. À l'écran, un seul des deux suit le rythme de l'affichage, et la différence ne vient jamais de l'état lui-même, mais de la phase qui le lit.

Chaque frame traverse trois phases, chacune avec son propre observateur de snapshot qui ne se redéclenche que pour les lectures d'état survenues à l'intérieur de cette phase :

  • Composition : ce qui existe (la plus coûteuse)
  • Layout : où/quelle taille (coût moyen)
  • Draw : quels pixels (la moins coûteuse)

Le coût n'est pas uniforme entre elles : la composition est la phase la plus coûteuse à rejouer, le layout est à coût moyen, le dessin est le moins coûteux.

La question qui compte n'est donc pas « où cette valeur est-elle utilisée », mais « dans quelle phase est-ce que je la lis », car cela répond à « quelle est la phase la moins coûteuse où cette lecture peut atterrir ».

Ce classement des coûts n'a d'importance que parce que les trois phases partagent une seule échéance : l'horloge de rafraîchissement de l'écran. Composition, layout et dessin doivent tous se terminer avant le prochain tick de , sinon la frame précédente est réaffichée (une frame perdue, visible comme une saccade).

Taux de rafraîchissementBudget par frame
60 Hz16,6 ms
90 Hz11,1 ms
120 Hz8,3 ms

Ce budget partagé est également partagé de manière inégale : une recomposition inutile coûte le plus, un re-layout inutile coûte moins, et un redessin inutile coûte le moins.

À 120 Hz, on ne dispose que de 8,3 ms au total pour les trois phases plus le GPU, donc un composable qui se recompose à chaque pixel de défilement est la première chose à faire exploser le budget et à provoquer un à-coup.

Astuce 1 : Recomposition, lire tard, pas tôt

// ❌ offsetPx figé dans la chaîne de Modifier au moment de la composition →
// chaque changement reconstruit la chaîne → recompose à chaque pixel de défilement
Modifier.offset(x = offsetPx.dp)
 
// ✅ offsetPx lu à l'intérieur du lambda de placement, pas passé comme valeur →
// l'identité du Modifier reste stable, seul le placement se redéclenche
Modifier.offset { IntOffset(0, offsetPx.roundToInt()) }

Modifier.offset(x: Dp, y: Dp) prend des valeurs simples, donc offsetPx.dp doit être résolu avant que la chaîne de Modifier n'existe, pendant la composition. Chaque changement produit un nouveau Modifier et force une recomposition.

Modifier.offset { IntOffset(...) } stocke au contraire le lambda lui-même et ne l'appelle que pendant le placement, qui fait partie de la phase de layout, donc l'identité du Modifier ne change jamais et la composition ne se redéclenche jamais. Même State, même effet à l'écran, mais une phase différente qui en assume le coût.

L'unique exception

Le fait qu'un nœud existe ou non (le visible d'AnimatedVisibility) doit être décidé en composition ; le layout et le dessin ne peuvent que déplacer ou repeindre ce que la composition a déjà émis.

Astuce 2 : Layout, les contraintes descendent, les tailles remontent, le parent décide de la position

// ❌ lu dans le corps du composable → le changement de heightPx recompose
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)
    }
}
 
// ✅ lu à l'intérieur du lambda du modifier lui-même → ne fait que se re-mesurer, pas de recomposition
Modifier.layout { measurable, constraints ->  // constraints : la boîte que je dois respecter
    val heightPx = lerp(maxHeightPx, minHeightPx, collapseFraction()).roundToInt()
    val placeable = measurable.measure(        // measurable : en attente, pas de taille avant que je l'appelle
        constraints.copy(maxHeight = heightPx)   // je choisis ce que je transmets vers le bas (hauteur fixée)
    )
    layout(placeable.width, heightPx) {        // je remonte MA taille à mon parent
        placeable.placeRelative(0, 0)            // je décide seul de l'endroit où placer l'enfant
    }
}

Un enfant ne peut choisir une taille qu'à l'intérieur de la boîte [min, max] que son parent lui remet ; il ne choisit jamais sa propre position.

Modifier.layout lit l'état à la phase de layout, un coût moyen, moins cher que la composition mais plus cher que le dessin. Donc heightPx doit être lu à l'intérieur du lambda, même leçon que l'Astuce 1, sinon chaque pixel de glissement lors du repliement recompose au lieu de simplement se re-mesurer.

Astuce 3 : DrawScope, pixels, origine en haut à gauche, et traits centrés

// ❌ lu dans le corps du composable → le changement de progress recompose
val progress = scrollProgress()
Modifier.drawBehind {
    val stroke = 8.dp.toPx()
    // décalage vers l'intérieur de la moitié de l'épaisseur du trait, sinon la moitié externe est rognée
    drawCircle(Color.Blue.copy(alpha = progress),
        radius = size.minDimension / 2 - stroke / 2, style = Stroke(stroke))
}
 
// ✅ lu à l'intérieur du lambda de drawBehind lui-même → ne fait que redessiner, pas de 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))
}

À l'intérieur de DrawScope, tout est déjà en pixels, l'origine est en haut à gauche, et +y va vers le bas. Les traits sont centrés sur le tracé, pas à l'intérieur, d'où le décalage d'une demi-épaisseur ci-dessus, sinon la moitié externe est rognée.

  • drawBehind : dessine uniquement avant le contenu propre du nœud, à chaque passe de dessin, sans mise en cache. L'option la plus simple quand on a juste besoin de quelque chose en dessous.
  • drawWithContent : vous appelez vous-même drawContent(), donc vous contrôlez l'ordre : avant, après, ou les deux, en plaçant cet appel où vous voulez par rapport à votre propre dessin.
  • drawWithCache : le lambda externe ne se redéclenche que lors des changements de taille/layout, pas à chaque frame ; construisez-y une seule fois les objets coûteux (Brush, Path, Shader), puis renvoyez un bloc onDrawBehind { } ou onDrawWithContent { } qui les réutilise à chaque dessin réel.

Le dessin est la moins coûteuse des trois phases à rejouer, donc progress doit être lu à l'intérieur de celui que vous utilisez parmi ceux-ci, même leçon que les Astuces 1 et 2 : le lire ici ne force jamais un re-mesurage, encore moins une recomposition.

Ailleurs : même principe fondamental, framework différent

  • Pipeline de rendu du navigateur (CSS) : recalcul de style, layout (reflow), peinture, composite, le même ordre de coût sous un nom différent. Animer transform/opacity saute directement au composite, sans reflow ni repeinture ; animer width/top force le pipeline complet. Le conseil « rester sur le thread du compositeur » correspond aux Astuces 1 et 3 de cet article, simplement présenté comme un conseil de performance DevTools du navigateur plutôt que Compose.
  • Flutter : la même répartition en trois phases, appelées build, layout, paint, avec markNeedsBuild(), markNeedsLayout() et markNeedsPaint() comme les trois boutons d'invalidation littéraux sur un RenderObject. Appeler le moins coûteux qui soit correct relève exactement de la même discipline que lire l'état dans la bonne phase Compose.
  • Système View classique d'Android : invalidate() (dessin seul) contre requestLayout() (mesure et layout, puis dessin) est l'ancêtre direct de la distinction des Astuces 2 et 3, moins une phase de composition, puisque le système View n'a jamais été déclaratif à la base.
  • UIKit : setNeedsDisplay() contre setNeedsLayout() trace la même ligne, moins une phase de composition, comme le système View classique ci-dessus.
  • SwiftUI : la même répartition en trois phases, appelées réévaluation du body (composition), sizeThatFits/placeSubviews du protocole Layout (layout), et GraphicsContext de Canvas (dessin), avec le même espace pixel, la même origine en haut à gauche, et le même piège des traits centrés que DrawScope. Le « lire tard, pas tôt » de l'Astuce 1 a un équivalent direct dans Animatable : un Shape ou un ViewModifier déclare var animatableData, et SwiftUI l'interpole et le re-rend à travers le layout/dessin à chaque frame sans jamais réinvoquer body.
Keep reading

Related reads

Recevez les nouveaux articles par e-mail