Starker Sprungmodus

Der Modus „Starkes Skipping“ ist im Compiler „Compose“ verfügbar. Wenn sie aktiviert ist, ändert das Verhalten des Compilers auf zwei Arten:

• Zusammensetzbare Elemente mit instabilen Parametern werden überspringbar
• Lambdas mit instabilen Aufnahmen erinnern wir uns

Starken Modus zum Überspringen aktivieren

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

android { ... }

composeCompiler {
   enableStrongSkippingMode = true
}

Zusammensetzbare Überspringbarkeit

Durch den starken Überspringenmodus werden einige der normalerweise angewendeten Stabilitätsregeln gelockert. vom Compose-Compiler beim Überspringen und zusammensetzbaren Funktionen. Von standardmäßig aktiviert, markiert der Compiler Compose eine zusammensetzbare Funktion als überspringbar, wenn alle haben ihre Argumente stabile Werte. Der starke Überspringen-Modus ändert dies.

Wenn starkes Überspringen aktiviert ist, werden alle neustartbaren zusammensetzbaren Funktionen überspringbar. Dies gilt unabhängig davon, ob sie instabile Parameter enthalten. Nicht neustartbare zusammensetzbare Funktionen können nicht übersprungen werden.

Überspringen

Um zu ermitteln, ob eine zusammensetzbare Funktion bei der Neuzusammensetzung übersprungen werden soll, vergleicht die Funktion „Compose“ Wert jedes Parameters durch die vorherigen Werte ersetzen. 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 während Neuzusammensetzung.

In einer zusammensetzbaren Funktion kann das starke Überspringen deaktiviert werden. Das heißt, Sie könnten sich eine neustartfähige, aber nicht überspringbare zusammensetzbare Funktion. Verwenden Sie in diesem Fall die Methode @NonSkippableComposable-Anmerkung.

@NonSkippableComposable
@Composable
fun MyNonSkippableComposable {}

Klassen als stabil kennzeichnen

Wenn Sie ein Objekt verwenden möchten, das die Objektgleichheit anstelle der Instanzgleichheit verwendet, die angegebene Klasse weiter mit @Stable annotieren. Ein Beispiel dafür, wann Sie wenn Sie eine ganze Liste von Objekten, Datenquellen wie Raum weist jedem Element in der Liste jederzeit neue Objekte zu. ändern.

Lambda-Speicherung

Der starke Überspringen-Modus ermöglicht auch mehr Ausmerkungen an Lambdas. zusammensetzbaren Funktionen verwenden. Wenn die Funktion „Starkes Überspringen“ aktiviert ist, wird jede Lambda-Funktion in einem zusammensetzbaren Funktionen werden automatisch gespeichert.

Beispiele

Um Lambdas in zusammensetzbaren Funktionen auswendig zu lernen, Der Compiler schließt deine Lambda-Funktion mit einem remember-Aufruf ein. Sie ist mit dem von Lambda erfasst.

Stellen Sie sich einen Fall vor, bei dem Sie eine Lambda-Funktion haben, 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 das Lambda, indem es es einen remember-Aufruf:

@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. Laufzeit vergleicht instabile Schlüssel anhand der Instanzgleichheit. Stabile Schlüssel werden anhand der Objektgleichheit.

Erinnerung und Neuzusammensetzung

Durch diese Optimierung wird die Anzahl der zusammensetzbaren Funktionen, die die Laufzeit bei der Neuzusammensetzung überspringt. Ohne Erinnerung ist die Laufzeit viel wahrscheinlicher, einer zusammensetzbaren Funktion eine neue Lambda-Funktion zuzuweisen, die während Neuzusammensetzung. Daher hat die neue Lambda-Funktion Parameter, die nicht gleich der letzten Komposition. Dies führt zu einer Neuzusammensetzung.

Erinnerung vermeiden

Wenn du ein Lambda hast, das du dir nicht merken möchtest, verwende das @DontMemoize .

val lambda = @DontMemoize {
    ...
}

APK-Größe

Überspringbare Composables erzeugen nach der Kompilierung mehr generierten Code als zusammensetzbaren Funktionen, die nicht überspringbar sind. Wenn starkes Überspringen aktiviert ist, fast alle zusammensetzbaren Funktionen als überspringbar kennzeichnet und alle Lambdas in einem remember{...} Aus diesem Grund hat die Aktivierung des starken Überspringenmodus auf die APK-Größe deiner App.

Durch die Aktivierung von starkem Überspringen in Now In Android wurde das APK mit 4 KB groß. Der Größenunterschied hängt stark von der Anzahl der zuvor nicht überspringbaren zusammensetzbaren Funktionen, die in der jeweiligen App vorhanden waren, relativ klein.