Mode sauté fort

Il s'agit d'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 peuvent être ignorés
  • Les lambdas avec des captures instables sont mémorisés

Activer le mode de désactivation renforcée

Pour activer le forçage de l'exclusion d'un module Gradle dans une version précédente, incluez l'option suivante dans le bloc composeCompiler de votre configuration Gradle :

android { ... }

composeCompiler {
   enableStrongSkippingMode = true
}

Désactivation du composable

Le mode de saut fort assouplit certaines des règles de stabilité normalement appliquées par le compilateur Compose en ce qui concerne le saut et les fonctions composables. Par défaut, le compilateur Compose marque une fonction modulable comme pouvant être ignorée si tous ses arguments ont des valeurs stables. Le mode de désactivation renforcée change cela.

Lorsque le forçage de l'élagage est activé, toutes les fonctions composables pouvant être redémarrées peuvent être ignorées. Cela s'applique, qu'ils aient ou non des paramètres instables. Les fonctions composables non réinitialisables ne peuvent pas être ignorées.

Quand ignorer

Pour déterminer si un composable doit être ignoré lors de la recomposition, Compose compare la valeur de chaque paramètre à ses valeurs précédentes. Le 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é des objets (Object.equals()).

Si tous les paramètres répondent à ces exigences, Compose ignore le composable lors de la recomposition.

Vous pouvez désactiver le forçage de la lecture d'un composable. Autrement dit, vous pouvez souhaiter un composable redémarrable, mais non ignorable. Dans ce cas, utilisez l'annotation @NonSkippableComposable.

@NonSkippableComposable
@Composable
fun MyNonSkippableComposable {}

Annoter des classes comme stables

Si vous souhaitez qu'un objet utilise l'égalité d'objet au lieu d'une égalité d'instance, continuez à annoter la classe donnée avec @Stable. Par exemple, lorsque vous observez une liste complète d'objets, les 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 d'omission fort permet également une plus grande mémoisation des lambdas dans les composables. Lorsque la désactivation renforcée est activée, chaque lambda d'une fonction composable est automatiquement mémorisé.

Exemples

Pour mémoriser les lambdas dans les composables lorsque vous utilisez un saut strict, le compilateur encapsule votre lambda avec un appel remember. Il est associé aux captures du lambda.

Prenons l'exemple suivant:

@Composable
fun MyComposable(unstableObject: Unstable, stableObject: Stable) {
    val lambda = {
        use(unstableObject)
        use(stableObject)
    }
}

Lorsque la désactivation renforcée est activée, le compilateur met en mémoire 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. Il compare les clés stables à l'aide de l'égalité des objets.

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, 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 mettre en cache, utilisez l'annotation @DontMemoize.

val lambda = @DontMemoize {
    ...
}

Taille de l'APK

Lors de la compilation, les composables ignorables génèrent plus de code que les composables non ignorables. Lorsque le forçage de l'élagage est activé, le compilateur marque presque tous les composables comme pouvant être ignorés et encapsule tous les lambdas dans un remember{...}. Par conséquent, l'activation du mode de désactivation renforcée a un impact très faible sur la taille de l'APK de votre application.

L'activation du saut fort dans Now In Android a augmenté 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 ignorables qui étaient présents dans l'application donnée, mais elle devrait être relativement mineure.