remember — Schlüsselkonzepte, Werte zwischen Neuzusammensetzungen erhalten

Was ist remember in Jetpack Compose

remember ist eine eingebaute Jetpack Compose-Funktion aus dem Paket androidx.compose.runtime, die ein Objekt erstellt, das seinen Wert zwischen aufeinanderfolgenden Aufrufen einer Composable-Funktion erhält. Technisch arbeitet remember mit Slots — speziellen Speicherzellen, die für jede Funktionsaufrufposition im UI-Baum zugewiesen werden. Solange die Funktion in der Komposition bleibt (nicht durch eine if-Bedingung entfernt wird), gibt remember bei jeder Neuzusammensetzung den gespeicherten Wert zurück.

Die Syntax von remember ist einfach: Innerhalb geschweifter Klammern wird der Berechnungsblock für den Anfangswert angegeben. Der Block wird nur einmal ausgeführt — während der ersten Komposition der Funktion. Alle nachfolgenden Neuzusammensetzungen geben den bereits gespeicherten Wert zurück, ohne den Block erneut auszuführen. Wenn jedoch ein Schlüsselparameter angegeben wird, wird der Block bei Änderung des Schlüssels erneut ausgeführt, was eine Neuberechnung des Werts auf Basis der Eingabedaten ermöglicht.

remember ist keine Kotlin-Magie — es ist eine einfache Funktion mit einem Schlüsselparameter und einem Berechnungs-Lambda. Seine interne Implementierung verwendet Composer, um in Slots zu lesen und zu schreiben. Der Kotlin-Compiler erzeugt beim Anblick eines remember-Aufrufs Code, der auf den aktuellen CompositionContext zugreift und die Slots verwaltet. Das bedeutet, dass remember nur innerhalb einer Composable-Funktion oder einer anderen Funktion im Kompositionskontext aufgerufen werden kann.

Arten von remember: remember, rememberSaveable, derivedStateOf

In Jetpack Compose gibt es drei Hauptvarianten von remember, jede mit ihrem eigenen Zweck. Das basische remember erhält den Wert nur im Speicher des aktuellen Prozesses — bei Bildschirmdrehung (Konfigurationsänderung) erstellt Compose die Komposition neu und alle remember-Werte werden zurückgesetzt. Zum Erhalten von Daten bei Konfigurationsänderungen und Prozessstopp wird rememberSaveable verwendet.

rememberSaveable serialisiert den Wert über den SavedStateHandle- oder Parcelable-Mechanismus in ein Bundle. Dies ermöglicht das Überleben von Bildschirmdrehung, der Einstellung "Aktivitäten nicht beibehalten" und sogar der vorübergehenden App-Minimierung. Allerdings schränkt rememberSaveable den Typ der speicherbaren Daten ein: Sie müssen Primitive, Parcelable, Serializable sein oder einen Saver-Konverter unterstützen.

derivedStateOf ist kein Erhaltungsmechanismus, sondern eine Optimierung. Es erstellt einen State, dessen Wert aus anderen State-Objekten berechnet wird. derivedStateOf reagiert auf Änderungen der Quellzustände, berechnet den Wert aber nur neu, wenn es Abonnenten gibt. Wenn die aktuelle Neuzusammensetzung derivedStateOf nicht liest, wird die Berechnung nicht durchgeführt, was Ressourcen bei häufigen, aber unnötigen Aktualisierungen spart.

@Composable
fun RememberVariants() {
    // 1. Basis-remember: bleibt bis zum Verlassen der Komposition erhalten
    val createdAt = remember { System.currentTimeMillis() }

    // 2. rememberSaveable: überlebt Bildschirmdrehung
    var username by rememberSaveable { mutableStateOf("") }

    // 3. derivedStateOf: wird nur bei Bedarf berechnet
    val isButtonVisible = remember {
        derivedStateOf { username.length() > 3 }
    }

    Text("Erstellt: $createdAt")
    TextField(value = username, onValueChange = { username = it })

    if (isButtonVisible.value) {
        Text("Schaltfläche wird angezeigt")
    }
}

remember vs rememberSaveable: wann verwendet man was

Die Wahl zwischen remember und rememberSaveable hängt davon ab, wie kritisch es ist, Daten bei Konfigurationsänderungen zu erhalten. Für temporäre Zustände, deren Verlust bei Drehung nicht wichtig ist (Animation, aktuelle Scrollposition, Fokus-Zustand) — reicht normales remember. Für kritische Daten (Text in Formularen, ausgewählte Elemente, Kontrollkästchen) — verwenden Sie rememberSaveable.

