Starker Sprungmodus

Starkes Überspringen ist ein Modus, der im Compose-Compiler verfügbar ist. Wenn diese Option aktiviert ist, ändert es das Verhalten des Compilers auf zwei Arten:

Modus für starkes Überspringen aktivieren

Um starkes Überspringen für ein Gradle-Modul zu aktivieren, fügen Sie die folgende Option in den composeCompiler-Block Ihrer Gradle-Konfiguration ein:

android { ... }

composeCompiler {
   enableStrongSkippingMode = true
}

Überspringbarkeit zusammensetzbar

Der starke Überspringungsmodus locker einige der stability-Regeln, die normalerweise vom Compose-Compiler für Überspringen und zusammensetzbare Funktionen angewendet werden. Standardmäßig markiert der Compose-Compiler eine zusammensetzbare Funktion als überspringbar, wenn alle Argumente stabile Werte haben. Mit dem starken Überspringenmodus ändert sich das.

Wenn die Option „Starkes Überspringen“ aktiviert ist, werden alle neustartbaren zusammensetzbaren Funktionen überspringbar. Dies gilt unabhängig davon, ob sie instabile Parameter haben oder nicht. Zusammensetzbare Funktionen, die nicht neu gestartet werden können, sind nicht überspringbar.

Wann überspringen

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

  • Instabile Parameter werden anhand der Instanzgleichheit (===) verglichen
  • Stabile Parameter werden anhand der Objektgleichheit (Object.equals()) verglichen.

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

Bei einer zusammensetzbaren Funktion kann das starke Überspringen deaktiviert werden. Vielleicht möchten Sie also eine neustartfähige, aber nicht überspringbare zusammensetzbare Funktion. Verwenden Sie in diesem Fall die Annotation @NonSkippableComposable.

@NonSkippableComposable
@Composable
fun MyNonSkippableComposable {}

Klassen als stabil annotieren

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

Lambda-Einprägung

Der starke Überspringungsmodus ermöglicht auch eine stärkere Memoisierung von Lambdas in zusammensetzbaren Funktionen. Wenn das starke Überspringen aktiviert ist, wird jedes Lambda in einer zusammensetzbaren Funktion automatisch gespeichert.

Beispiele

Damit Lambdas in zusammensetzbaren Funktionen bei starkem Überspringen gespeichert werden, schließt der Compiler Ihr Lambda mit einem remember-Aufruf ein. Sie ist mit den Einfängen des Lambdas angegeben.

Nehmen wir einen Fall, bei dem Sie ein Lambda haben, wie im folgenden Beispiel:

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

Wenn das starke Überspringen aktiviert ist, speichert der Compiler das Lambda, indem es es in einen remember-Aufruf einbindet:

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

Für die Schlüssel gelten dieselben Vergleichsregeln wie für zusammensetzbare Funktionen. Die Laufzeit vergleicht instabile Schlüssel anhand der Instanzgleichheit. Dabei werden stabile Schlüssel anhand der Objektgleichheit verglichen.

Erinnerung und Neuzusammensetzung

Durch diese Optimierung wird die Anzahl der zusammensetzbaren Funktionen, die von der Laufzeit während der Neuzusammensetzung übersprungen werden, erheblich erhöht. Ohne Erinnerung weist die Laufzeit jeder zusammensetzbaren Funktion, die während der Neuzusammensetzung einen Lambda-Parameter annimmt, viel eher eine neue Lambda-Funktion zu. Daher hat das neue Lambda Parameter, die nicht der letzten Zusammensetzung entsprechen. Dies führt zu einer Neuzusammensetzung.

Auswendig lernen

Wenn du eine Lambda-Funktion hast, die du dir nicht merken möchtest, verwende die Anmerkung @DontMemoize.

val lambda = @DontMemoize {
    ...
}

APK-Größe

Überspringbare zusammensetzbare Funktionen, die kompiliert sind, generieren mehr Code als zusammensetzbare Funktionen, die nicht überspringbar sind. Wenn das starke Überspringen aktiviert ist, markiert der Compiler fast alle zusammensetzbaren Funktionen als überspringbar und packt alle Lambdas in eine remember{...}. Aus diesem Grund hat das Aktivieren des Modus für starkes Überspringen einen sehr geringen Einfluss 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. Der Größenunterschied hängt hauptsächlich von der Anzahl der zuvor nicht überspringbaren zusammensetzbaren Funktionen ab, die in der jeweiligen App vorhanden waren, aber relativ gering sein sollten.