L'eliminazione forzata è una modalità disponibile nel compilatore di Compose. Quando abilitato, cambia il comportamento del compilatore in due modi:
- I componibili con parametri instabili diventano ignorabili
- Le lambda con acquisizioni instabili vengono ricordate
Attiva la modalità Ignora forte
Per abilitare la funzionalità che consente di ignorare in modo forzato un modulo Gradle, includi la seguente opzione nel blocco composeCompiler
della configurazione di Gradle:
composeCompiler {
enableStrongSkipping = true
}
Possibilità di ignorare componibili
Questa modalità riduce alcune delle regole di stabilità normalmente applicate dal compilatore di Compose, in relazione alle funzioni di salto e componibile. Per impostazione predefinita, il compilatore di Compose contrassegna una funzione componibile come ignorabile se tutti gli argomenti hanno valori stabili. La modalità di salto in modo deciso consente di cambiare la situazione.
Se è attivata l'opzione Ignora forte, tutte le funzioni componibili riavviabili diventano ignorabili. Ciò si applica indipendentemente dal fatto che abbiano parametri instabili o meno. Le funzioni componibili non riavviabili rimangono non ignorabili.
Quando saltare
Per determinare se ignorare un componibile durante la ricomposizione, Compose confronta il valore di ogni parametro con i valori precedenti. Il tipo di confronto dipende dalla stabilità del parametro.
- I parametri instabili vengono confrontati utilizzando l'uguaglianza dell'istanza (
===
) - I parametri stabili vengono confrontati utilizzando l'uguaglianza degli oggetti (
Object.equals()
)
Se tutti i parametri soddisfano questi requisiti, Compose ignora il componibile durante la ricomposizione.
Ti consigliamo di utilizzare un componibile per disattivare l'opzione che consente di ignorare gli elementi in modo deciso. Ad esempio, potresti aver bisogno
di un componibile riavviabile, ma non ignorabile. In questo caso, utilizza l'annotazione @NonSkippableComposable
.
@NonSkippableComposable
@Composable
fun MyNonSkippableComposable {}
Annota le classi come stabile
Se vuoi che un oggetto utilizzi l'uguaglianza degli oggetti anziché l'uguaglianza dell'istanza, continua ad annotare la classe specificata con @Stable. Un esempio di quando potresti dover farlo è quando osservi un intero elenco di oggetti, origini dati come Room allocaranno nuovi oggetti per ogni elemento nell'elenco ogni volta che uno di loro viene modificato.
Memorizzazione Lambda
La modalità di abbandono avanzata consente anche una maggiore memoizzazione dei lambda all'interno dei componibili. Se abiliti la funzione lambda, ogni funzione lambda all'interno di una funzione componibile verrà memorizzata automaticamente.
Esempi
Per ottenere la memorizzazione dei lambda all'interno dei componibili quando utilizzi un comando che salta in alto, il compilatore aggrega il tuo lambda con una chiamata remember
. È chiusa con le
catture del lambda.
Considera un caso in cui hai una funzione lambda, come nell'esempio seguente:
@Composable
fun MyComposable(unstableObject: Unstable, stableObject: Stable) {
val lambda = {
use(unstableObject)
use(stableObject)
}
}
Con la funzionalità di abbandono deciso abilitata, il compilatore memorizza il lambda racchiudendolo in una
chiamata remember
:
@Composable
fun MyComposable(unstableObject: Unstable, stableObject: Stable) {
val lambda = remember(unstableObject, stableObject) {
{
use(unstableObject)
use(stableObject)
}
}
}
Le chiavi seguono le stesse regole di confronto delle funzioni componibili. Il runtime confronta le chiavi instabili utilizzando l'uguaglianza delle istanze. Confronta le chiavi stabili usando l'uguaglianza dell'oggetto.
Memorizzazione e ricomposizione
Questa ottimizzazione aumenta notevolmente il numero di elementi componibili che il runtime salta durante la ricomposizione. Senza la memorizzazione, è molto più probabile che il runtime assegni un nuovo lambda a qualsiasi componibile che richiede un parametro lambda durante la ricomposizione. Di conseguenza, il nuovo lambda ha parametri diversi dall'ultima composizione. Questo comporta la ricomposizione.
Evita la memorizzazione nella cache
Se hai una funzione lambda che non vuoi memorizzare, usa l'annotazione @DontMemoize
.
val lambda = @DontMemoize {
...
}
Dimensioni APK
Quando vengono compilati, gli elementi componibili ignorabili generano più codice generato rispetto agli
componibili non ignorabili. Se abiliti la funzionalità di salto in modo deciso, il compilatore contrassegna quasi tutti i componibili come ignorabili e aggrega tutti i lambda in un remember{...}
. Per questo motivo, l'attivazione di una modalità che consente di saltare in modo deciso ha un impatto minimo sulle dimensioni degli APK della tua applicazione.
L'abilitazione di un'opzione che consente di saltare in modo deciso in Ora in Android ha aumentato le dimensioni dell'APK di 4 kB. La differenza di dimensioni dipende in gran parte dal numero di elementi componibili precedentemente non ignorabili che erano presenti nell'app, ma dovrebbero essere relativamente minori.