Le saut fort est un mode disponible dans le compilateur Compose. Lorsqu'elle est activée, elle modifie le comportement du compilateur de deux manières:
- Les composables avec des paramètres instables deviennent ignorables.
- Les lambdas avec des captures instables sont mémorisés.
Activer le mode Ignorer fort
Pour ignorer un module Gradle, incluez l'option suivante dans le bloc composeCompiler de votre configuration Gradle:
composeCompiler {
enableStrongSkipping = true
}
Désactivation du composable
Le mode Ignorer forte assouplie certaines des règles de stabilité normalement appliquées par le compilateur Compose lorsqu'il s'agit d'ignorer des fonctions et des fonctions modulables. Par défaut, le compilateur Compose marque une fonction composable comme étant désactivable si tous ses arguments ont des valeurs stables. Le fait de passer d'une option à l'autre change la donne.
Lorsque l'option "Ignorer" est activée, toutes les fonctions composables redémarrables deviennent désactivables. Cela s'applique aux paramètres instables ou non. Les fonctions composables non redémarrables restent non désactivables.
Quand ignorer
Pour déterminer s'il faut ignorer un composable lors de la recomposition, Compose compare la valeur de chaque paramètre avec ses valeurs précédentes. Le type de comparaison dépend de la stabilité du paramètre.
- Les paramètres instables sont comparés en utilisant l'égalité d'instance (
===) - Les paramètres stables sont comparés en utilisant l'égalité d'objet (
Object.equals())
Si tous les paramètres répondent à ces exigences, Compose ignore le composable lors de la recomposition.
Vous pouvez souhaiter qu'un composable désactive cette option. Autrement dit, vous pouvez avoir besoin d'un composable redémarrable, mais non désactivable. Dans ce cas, utilisez l'annotation @NonSkippableComposable.
@NonSkippableComposable
@Composable
fun MyNonSkippableComposable {}
Annoter les classes comme étant stables
Si vous souhaitez qu'un objet utilise l'égalité d'objet plutôt que l'égalité d'instance, continuez à annoter la classe donnée avec @Stable. Par exemple, lorsque vous observez une liste complète d'objets, des sources de données telles que Room allouent de nouveaux objets à chaque élément de la liste à chaque fois que l'un d'eux change.
Mémorisation lambda
Le mode Ignorer forte permet également une plus grande mémoisation des lambdas dans les composables. Lorsque la fonctionnalité d'omission forte est activée, chaque lambda d'une fonction modulable est automatiquement mémorisé.
Exemples
Pour réaliser la mémorisation des lambdas dans les composables lorsque vous utilisez un saut fort, le compilateur encapsule votre lambda avec un appel remember. Il est associé aux captures du lambda.
Prenons un cas dans lequel vous avez un lambda, comme dans l'exemple suivant:
@Composable
fun MyComposable(unstableObject: Unstable, stableObject: Stable) {
val lambda = {
use(unstableObject)
use(stableObject)
}
}
Lorsque la fonctionnalité d'omission forte est activée, 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 clés suivent les mêmes règles de comparaison que les fonctions composables. L'environnement d'exécution compare les clés instables en utilisant l'égalité d'instance. Elle compare les clés stables en utilisant l'égalité d'objet.
Mémorisation et recomposition
Cette optimisation augmente considérablement le nombre de composables que l'environnement d'exécution ignore lors de la recomposition. Sans mémorisation, l'environnement d'exécution est beaucoup plus susceptible d'allouer un nouveau lambda à tout composable qui accepte un paramètre lambda lors de la recomposition. Par conséquent, le nouveau lambda comporte des paramètres différents de la dernière composition. Cela entraîne une recomposition.
Éviter la mémorisation
Si vous avez un lambda que vous ne souhaitez pas mémoriser, utilisez l'annotation @DontMemoize.
val lambda = @DontMemoize {
...
}
Taille de l'APK
Lorsqu'ils sont compilés, les composables désactivables génèrent plus de code que les composables qui ne sont pas désactivables. Lorsque l'option d'omission forte est activée, le compilateur marque presque tous les composables comme étant désactivables et encapsule tous les lambdas dans un remember{...}. De ce fait, l'activation du mode fortement ignoré a très peu d'impact sur la taille de l'APK de votre application.
L'activation de la fonctionnalité Ignorer forte dans Now In Android a permis d'augmenter la taille de l'APK de 4 Ko. La différence de taille dépend en grande partie du nombre de composables précédemment non désactivables présents dans l'application donnée, mais il devrait être relativement mineur.