Modalità di salto intensa

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

di Gemini Advanced.

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.