Il s'agit d'un mode disponible dans le compilateur Compose. Lorsqu'elle est activée, modifie le comportement du compilateur de deux manières:
- Les composables avec des paramètres instables deviennent désactivables.
- Les lambdas avec des captures instables sont mémorisés.
Activer le mode de désactivation renforcée
Pour activer le saut fort pour un module Gradle, incluez l'option suivante dans
le bloc composeCompiler
de votre configuration Gradle:
android { ... }
composeCompiler {
enableStrongSkippingMode = true
}
Désactivation des composables
Le mode "Ignorer" avec un haut niveau de sortie assouplit certaines règles de stabilité normalement appliquées par le compilateur Compose lorsqu'il s'agit de sauter des fonctions composables. Par par défaut, le compilateur Compose marque une fonction modulable comme étant désactivable si toutes les ses arguments ont des valeurs stables. Le mode "Ignorer" avec précision permet de changer cela.
Avec l'option "Ignorer" de façon forte, toutes les fonctions composables redémarrables deviennent désactivables. Cela s'applique, qu'ils aient ou non des paramètres instables. Les fonctions composables non redémarrables ne peuvent pas être désactivées.
Quand ignorer
Pour déterminer s'il faut ignorer un composable lors de la recomposition, Compose compare la valeur de chaque paramètre par leurs valeurs précédentes. Type de comparaison dépend de la stabilité du paramètre.
- Les paramètres instables sont comparés à l'aide d'une égalité d'instance (
===
) - Les paramètres stables sont comparés à l'aide de l'égalité d'objet (
Object.equals()
)
Si tous les paramètres répondent à ces exigences, Compose ignore le composable pendant la recomposition.
Vous pouvez souhaiter qu'un composable désactive cette fonctionnalité. Autrement dit, vous pouvez
un composable redémarrable, mais non désactivable. Dans ce cas, utilisez la méthode
Annotation @NonSkippableComposable
.
@NonSkippableComposable
@Composable
fun MyNonSkippableComposable {}
Annoter les classes comme étant stables
Si vous voulez qu'un objet utilise une égalité d'objet au lieu d'une égalité d'instance, continue à annoter la classe donnée avec @Stable. Par exemple, vous pourriez lorsqu'il s'agit d'observer une liste complète d'objets, de sources de données car Room attribuera de nouveaux objets à chaque élément de la liste à chaque fois que les changements.
Mémoisation lambda
Le mode "Ignorer" à fort volume permet également de mieux mémoiser les lambdas. dans des composables. Avec le saut fort activé, chaque lambda à l'intérieur d'un fonction composable sera automatiquement mémorisée.
Exemples
Pour obtenir la mémoisation des lambdas dans des composables lors de l'utilisation d'un saut fort,
le compilateur encapsule votre lambda avec un appel remember
. Il est associé aux
du lambda.
Prenons un cas où vous avez un lambda, comme dans l'exemple suivant:
@Composable
fun MyComposable(unstableObject: Unstable, stableObject: Stable) {
val lambda = {
use(unstableObject)
use(stableObject)
}
}
Lorsque le saut fort est activé, le compilateur mémorise le lambda en l'encapsulant dans
un appel remember
:
@Composable
fun MyComposable(unstableObject: Unstable, stableObject: Stable) {
val lambda = remember(unstableObject, stableObject) {
{
use(unstableObject)
use(stableObject)
}
}
}
Les touches suivent les mêmes règles de comparaison que les fonctions composables. L'environnement d'exécution compare les clés instables à l'aide de l'égalité d'instance. Il compare les clés stables à l'aide de l'égalité des objets.
Mémoisation et recomposition
Cette optimisation augmente considérablement le nombre de composables que l'environnement d'exécution ignore lors de la recomposition. Sans mémoisation, l'environnement d'exécution pour allouer un nouveau lambda à tout composable qui reçoit un paramètre lambda pendant la recomposition. Par conséquent, les paramètres du nouveau lambda ne sont pas égaux à la dernière composition. Cela entraîne une recomposition.
Éviter la mémoisation
Si vous avez un lambda que vous ne souhaitez pas mémoriser, utilisez @DontMemoize
.
val lambda = @DontMemoize {
...
}
Taille de l'APK
Lorsqu'ils sont compilés, les composables désactivables génèrent plus de code que
composables qui ne sont pas désactivables. Avec l'option d'omission forte activée, le compilateur
marque presque tous les composables comme désactivables et encapsule tous les lambdas dans un
remember{...}
C'est pourquoi l'activation d'un mode de saut fort
sur la taille de l'APK de votre application.
La possibilité d'ignorer fortement les annonces dans Now In Android a augmenté le nombre d'APK de 4 Ko. La différence de taille dépend en grande partie du nombre composables non désactivables présents dans l'application donnée, mais qui devraient être sont relativement mineures.