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:

Modus für starkes Überspringen aktivieren

In Kotlin 2.0.20 ist das Überspringen von Frames standardmäßig aktiviert.

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

android { ... }

composeCompiler {
   enableStrongSkippingMode = true
}

Komponierbare Ü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. Das ändert sich mit dem Modus „Starkes Überspringen“.

Wenn die Funktion „Starkes Überspringen“ aktiviert ist, können alle neu startbaren kompositionsfähigen Funktionen übersprungen werden. Das gilt unabhängig davon, ob die Parameter instabil sind oder nicht. Nicht neu startbare kompositionsfähige Funktionen können weiterhin nicht übersprungen werden.

Wann kann ich Inhalte überspringen?

Um zu bestimmen, ob ein Composeable 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.

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

Wenn alle Parameter diese Anforderungen erfüllen, wird das Composeable bei der Neuzusammensetzung übersprungen.

Du kannst für ein Composed-Element festlegen, dass es nicht übersprungen werden kann. Das heißt, Sie möchten möglicherweise ein wiederstartbares, aber nicht überspringbares Composeable. Verwenden Sie in diesem Fall die Annotation @NonSkippableComposable.

@NonSkippableComposable
@Composable
fun MyNonSkippableComposable {}

Klassen als stabil kennzeichnen

Wenn Sie für ein Objekt die Objektgleichheit anstelle der Instanzgleichheit verwenden möchten, annotieren Sie die entsprechende 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-Memoisierung

Der Modus „Strenges Überspringen“ ermöglicht außerdem eine bessere Memorisierung von Lambdas in Composeables. Wenn die Funktion „Starkes Überspringen“ aktiviert ist, wird jedes Lambda in einer kombinierbaren Funktion automatisch gespeichert.

Beispiele

Um Lambdas in Composeables bei Verwendung von starkem Überspringen zu merken, umschließt der Compiler Ihr Lambda 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 die Funktion „Starkes Überspringen“ aktiviert ist, speichert der Compiler die Lambda-Funktion, indem er sie in einen remember-Aufruf einbettet:

@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 kombinierbare Funktionen. Die Laufzeit vergleicht instabile Schlüssel anhand der Instanzgleichheit. Dabei werden stabile Schlüssel 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 einem Composable, 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.

Vermeiden Sie die Memoisierung.

Wenn Sie ein Lambda haben, das nicht zwischengespeichert werden soll, verwenden Sie die Anmerkung @DontMemoize.

val lambda = @DontMemoize {
    ...
}

APK-Größe

Beim Kompilieren führen überspringbare Composables zu mehr generiertem Code als nicht überspringbare Composables. Wenn die Funktion „Starkes Überspringen“ aktiviert ist, kennzeichnet der Compiler fast alle Composeables als überspringbar und umschließt alle Lambdas in einem remember{...}. Daher hat die Aktivierung des Modus für das Überspringen von Werbung nur einen sehr geringen Einfluss auf die APK-Größe Ihrer Anwendung.

Durch die Aktivierung der Funktion „Starkes Überspringen“ unter Jetzt bei Android ist die APK-Größe um 4 KB gestiegen. Die Größenänderung hängt hauptsächlich von der Anzahl der zuvor nicht überspringbaren Composeables ab, die in der jeweiligen App vorhanden waren. Sie sollte jedoch relativ gering sein.