Modalità di salto intensa

Il salto forzato è una modalità disponibile nel compilatore di Compose. Se abilitata, modifica il comportamento del compilatore in due modi:

• I composabili con parametri instabili diventano scontrabili
• Le lambda con acquisizioni instabili vengono ricordate

Nota: il salto avanzato è abilitato per impostazione predefinita in Kotlin 2.0.20. L'elenco completo delle opzioni è disponibile nel riferimento del plug-in Gradle del compilatore Compose.

Attivare la modalità di salto forzato

Il salto avanzato è abilitato per impostazione predefinita in Kotlin 2.0.20.

Per attivare il salto forzato per un modulo Gradle in una release precedente alla 2.0.20, includere la seguente opzione nel blocco composeCompiler della configurazione di Gradle:

android { ... }

composeCompiler {
   enableStrongSkippingMode = true
}

Possibilità di ignorare i contenuti componibile

La modalità di salto forte 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 avanzamento veloce modifica questa impostazione.

Con l'opzione di salto forzato attivata, tutte le funzioni composable riavviabili diventano saltabili. Questo vale indipendentemente dal fatto che abbiano o meno parametri instabili. Le funzioni composable 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 relativi 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 voler disattivare il salto forte in un composable. In altre parole, potresti volere un composable 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 di oggetti anziché l'uguaglianza di 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 nella cache di Lambda

La modalità di salto forzato consente inoltre una maggiore memorizzazione delle funzioni lambda all'interno dei composabili. Se l'opzione di salto forzato è attivata, ogni 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. È associato alle acquisizioni della lambda.

Considera un caso in cui hai una lambda come nell'esempio seguente:

@Composable
fun MyComposable(unstableObject: Unstable, stableObject: Stable) {
    val lambda = {
        use(unstableObject)
        use(stableObject)
    }
}

Con l'opzione di salto forzato abilitata, il compilatore memorizza nella cache la funzione lambda racchiudendola 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 chiamata remember tipica 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 diversi da quelli dell'ultima composizione. Ciò comporta una nuova composizione.

Nota: un errore comune è pensare che le funzioni lambda con acquisizioni instabili siano esse stesse oggetti instabili. Non è vero. Il compilatore Compose considera sempre le lambda stabili. Tuttavia, se l'opzione di omesso forzato è disattivata, il compilatore non le memorizza nella cache e il runtime le alloca durante la ricostituzione. Di conseguenza, le lambda con acquisizioni instabili fanno sì che Compose non salti i composabili perché hanno parametri non uguali.

Evita la memorizzazione nella cache

Se hai una funzione lambda che non vuoi memorizzare nella cache, utilizza 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{...}. Di conseguenza, l'attivazione della modalità di salto forzato ha un impatto molto ridotto sulle dimensioni dell'APK dell'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 composabili precedentemente non ignorabili presenti nell'app in questione, ma dovrebbe essere relativamente ridotta.