remember — temel kavramlar, yeniden oluşturmalar arasında değerleri koruma

Jetpack Compose'da remember nedir

remember, androidx.compose.runtime paketinden gelen, bir Composable işlevin ardışık çağrıları arasında değerini koruyan bir nesne oluşturan yerleşik bir Jetpack Compose işlevidir. Teknik olarak remember, slotlarla (UI ağacındaki her işlev çağrısı konumu için ayrılan özel bellek hücreleri) çalışır. İşlev kompozisyonda kaldığı sürece (bir if koşuluyla kaldırılmadıkça), remember her yeniden oluşturmada kaydedilen değeri döndürür.

remember'ın sözdizimi basittir: küme parantezleri içinde ilk değerin hesaplama bloğu belirtilir. Blok yalnızca bir kez yürütülür — işlevin ilk kompozisyonu sırasında. Sonraki tüm yeniden oluşturmalar, bloğu yeniden yürütmeden zaten kaydedilmiş değeri döndürür. Ancak, bir anahtar parametresi belirtilmişse, anahtar değiştiğinde blok yeniden yürütülür ve girdi verilerine dayalı olarak değerin yeniden hesaplanmasına olanak tanır.

remember Kotlin sihri değildir — bir anahtar parametresi ve hesaplama lambdası olan basit bir işlevdir. Dahili uygulaması, slotları okumak ve yazmak için Composer kullanır. Kotlin derleyicisi, bir remember çağrısı gördüğünde, geçerli CompositionContext'e erişen ve slotları yöneten kod üretir. Bu, remember'ın yalnızca bir Composable işlev içinde veya kompozisyon bağlamındaki başka bir işlev içinde çağrılabileceği anlamına gelir.

remember türleri: remember, rememberSaveable, derivedStateOf

Jetpack Compose'da, her biri kendi amacına sahip üç ana remember çeşidi vardır. Temel remember, değeri yalnızca geçerli işlem belleğinde korur — ekran döndürmede (yapılandırma değişikliği), Compose Kompozisyonu yeniden oluşturur ve tüm remember değerleri sıfırlanır. Yapılandırma değişiklikleri ve işlem durması sırasında verileri korumak için rememberSaveable kullanılır.

rememberSaveable, SavedStateHandle veya Parcelable mekanizması aracılığıyla değeri bir Bundle'da seri hale getirir. Bu, ekran döndürme, "Etkinlikleri saklama" ayarı ve hatta geçici uygulama küçültmeden kurtulmayı sağlar. Ancak, rememberSaveable depolanabilir veri türüne kısıtlamalar getirir: ilkel, Parcelable, Serializable olmalı veya bir Saver dönüştürücüsünü desteklemelidir.

derivedStateOf bir koruma mekanizması değil, bir optimizasyondur. Değeri diğer State nesnelerinden hesaplanan bir State oluşturur. derivedStateOf, kaynak durumlarındaki değişikliklere tepki verir, ancak değeri yalnızca aboneler olduğunda yeniden hesaplar. Geçerli yeniden oluşturma derivedStateOf'u okumazsa, hesaplama yapılmaz ve sık ancak gereksiz güncellemelerde kaynak tasarrufu sağlanır.

@Composable
fun RememberVariants() {
    // 1. Temel remember: kompozisyondan ayrılana kadar kalıcıdır
    val createdAt = remember { System.currentTimeMillis() }

    // 2. rememberSaveable: ekran döndürmeye dayanır
    var username by rememberSaveable { mutableStateOf("") }

    // 3. derivedStateOf: yalnızca gerektiğinde hesaplanır
    val isButtonVisible = remember {
        derivedStateOf { username.length() > 3 }
    }

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

    if (isButtonVisible.value) {
        Text("Düğme gösterilecek")
    }
}

remember vs rememberSaveable: ne zaman hangisi kullanılır

