Modalità di salto intensa

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.