Leistung: rememberSaveable ist langsamer als normales remember, da es eine Serialisierung in ein Bundle erfordert. Verwenden Sie rememberSaveable nur für Daten, die wirklich die Neuerstellung der Activity überleben müssen. Für alles andere — einfaches remember. Übermäßige Verwendung von rememberSaveable führt zu Verlangsamungen bei Bildschirmdrehungen und beim Wechsel zwischen Apps.

Wenn Sie mit Klassen arbeiten, die Parcelable oder Serializable nicht unterstützen, verwenden Sie Saver — einen Konverter, der definiert, wie das Objekt gespeichert und wiederhergestellt wird. Saver wird durch ein Paar von Lambdas beschrieben: save (konvertiert das Objekt in einen speicherbaren Typ) und restore (stellt das Objekt aus gespeicherten Daten wieder her). Ein Standard-Saver ist bereits für mutableStateListOf und mutableStateMapOf implementiert.

Beispiele für die Verwendung von remember in realen Projekten

Betrachten wir ein typisches Szenario — einen Profilbearbeitungsbildschirm, in dem remember für mehrere Zwecke verwendet wird: Speichern des Zustands von Formularfeldern, Berechnen abgeleiteter Werte und Zwischenspeichern rechenintensiver Operationen.

data class ProfileUiState(
    val name: String = "",
    val bio: String = "",
    val isSaving: Boolean = false
)

@Composable
fun ProfileEditor() {
    var state by rememberSaveable { mutableStateOf(ProfileUiState()) }
    val isValid = remember {
        derivedStateOf { state.name.isNotBlank() && state.bio.length() <= 500 }
    }

    val bioWarning = remember(state.bio) {
        if (state.bio.length() > 400) {
            "${500 - state.bio.length} chars left"
        } else null
    }

    Column(modifier = Modifier.padding(16.dp)) {
        OutlinedTextField(
            value = state.name,
            onValueChange = { state = state.copy(name = it) },
            label = { Text("Name") }
        )

        OutlinedTextField(
            value = state.bio,
            onValueChange = { state = state.copy(bio = it) },
            label = { Text("Über") }
        )

        bioWarning?.let { Text(it, color = MaterialTheme.colorScheme.error) }

        Button(onClick = { /* save */ },
            enabled = isValid.value) {
            Text("Speichern")
        }
    }
}

Im Beispiel wird der Zustand über rememberSaveable gespeichert — Text geht bei Bildschirmdrehung nicht verloren. isValid wird über derivedStateOf berechnet, was unnötige Berechnungen während Neuzusammensetzungen verhindert. bioWarning verwendet remember mit dem Schlüssel bio — dies ist eine teure Berechnung (optional, zur Demonstration), die nur bei Änderung von bio neu berechnet wird, nicht bei jeder Neuzusammensetzung.

Abgeleitete Zustände und remember mit Schlüsseln

Abgeleitete Zustände sind Werte, die aus anderen State-Objekten berechnet werden. Anstatt sie bei jeder Neuzusammensetzung zu berechnen und CPU für identische Ergebnisse zu verschwenden, berechnet remember mit derivedStateOf den Wert nur, wenn sich die Quellen ändern. Dies ist besonders nützlich für Filterung, Sortierung und Datenaggregation.

remember mit Schlüsseln (remember(key) { calculation }) ist ein weiterer Optimierungsmechanismus. Wenn sich der Schlüssel seit der letzten Neuzusammensetzung nicht geändert hat, wird der Berechnungsblock nicht ausgeführt und der zwischengespeicherte Wert zurückgegeben. Dies ist praktisch zum Zwischenspeichern von Objekten, deren Erstellung teuer ist: Datumsformatierung, JSON-Parsing, Erstellung großer unveränderlicher Sammlungen.

@Composable
fun SearchResults(allItems: List<Item>, query: String) {
    // derivedStateOf: Filter wird nur bei Eingabeänderungen neu berechnet
    val filtered = remember {
        derivedStateOf {
            allItems.filter { it.title.contains(query, true) }
        }
    }

    // remember mit Schlüssel: formatierte Statistiken werden nur bei Abfrageänderung neu berechnet
    val statsText = remember(query) {
        "Results for query \"$query\": ${filtered.value.size}"
    }

    Text(statsText)
    LazyColumn {
        items(filtered.value, key = { it.id }) { item ->
            Text(item.title)
        }
    }
}

filtered ist ein derivedStateOf, das automatisch neu berechnet, wenn sich allItems oder query ändern. statsText verwendet remember(query) — die teure String-Formatierung wird nur durchgeführt, wenn sich die Suchanfrage ändert. Die Kombination von derivedStateOf und remember mit Schlüsseln bietet maximale Leistung: Der abgeleitete Zustand wird nur bei Bedarf berechnet und komplexe Objekte werden zwischengespeichert, bis sich der Schlüssel ändert.