Starker Sprungmodus

„Strong Skipping“ ist ein Modus, der im Compose-Compiler verfügbar ist. Wenn diese Option aktiviert ist, ändert sich das Verhalten des Compilers auf zwei Arten:

Starken Modus zum Überspringen aktivieren

Wenn Sie das starke Überspringen für ein Gradle-Modul in einem früheren Release aktivieren möchten, fügen Sie die folgende Option in den composeCompiler-Block Ihrer Gradle-Konfiguration ein:

android { ... }

composeCompiler {
   enableStrongSkippingMode = true
}

Zusammensetzbare Überspringbarkeit

Im Modus „Starkes Überspringen“ werden einige der Stabilitätsregeln gelockert, die normalerweise vom Compose-Compiler für übersprungene und kombinierbare Funktionen angewendet werden. Standardmäßig kennzeichnet der Compose-Compiler eine kombinierbare Funktion als überspringbar, wenn alle ihre Argumente stabile Werte haben. Der starke Überspringen-Modus ändert dies.

Wenn die Funktion „Starkes Überspringen“ aktiviert ist, können alle neustartbaren kompositionsfähigen Funktionen übersprungen werden. Dies gilt unabhängig davon, ob sie instabile Parameter enthalten. Nicht neu startbare kompositionsfähige Funktionen können weiterhin nicht übersprungen werden.

Überspringen

Um zu ermitteln, ob eine zusammensetzbare Funktion bei der Neuzusammensetzung übersprungen werden soll, vergleicht die Compose-Funktion den Wert jedes Parameters mit den vorherigen Werten. Die Art des Vergleichs hängt von der Stabilität des Parameters ab.

  • Instabilitäten werden anhand der Instanzgleichheit (===) verglichen.
  • Stabile Parameter werden mithilfe von Objektgleichheit (Object.equals()) verglichen

Wenn alle Parameter diese Anforderungen erfüllen, wird die zusammensetzbare Funktion bei der Neuzusammensetzung übersprungen.

Du kannst für ein Composed-Element festlegen, dass es nicht übersprungen werden kann. Das heißt, Sie könnten eine neustartfähige, aber nicht überspringbare zusammensetzbare Funktion verwenden. Verwenden Sie in diesem Fall die Annotation @NonSkippableComposable.

@NonSkippableComposable
@Composable
fun MyNonSkippableComposable {}

Klassen als stabil kennzeichnen

Wenn Sie möchten, dass ein Objekt die Objektgleichheit anstelle der Instanzgleichheit verwendet, annotieren Sie die angegebene Klasse weiterhin mit @Stable. Das kann beispielsweise der Fall sein, wenn Sie eine ganze Liste von Objekten beobachten. Datenquellen wie Room weisen dann jedes Mal, wenn sich eines der Objekte ändert, jedem Element in der Liste neue Objekte zu.

Lambda-Speicherung

Der starke Überspringen-Modus ermöglicht außerdem eine bessere Speicherung von Lambdas in zusammensetzbaren Funktionen. Wenn „Starkes Überspringen“ aktiviert ist, wird jede Lambda-Funktion in einer zusammensetzbaren Funktion automatisch gespeichert.

Beispiele

Damit Lambdas in zusammensetzbaren Funktionen gespeichert werden, wenn ein starker Überspringen verwendet wird, umschließt der Compiler die Lambda-Funktion mit einem remember-Aufruf. Sie ist mit den Aufnahmen der Lambda verknüpft.

Angenommen, Sie haben eine Lambda-Funktion wie im folgenden Beispiel:

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

Wenn starkes Überspringen aktiviert ist, merkt sich der Compiler die Lambda-Funktion, indem sie sie in einen remember-Aufruf umschließt:

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

Die Schlüssel folgen denselben Vergleichsregeln wie zusammensetzbare Funktionen. Die Laufzeit vergleicht instabile Schlüssel anhand der Instanzgleichheit. Stabile Schlüssel werden anhand der Objektgleichheit verglichen.

Memoisierung und Neuzusammensetzung

Durch diese Optimierung wird die Anzahl der Composeables, die die Laufzeit beim Neuzusammenstellen überspringt, erheblich erhöht. Ohne Memoisierung ist es bei der Laufzeit viel wahrscheinlicher, dass jedem Composeable, das einen Lambda-Parameter annimmt, bei der Neuzusammensetzung ein neues Lambda zugewiesen wird. Daher hat die neue Lambda-Funktion Parameter, die nicht mit der letzten Zusammensetzung übereinstimmen. Dies führt zu einer Neuzusammensetzung.

Erinnerung vermeiden

Wenn Sie eine Lambda-Funktion haben, die Sie sich nicht merken möchten, verwenden Sie die Anmerkung @DontMemoize.

val lambda = @DontMemoize {
    ...
}

APK-Größe

Beim Kompilieren führen überspringbare Composables zu mehr generierten Code als zusammensetzbare Funktionen, die nicht überspringbar sind. Wenn die Option „Starkes Überspringen“ aktiviert ist, markiert der Compiler fast alle zusammensetzbaren Funktionen als überspringbar und fasst alle Lambdas in einem remember{...} zusammen. Daher hat die Aktivierung des Modus für starkes Überspringen nur sehr geringe Auswirkungen auf die APK-Größe Ihrer App.

Durch Aktivieren des starken Überspringens in Now In Android wurde die APK-Größe um 4 KB erhöht. Die Größenunterschiede hängen weitgehend von der Anzahl der zuvor nicht überspringbaren Composeables ab, die in der jeweiligen App vorhanden waren. Sie sollten jedoch relativ gering sein.