Mode sauté fort

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.