Strong Skipping è una modalità disponibile nel compilatore Compose. Quando è abilitato, cambia il comportamento del compilatore in due modi:
- Gli elementi componibili con parametri instabili diventano ignorabili
- Le funzioni lambda con acquisizioni instabili vengono ricordate
Attiva la modalità Ignora veloce
Per abilitare questa funzionalità per un modulo Gradle, includi la seguente opzione in
il blocco composeCompiler
della tua configurazione Gradle:
android { ... }
composeCompiler {
enableStrongSkippingMode = true
}
Possibilità di ignorare gli annunci componibili
La modalità di salto forte rilassa alcune delle regole di stabilità normalmente applicate. dal compilatore Compose quando si tratta di saltare le funzioni e creare funzioni componibili. Di per impostazione predefinita, il compilatore Compose contrassegna una funzione componibile come ignorabile se i suoi argomenti hanno valori stabili. La modalità di salto forte cambia questo aspetto.
Con questa funzionalità attivata, tutte le funzioni componibili riavviabili diventano ignorabili. Questo si applica indipendentemente dal fatto che i parametri abbiano o meno parametri instabili. Le funzioni componibili non riavviabili rimangono non ignorabili.
Quando saltare il passaggio
Per determinare se saltare un messaggio 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 delle istanze (
===
) - I parametri stabili vengono confrontati utilizzando l'uguaglianza degli oggetti (
Object.equals()
)
Se tutti i parametri soddisfano questi requisiti, Compose salta il componibile durante di ricomposizione.
Potresti utilizzare un componibile per disattivare questa funzione. Vale a dire che potresti
vuoi un componibile riavviabile ma non ignorabile. In questo caso, utilizza
Annotazione @NonSkippableComposable
.
@NonSkippableComposable
@Composable
fun MyNonSkippableComposable {}
Annota le classi come stabili
Se vuoi che un oggetto utilizzi l'uguaglianza degli oggetti anziché l'uguaglianza delle istanze, continuare ad annotare la classe specificata con @Stable. Un esempio di quando quando si osserva un intero elenco di oggetti, origini dati come poiché Room assegnerà nuovi oggetti per ogni elemento nell'elenco in qualsiasi momento modifiche.
Memorizzazione Lambda
La modalità di salto potente consente anche una maggiore memoizzazione delle funzioni lambda. all'interno dei componibili. Con questa funzionalità attivata, ogni funzione lambda all'interno di un funzione componibile verrà memorizzata automaticamente.
Esempi
Per ottenere la memorizzazione dei lambda all'interno degli elementi componibili quando si utilizza un forte skipping,
il compilatore aggrega il tuo lambda con una chiamata remember
. È basata sul
delle immagini 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 l'attivazione efficace dell'opzione Ignora, il compilatore memorizza la funzione lambda aggregandola
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 usando l'uguaglianza delle istanze. Confronta le chiavi stabili l'uguaglianza degli oggetti.
Memorizzazione e ricomposizione
Questa ottimizzazione aumenta notevolmente il numero di elementi componibili che il runtime salta durante la ricomposizione. Senza la memorizzazione, il runtime è molto più probabile per allocare un nuovo parametro lambda a qualsiasi componibile che accetta un parametro lambda di ricomposizione. Di conseguenza, il nuovo lambda ha parametri diversi da l'ultima composizione. Ciò determina la ricomposizione.
Evita la memorizzazione
Se hai un lambda che non vuoi memorizzare, usa @DontMemoize
.
annotazione.
val lambda = @DontMemoize {
...
}
Dimensioni APK
Quando vengono compilati, gli elementi componibili ignorabili generano una quantità di codice maggiore rispetto a quella
elementi componibili non ignorabili. Con questa funzionalità attivata, il compilatore
contrassegna quasi tutti gli elementi componibili come ignorabili e aggrega tutti i lambda in una
remember{...}
. Per questo motivo, l'attivazione di questa modalità ha un limite
impatto sulle dimensioni dell'APK dell'applicazione.
L'attivazione dell'opzione Ignora forte in Now In Android ha aumentato l'APK dimensioni per 4 kB. La differenza di dimensioni dipende in gran parte dal numero di elementi componibili non ignorabili presenti nell'app specificata, ma che devono essere è relativamente minore.