remember — nyckelbegrepp, bevara värden mellan rekompositioner

Vad är remember i Jetpack Compose

remember — är en inbyggd funktion i Jetpack Compose från paketet androidx.compose.runtime som skapar ett objekt som bevarar sitt värde mellan på varandra följande anrop av Composable-funktionen. Tekniskt sett arbetar remember med platser — speciella minnesceller som tilldelats varje anropsposition för funktionen i UI-trädet. Så länge funktionen förblir i kompositionen (inte har tagits bort via ett if-villkor) kommer remember att returnera det sparade värdet vid varje rekomposition.

Syntaxen för remember är enkel: inom klammerparenteser anges beräkningsblocket för startvärdet. Blocket körs endast en gång — vid den första kompositionen av funktionen. Alla efterföljande rekompositioner returnerar det redan sparade värdet utan att anropa blocket igen. Om en nyckel (parameter key) anges, körs blocket igen när nyckeln ändras, vilket gör det möjligt att beräkna om värdet baserat på indata.

remember är inte Kotlin-magi — det är en enkel funktion med en key-parameter och en beräkningslambda. Dess interna implementering använder Composer för att läsa och skriva till platser. Kotlin-kompilatorn, när den ser ett anrop till remember, genererar kod som får åtkomst till den aktuella CompositionContext och hanterar platserna. Detta innebär att remember endast kan anropas inuti en Composable-funktion eller en annan funktion i kompositionskontexten.

Typer av remember: remember, rememberSaveable, derivedStateOf

I Jetpack Compose finns det tre huvudvarianter av remember, var och en med sitt eget syfte. Grundläggande remember bevarar värdet endast i den aktuella processens minne — vid skärmrotation (config change) återskapar Compose Composition och alla remember-värden återställs. För att bevara data vid konfigurationsändringar och processstopp används rememberSaveable.

rememberSaveable serialiserar värdet till Bundle via SavedStateHandle- eller Parcelable-mekanismen. Detta gör det möjligt att överleva skärmrotation, anropet “Spara inte aktiviteter” och även tillfällig minimering av appen. Dock lägger rememberSaveable begränsningar på typen av data som sparas: de måste vara primitiver, Parcelable, Serializable eller stödja Saver-omvandlaren.

derivedStateOf — är inte en lagringsmekanism, utan en optimering. Det skapar ett State vars värde beräknas baserat på andra State-objekt. derivedStateOf reagerar på förändringar i källtillstånd, men beräknar om värdet endast när det finns prenumeranter. Om den aktuella rekompositionen inte läser derivedStateOf utförs ingen beräkning, vilket sparar resurser vid frekventa men oönskade uppdateringar.

@Composable
fun RememberVariants() {
    // 1. Grundläggande remember: varar tills kompositionen lämnas
    val createdAt = remember { System.currentTimeMillis() }

    // 2. rememberSaveable: överlever skärmrotation
    var username by rememberSaveable { mutableStateOf("") }

    // 3. derivedStateOf: beräknas endast när det behövs
    val isButtonVisible = remember {
        derivedStateOf { username.length() > 3 }
    }

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

    if (isButtonVisible.value) {
        Text("Knappen kommer att visas")
    }
}

remember vs rememberSaveable: när ska man använda vad

Valet mellan remember och rememberSaveable beror på hur kritisk databevarandet är vid konfigurationsändringar. För temporära tillstånd vars förlust vid rotation inte är viktig (animation, aktuell scrollposition, fokusstatus) — räcker vanlig remember. För kritisk data (text i formulär, valda element, kryssrutor) — använd rememberSaveable.

Prestanda för rememberSaveable är lägre än för vanlig remember eftersom det kräver serialisering till Bundle. Använd rememberSaveable endast för data som verkligen måste överleva återskapning av Activity. För allt annat — vanlig remember. Överdriven användning av rememberSaveable leder till långsamhet vid skärmrotation och växling mellan appar.

Om du arbetar med klasser som inte stöder Parcelable eller Serializable, använd Saver — en omvandlare som bestämmer hur ett objekt ska sparas och återställas. Saver beskrivs av ett par lambda: save (omvandlar objektet till en sparbar typ) och restore (återställer objektet från sparad data). Standard Saver är redan implementerad för mutableStateListOf och mutableStateMapOf.

Exempel på användning av remember i verkliga projekt

Låt oss titta på ett typiskt scenario — profiledigeringsskärmen, där remember används för flera ändamål: lagring av formulärfälts tillstånd, beräkning av härledda värden och cachning av beräkningstunga operationer.

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("Namn") }
        )

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

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

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

I exemplet sparas tillståndet via rememberSaveable — vid skärmrotation försvinner inte texten. isValid beräknas via derivedStateOf, vilket förhindrar onödiga beräkningar vid rekompositioner. bioWarning använder remember med nyckeln bio — detta är en dyr beräkning (valfritt, för demonstration) som endast beräknas om när bio ändras, inte vid varje rekomposition.

Härledda tillstånd och remember med nycklar

Härledda tillstånd (derived state) är värden som beräknas från andra State-objekt. Istället för att beräkna dem vid varje rekomposition och slösa CPU på identiska resultat, beräknar remember med derivedStateOf värdet endast när källorna ändras. Detta är särskilt användbart för filtrering, sortering och aggregering av data.

remember med nycklar (remember(key) { calculation }) — en annan optimeringsmekanism. Om nyckeln inte har ändrats sedan föregående rekomposition, körs inte beräkningsblocket och det cachade värdet returneras. Detta är praktiskt för cachning av objekt vars skapande är dyrt: datumformatering, JSON-tolkning, skapande av stora oföränderliga samlingar.

@Composable
fun SearchResults(allItems: List<Item>, query: String) {
    // derivedStateOf: filter beräknas om endast när indata ändras
    val filtered = remember {
        derivedStateOf {
            allItems.filter { it.title.contains(query, true) }
        }
    }

    // remember med nyckel: formaterad statistik beräknas om endast vid frågeändring
    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 — är en derivedStateOf som automatiskt beräknas om när allItems eller query ändras. statsText använder remember(query) — dyr strängformatering utförs endast när sökfrågan ändras. Kombinationen av derivedStateOf och remember med nycklar ger maximal prestanda: det härledda tillståndet beräknas endast när det behövs, och komplexa objekt cachas tills nyckeln ändras.