remember — ключови понятия, запазване на стойности между рекомпозициите

Какво е remember в Jetpack Compose

remember — е вградена функция на Jetpack Compose от пакета androidx.compose.runtime, която създава обект, запазващ стойността си между последователни извиквания на Composable функция. Технически, remember работи със слотове — специални клетки памет, разпределени за всяка позиция на извикване на функцията в UI дървото. Докато функцията остава в композицията (не е премахната чрез if условие), remember ще връща запазената стойност при всяка рекомпозиция.

Синтаксисът на remember е прост: във фигурни скоби се посочва блокът за изчисление на началната стойност. Блокът се изпълнява само веднъж — при първата композиция на функцията. Всички следващи рекомпозиции връщат вече запазената стойност, без да извикват блока отново. Ако обаче е посочен ключ (параметър key), блокът се изпълнява отново при промяна на ключа, което позволява преизчисляване на стойността въз основа на входните данни.

remember не е магия на Kotlin — това е проста функция с параметър key и ламбда за изчисление. Вътрешната ѝ реализация използва Composer за четене и запис в слотовете. Компилаторът на Kotlin, виждайки извикване на remember, генерира код, който достъпва текущия CompositionContext и управлява слотовете. Това означава, че remember може да бъде извикван само вътре в Composable функция или друга функция в контекста на композицията.

Видове remember: remember, rememberSaveable, derivedStateOf

В Jetpack Compose съществуват три основни варианта на remember, всеки със свое предназначение. Базовият remember запазва стойността само в паметта на текущия процес — при завъртане на екрана (config change) Compose пресъздава Composition и всички remember стойности се нулират. За запазване на данни при конфигурационни промени и спиране на процеса се използва rememberSaveable.

rememberSaveable сериализира стойността в Bundle чрез механизма SavedStateHandle или Parcelable. Това позволява оцеляване при завъртане на екрана, извикване на „Не запазвай активности” и дори временно минимизиране на приложението. Въпреки това, rememberSaveable налага ограничения върху типа на запазваните данни: те трябва да бъдат примитиви, Parcelable, Serializable или да поддържат Saver конвертор.

derivedStateOf — не е механизъм за запазване, а оптимизация. Създава State, чиято стойност се изчислява на базата на други State обекти. derivedStateOf реагира на промени в изходните състояния, но преизчислява стойността само когато има абонати. Ако текущата рекомпозиция не чете derivedStateOf, изчислението не се изпълнява, което спестява ресурси при чести, но ненужни актуализации.

@Composable
fun RememberVariants() {
    // 1. Основен remember: продължава до напускане на композицията
    val createdAt = remember { System.currentTimeMillis() }

    // 2. rememberSaveable: оцелява при завъртане на екрана
    var username by rememberSaveable { mutableStateOf("") }

    // 3. derivedStateOf: изчислява се само когато е необходимо
    val isButtonVisible = remember {
        derivedStateOf { username.length() > 3 }
    }

    Text("Създадено: $createdAt")
    TextField(value = username, onValueChange = { username = it })

    if (isButtonVisible.value) {
        Text("Бутонът ще бъде показан")
    }
}

remember vs rememberSaveable: кога какво да използваме

Изборът между remember и rememberSaveable зависи от това колко критично е запазването на данни при конфигурационни промени. За временни състояния, чиято загуба при завъртане не е важна (анимация, текуща позиция на превъртане, състояние на фокус) — достатъчно е обикновеното remember. За критични данни (текст във форма, избрани елементи, квадратчета за отметка) — използвайте rememberSaveable.

Производителност на rememberSaveable е по-ниска от обикновеното remember, тъй като изисква сериализация в Bundle. Използвайте rememberSaveable само за данни, които наистина трябва да оцелеят при пресъздаване на Activity. За всичко останало — обикновено remember. Прекомерната употреба на rememberSaveable води до забавяне при завъртания на екрана и превключване между приложения.

Ако работите с класове, които не поддържат Parcelable или Serializable, използвайте Saver — конвертор, който определя как да запазите и възстановите обект. Saver се описва от двойка ламбди: save (преобразува обекта в запазваем тип) и restore (възстановява обекта от запазените данни). Стандартният Saver вече е имплементиран за mutableStateListOf и mutableStateMapOf.

Примери за използване на remember в реални проекти

Нека разгледаме типичен сценарий — екран за редактиране на профил, където remember се използва за няколко цели: съхраняване на състоянието на полетата на формуляра, изчисляване на производни стойности и кеширане на изчислително скъпи операции.

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("Име") }
        )

        OutlinedTextField(
            value = state.bio,
            onValueChange = { state = state.copy(bio = it) },
            label = { Text("Относно") }
        )

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

        Button(onClick = { /* save */ },
            enabled = isValid.value) {
            Text("Запазване")
        }
    }
}

В примера състоянието се запазва чрез rememberSaveable — при завъртане на екрана текстът няма да изчезне. isValid се изчислява чрез derivedStateOf, което предотвратява ненужни изчисления при рекомпозиции. bioWarning използва remember с ключ bio — това е скъпо изчисление (по избор, за демонстрация), което се преизчислява само при промяна на bio, а не при всяка рекомпозиция.

Производни състояния и remember с ключове

Производните състояния (derived state) са стойности, които се изчисляват от други State обекти. Вместо да ги изчислявате при всяка рекомпозиция и да пилеете CPU за идентични резултати, remember с derivedStateOf изчислява стойността само при промяна на източниците. Това е особено полезно за филтриране, сортиране и агрегиране на данни.

remember с ключове (remember(key) { calculation }) — друг механизъм за оптимизация. Ако ключът не се е променил от предишната рекомпозиция, блокът за изчисление не се изпълнява и се връща кешираната стойност. Това е удобно за кеширане на обекти, чието създаване е скъпо: форматиране на дати, парсване на JSON, създаване на големи неизменяеми колекции.

@Composable
fun SearchResults(allItems: List<Item>, query: String) {
    // derivedStateOf: филтърът се преизчислява само когато входните данни се променят
    val filtered = remember {
        derivedStateOf {
            allItems.filter { it.title.contains(query, true) }
        }
    }

    // remember с ключ: форматираните статистики се преизчисляват само при промяна на заявката
    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 — е derivedStateOf, който автоматично се преизчислява при промяна на allItems или query. statsText използва remember(query) — скъпото форматиране на низ се изпълнява само при промяна на търсенето. Комбинацията от derivedStateOf и remember с ключове дава максимална производителност: производното състояние се изчислява само когато е необходимо, а сложните обекти се кешират до промяна на ключа.