Modalità di salto intensa

Strong Skipping è una modalità disponibile nel compilatore Compose. Quando l'opzione è abilitata, modifica il comportamento del compilatore in due modi:

• Gli elementi componibili con parametri instabili diventano ignorabili
• Le lambda con acquisizioni instabili vengono ricordate

Nota: l'opzione Ignora forte è abilitata per impostazione predefinita in Kotlin 2.0.20.

Attiva la modalità Ignora veloce

Per consentire l'esclusione definitiva di un modulo Gradle in una release precedente, include la seguente opzione nel blocco composeCompiler della configurazione Gradle:

android { ... }

composeCompiler {
   enableStrongSkippingMode = true
}

Possibilità di ignorare i contenuti componibile

La modalità di salto rigorosa allenta alcune delle regole di stabilità normalmente applicate dal compilatore Compose per quanto riguarda le funzioni di salto e composibili. Per impostazione predefinita, il compilatore Compose contrassegna una funzione componibile come ignorabile se tutti i suoi argomenti hanno valori stabili. La modalità di salto forte cambia questo aspetto.

Se l'opzione di salto forzato è attivata, tutte le funzioni composable riavviabili diventano saltabili. Questo si applica indipendentemente dal fatto che i parametri abbiano o meno parametri instabili. Le funzioni componibili non riavviabili rimangono non ignorabili.

Quando saltare

Per determinare se saltare un composable durante la ricompozione, Compose confronta il valore di ciascun parametro con i valori precedenti. Il tipo di confronto dipende dalla stabilità del parametro.

• I parametri instabili vengono confrontati utilizzando l'uguaglianza di istanze (===)
• I parametri stabili vengono confrontati utilizzando l'uguaglianza degli oggetti (Object.equals())

Se tutti i parametri soddisfano questi requisiti, Compose salta il composable durante la ricompozione.

Potresti utilizzare un componibile per disattivare questa funzione. Ad esempio, potresti volere un componibile riavviabile, ma non ignorabile. In questo caso, utilizza l'annotazione @NonSkippableComposable.

@NonSkippableComposable
@Composable
fun MyNonSkippableComposable {}

Contrassegna le lezioni come stabili

Se vuoi che un oggetto utilizzi l'uguaglianza degli oggetti anziché l'uguaglianza delle istanze, continua ad annotare la classe specificata con @Stable. Un esempio di quando potresti dover eseguire questa operazione è quando osservi un intero elenco di oggetti. Le origini dati come Room allocano nuovi oggetti per ogni elemento dell'elenco ogni volta che uno di questi cambia.

Memorizzazione Lambda

La modalità di salto potente consente anche una maggiore memoizzazione delle funzioni lambda all'interno dei componibili. Con l'esclusione avanzata abilitata, ogni funzione lambda all'interno di una funzione componibile verrà memorizzata automaticamente.

Esempi

Per ottenere la memorizzazione delle funzioni lambda all'interno dei composabili quando si utilizza il salto forzato, il compilatore avvolge la funzione lambda con una chiamata remember. È impreziosita dalle acquisizioni dei 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 questa funzionalità abilitata, il compilatore memorizza la funzione lambda eseguendone il wrapping 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 utilizzando l'uguaglianza degli oggetti.

Nota: questo è leggermente diverso da una tipica chiamata remember in cui il runtime di Compose confronta tutte le chiavi utilizzando l'uguaglianza degli oggetti.

Memorizzazione e ricompozione

Questa ottimizzazione aumenta notevolmente il numero di composabili che il runtime salta durante la ricompozione. Senza la memorizzazione nella cache, è molto più probabile che il runtime allochi un nuovo lambda a qualsiasi composable che accetta un parametro lambda durante la ricompozione. Di conseguenza, la nuova funzione lambda ha parametri che non sono uguali all'ultima composizione. Ciò comporta una nuova composizione.

Nota: spesso si pensa erroneamente che i lambda con acquisizioni instabili siano a loro volta oggetti instabili. Non è vero. Il compilatore di Compose considera sempre le lambda stabili. Se, invece, l'opzione Ignora forte è disabilitata, il compilatore non li memorizza e il runtime li alloca durante la ricomposizione. Di conseguenza, le funzionalità lambda con acquisizioni instabili fanno sì che Compose non salti i componenti componibili perché hanno parametri disuguali.

Evita la memorizzazione

Se hai un lambda che non vuoi memorizzare, usa l'annotazione @DontMemoize.

val lambda = @DontMemoize {
    ...
}

Dimensioni APK

Quando vengono compilati, i composabili ignorabili generano più codice rispetto ai composabili non ignorabili. Con l'opzione di salto forzato attivata, il compilatore contras segna quasi tutti i composabili come ignorabili e racchiude tutti i lambda in un remember{...}. Per questo motivo, l'attivazione della modalità Ignora intelligente ha un impatto minimo sulle dimensioni dell'APK della tua applicazione.

L'attivazione del salto forzato in Ora su 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 presenti nell'app specifica, ma che dovrebbero essere relativamente minori.