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 deviennent désactivables.
• 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 des composables

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 étant désactivable si tous ses arguments ont des valeurs stables. Le mode "Ignorer" avec précision permet de changer cela.

Lorsque cette option est activée, toutes les fonctions composables redémarrables deviennent désactivables. Cela s'applique que les paramètres soient instables ou non. 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 souhaiter qu'un composable désactive cette fonctionnalité. Autrement dit, vous voudrez peut-être un composable redémarrable mais non désactivable. 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, des sources de données telles que Room allouent de nouveaux objets pour chaque élément de la liste chaque fois que l'un d'eux change.

Mémoisation lambda

Le mode d'omission fort permet également une plus grande mémoisation des lambdas dans les composables. Lorsque l'omission forte 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. Elle est associée aux captures 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é des instances. Elle 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émoisation, l'environnement d'exécution est beaucoup plus susceptible d'allouer un nouveau lambda à tout composable qui reçoit un paramètre lambda lors de la recomposition. Par conséquent, le nouveau lambda comporte des paramètres qui 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 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 forte a un très faible impact sur la taille de l'APK de votre application.

Le fait d'activer le 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.