remember ve rememberSaveable arasındaki seçim, yapılandırma değişiklikleri sırasında verileri korumanın ne kadar kritik olduğuna bağlıdır. Döndürmede kaybedilmesi önemli olmayan geçici durumlar için (animasyon, geçerli kaydırma konumu, odak durumu) — normal remember yeterlidir. Kritik veriler için (form metni, seçili öğeler, onay kutuları) — rememberSaveable kullanın.

Performans: rememberSaveable, normal remember'dan daha yavaştır çünkü bir Bundle'da serileştirme gerektirir. rememberSaveable'ı yalnızca gerçekten Activity yeniden oluşturmasından kurtulması gereken veriler için kullanın. Diğer her şey için — basit remember. rememberSaveable'ın aşırı kullanımı, ekran döndürme ve uygulamalar arasında geçiş yaparken yavaşlamalara neden olur.

Parcelable veya Serializable'ı desteklemeyen sınıflarla çalışıyorsanız, Saver kullanın — nesnenin nasıl kaydedileceğini ve geri yükleneceğini tanımlayan bir dönüştürücü. Saver, bir çift lambda ile tanımlanır: save (nesneyi kaydedilebilir bir türe dönüştürür) ve restore (nesneyi kaydedilen verilerden geri yükler). mutableStateListOf ve mutableStateMapOf için standart bir Saer zaten uygulanmıştır.

Gerçek projelerde remember kullanım örnekleri

Tipik bir senaryo düşünelim — remember'ın birden çok amaç için kullanıldığı bir profil düzenleme ekranı: form alanlarının durumunu depolama, türetilmiş değerleri hesaplama ve hesaplama açısından pahalı işlemleri önbelleğe alma.

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

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

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

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

Örnekte, durum rememberSaveable aracılığıyla kaydedilir — metin ekran döndürmede kaybolmaz. isValid, derivedStateOf aracılığıyla hesaplanır ve yeniden oluşturmalar sırasında gereksiz hesaplamaları önler. bioWarning, bio anahtarıyla remember kullanır — bu, yalnızca bio değiştiğinde yeniden hesaplanan pahalı bir hesaplamadır (isteğe bağlı, gösterim amaçlı), her yeniden oluşturmada değil.

Türetilmiş durumlar ve anahtarlarla remember

Türetilmiş durumlar, diğer State nesnelerinden hesaplanan değerlerdir. Bunları her yeniden oluşturmada hesaplayıp aynı sonuçlar için CPU harcamak yerine, remember derivedStateOf ile değeri yalnızca kaynaklar değiştiğinde hesaplar. Bu, filtreleme, sıralama ve veri toplama için özellikle kullanışlıdır.

Anahtarlarla remember (remember(key) { calculation }) başka bir optimizasyon mekanizmasıdır. Son yeniden oluşturmadan bu yana anahtar değişmediyse, hesaplama bloğu yürütülmez ve önbelleğe alınmış değer döndürülür. Bu, oluşturulması pahalı olan nesneleri (tarih biçimlendirme, JSON ayrıştırma, büyük değişmez koleksiyonlar oluşturma) önbelleğe almak için kullanışlıdır.

@Composable
fun SearchResults(allItems: List<Item>, query: String) {
    // derivedStateOf: filtre yalnızca girdiler değiştiğinde yeniden hesaplanır
    val filtered = remember {
        derivedStateOf {
            allItems.filter { it.title.contains(query, true) }
        }
    }

    // anahtarlı remember: biçimlendirilmiş istatistikler yalnızca sorgu değiştiğinde yeniden hesaplanır
    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, allItems veya query değiştiğinde otomatik olarak yeniden hesaplanan bir derivedStateOf'dur. statsText remember(query) kullanır — pahalı dize biçimlendirme, yalnızca arama sorgusu değiştiğinde gerçekleştirilir. derivedStateOf ve anahtarlarla remember kombinasyonu maksimum performans sağlar: türetilmiş durum yalnızca gerektiğinde hesaplanır ve karmaşık nesneler anahtar değişene kadar önbellekte kalır.