La omisión fuerte es un modo disponible en el compilador de Compose. Cuando se habilita, cambia el comportamiento del compilador de dos maneras:
- Los elementos componibles con parámetros inestables se pueden omitir
- Se recuerdan las expresiones lambda con capturas inestables.
Cómo habilitar el modo de omisión avanzada
Para habilitar la omisión fuerte en un módulo de Gradle, incluye la siguiente opción en
el bloque composeCompiler de tu configuración de Gradle:
android { ... }
composeCompiler {
enableStrongSkippingMode = true
}
Omisión de componibilidad
El modo de omisión fuerte relaja algunas de las reglas de stability que se aplican normalmente. por el compilador de Compose cuando se trata de omitir y de funciones de componibilidad. De de forma predeterminada, el compilador de Compose marca una función de componibilidad como que se puede omitir si todas sus argumentos tienen valores estables. El modo de omisión fuerte cambia esta situación.
Con la omisión segura habilitada, todas las funciones de componibilidad reiniciables se vuelven que se pueden omitir. Esto se aplica sin importar si tienen parámetros inestables o no. Las funciones de componibilidad que no se pueden reiniciar no se pueden omitir.
Cuándo omitir
Para determinar si se debe omitir un elemento componible durante la recomposición, Compose compara el valor de cada parámetro con sus valores anteriores. El tipo de comparación depende de la estabilidad del parámetro.
- Los parámetros inestables se comparan con la igualdad de instancias (
===) - Los parámetros estables se comparan mediante la igualdad de objetos (
Object.equals())
Si todos los parámetros cumplen con estos requisitos, Compose omite el elemento componible durante a la recomposición.
Te recomendamos que un elemento componible inhabilite la omisión automática. Es decir, podrías
y quieres un elemento
que se pueda reiniciar, pero que no se pueda omitir. En este caso, usa el
@NonSkippableComposable.
@NonSkippableComposable
@Composable
fun MyNonSkippableComposable {}
Anota las clases como estables
Si quieres que un objeto use igualdad de objeto en lugar de igualdad de instancias, continuar anotando la clase determinada con @Stable. Un ejemplo de cuándo podrías que hacer esto es cuando se observa una lista completa de objetos, fuentes de datos como ya que Room asignará nuevos objetos para cada elemento de la lista cada vez que los cambios.
Memorización de lambda
El modo de omisión fuerte también permite una mayor memoria de las lambdas. dentro de elementos componibles. Con la omisión potente habilitada, cada lambda dentro de función de componibilidad se recordarán automáticamente.
Ejemplos
Para lograr la memorización de las lambdas dentro de elementos componibles cuando se usa una omisión fuerte,
el compilador une tu lambda con una llamada remember. Está vinculado con la
capturas de la lambda.
Considera un caso en el que tienes una lambda, como en el siguiente ejemplo:
@Composable
fun MyComposable(unstableObject: Unstable, stableObject: Stable) {
val lambda = {
use(unstableObject)
use(stableObject)
}
}
Con la omisión fuerte habilitada, el compilador memoriza la lambda uniéndola
Una llamada a remember:
@Composable
fun MyComposable(unstableObject: Unstable, stableObject: Stable) {
val lambda = remember(unstableObject, stableObject) {
{
use(unstableObject)
use(stableObject)
}
}
}
Las teclas siguen las mismas reglas de comparación que las funciones de componibilidad. El entorno de ejecución compara las claves inestables con la igualdad de instancia. Compara las claves estables con igualdad de objetos.
Memorización y recomposición
Esta optimización aumenta en gran medida la cantidad de elementos componibles que el entorno de ejecución o que se omiten durante la recomposición. Sin la memorización, es mucho más probable que el tiempo de ejecución para asignar una nueva lambda a cualquier elemento componible que tome un parámetro lambda durante a la recomposición. Como resultado, la nueva expresión lambda tiene parámetros que no son iguales a la última composición. Esto da como resultado la recomposición.
Evita la memorización
Si tienes una expresión lambda que no deseas memorizar, usa @DontMemoize.
.
val lambda = @DontMemoize {
...
}
Tamaño del APK
Cuando se compilan, los elementos componibles que se pueden omitir generan más código que el
elementos componibles que no se pueden omitir. Con la omisión fuerte habilitada, el compilador
marca casi todos los elementos componibles como que se pueden omitir y une todas las lambdas en un
remember{...} Debido a esto, habilitar el modo de omisión fuerte tiene un
en el tamaño del APK de tu aplicación.
Habilitar la omisión potente en Now In Android aumentó el APK en 4 KB. La diferencia en el tamaño depende en gran medida de la cantidad elementos componibles que no se pueden omitir y que estaban presentes en la app determinada, pero que deben relativamente menor.