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îchissement | Budget par frame |
|---|---|
| 60 Hz | 16,6 ms |
| 90 Hz | 11,1 ms |
| 120 Hz | 8,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êmedrawContent(), 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 bloconDrawBehind { }ouonDrawWithContent { }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/opacitysaute directement au composite, sans reflow ni repeinture ; animerwidth/topforce 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()etmarkNeedsPaint()comme les trois boutons d'invalidation littéraux sur unRenderObject. 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
Viewclassique d'Android :invalidate()(dessin seul) contrerequestLayout()(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èmeViewn'a jamais été déclaratif à la base. - UIKit :
setNeedsDisplay()contresetNeedsLayout()trace la même ligne, moins une phase de composition, comme le systèmeViewclassique ci-dessus. - SwiftUI : la même répartition en trois phases, appelées
réévaluation du body (composition),
sizeThatFits/placeSubviewsdu protocoleLayout(layout), etGraphicsContextdeCanvas(dessin), avec le même espace pixel, la même origine en haut à gauche, et le même piège des traits centrés queDrawScope. Le « lire tard, pas tôt » de l'Astuce 1 a un équivalent direct dansAnimatable: unShapeou unViewModifierdéclarevar animatableData, et SwiftUI l'interpole et le re-rend à travers le layout/dessin à chaque frame sans jamais réinvoquerbody.



