remember — konsep kunci, menyimpan nilai di antara rekomposisi

Apa itu remember di Jetpack Compose

remember — adalah fungsi bawaan Jetpack Compose dari paket androidx.compose.runtime yang membuat objek yang mempertahankan nilainya di antara panggilan berturut-turut fungsi Composable. Secara teknis, remember bekerja dengan slot — sel memori khusus yang dialokasikan untuk setiap posisi panggilan fungsi di pohon UI. Selama fungsi tetap dalam komposisi (tidak dihapus melalui kondisi if), remember akan mengembalikan nilai yang disimpan pada setiap rekomposisi.

Sintaksis remember sederhana: di dalam kurung kurawal ditentukan blok perhitungan nilai awal. Blok hanya dijalankan sekali — pada komposisi pertama fungsi. Semua rekomposisi berikutnya mengembalikan nilai yang sudah disimpan, tanpa memanggil blok lagi. Namun, jika kunci ditentukan (parameter key), blok akan dijalankan ulang saat kunci berubah, memungkinkan perhitungan ulang nilai berdasarkan data input.

remember bukanlah sihir Kotlin — ini adalah fungsi sederhana dengan parameter key dan lambda perhitungan. Implementasi internalnya menggunakan Composer untuk membaca dan menulis ke slot. Kompiler Kotlin, saat melihat panggilan remember, menghasilkan kode yang mengakses CompositionContext saat ini dan mengelola slot. Ini berarti remember hanya dapat dipanggil di dalam fungsi Composable atau fungsi lain dalam konteks komposisi.

Jenis remember: remember, rememberSaveable, derivedStateOf

Di Jetpack Compose ada tiga varian utama remember, masing-masing dengan tujuannya sendiri. Remember dasar menyimpan nilai hanya di memori proses saat ini — saat rotasi layar (config change), Compose membuat ulang Composition dan semua nilai remember direset. Untuk menyimpan data saat perubahan konfigurasi dan penghentian proses, digunakan rememberSaveable.

rememberSaveable menyerialisasikan nilai ke Bundle melalui mekanisme SavedStateHandle atau Parcelable. Ini memungkinkan bertahan dari rotasi layar, panggilan “Jangan simpan aktivitas” dan bahkan meminimalkan aplikasi sementara. Namun, rememberSaveable memberlakukan batasan pada jenis data yang disimpan: mereka harus primitif, Parcelable, Serializable, atau mendukung konverter Saver.

derivedStateOf — bukan mekanisme penyimpanan, melainkan optimasi. Ini membuat State yang nilainya dihitung berdasarkan objek State lain. derivedStateOf bereaksi terhadap perubahan status sumber, tetapi menghitung ulang nilai hanya ketika ada pelanggan. Jika rekomposisi saat ini tidak membaca derivedStateOf, perhitungan tidak dilakukan, menghemat sumber daya pada pembaruan yang sering tetapi tidak diperlukan.

@Composable
fun RememberVariants() {
    // 1. Remember dasar: bertahan sampai meninggalkan komposisi
    val createdAt = remember { System.currentTimeMillis() }

    // 2. rememberSaveable: bertahan dari rotasi layar
    var username by rememberSaveable { mutableStateOf("") }

    // 3. derivedStateOf: hanya dihitung saat diperlukan
    val isButtonVisible = remember {
        derivedStateOf { username.length() > 3 }
    }

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

    if (isButtonVisible.value) {
        Text("Tombol akan ditampilkan")
    }
}

remember vs rememberSaveable: kapan menggunakan apa

Pilihan antara remember dan rememberSaveable tergantung pada seberapa kritis penyimpanan data saat perubahan konfigurasi. Untuk status sementara yang kehilangannya saat rotasi tidak penting (animasi, posisi scroll saat ini, status fokus) — remember biasa sudah cukup. Untuk data kritis (teks dalam formulir, item yang dipilih, kotak centang) — gunakan rememberSaveable.

Kinerja rememberSaveable lebih rendah dari remember biasa, karena memerlukan serialisasi ke Bundle. Gunakan rememberSaveable hanya untuk data yang benar-benar harus bertahan dari pembuatan ulang Activity. Untuk yang lainnya — remember biasa. Penggunaan rememberSaveable yang berlebihan menyebabkan perlambatan saat rotasi layar dan perpindahan antar aplikasi.

Jika Anda bekerja dengan kelas yang tidak mendukung Parcelable atau Serializable, gunakan Saver — konverter yang menentukan cara menyimpan dan memulihkan objek. Saver dijelaskan oleh sepasang lambda: save (mengubah objek menjadi tipe yang dapat disimpan) dan restore (memulihkan objek dari data yang disimpan). Saver standar sudah diimplementasikan untuk mutableStateListOf dan mutableStateMapOf.

Contoh penggunaan remember di proyek nyata

Mari kita lihat skenario tipikal — layar edit profil, di mana remember digunakan untuk beberapa tujuan: menyimpan status bidang formulir, menghitung nilai turunan, dan menyimpan cache operasi yang mahal secara komputasi.

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

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

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

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

Dalam contoh, status disimpan melalui rememberSaveable — saat rotasi layar teks tidak akan hilang. isValid dihitung melalui derivedStateOf, yang mencegah perhitungan yang tidak perlu saat rekomposisi. bioWarning menggunakan remember dengan kunci bio — ini adalah perhitungan mahal (opsional, untuk demonstrasi) yang hanya dihitung ulang saat bio berubah, bukan pada setiap rekomposisi.

Status turunan dan remember dengan kunci

Status turunan (derived state) adalah nilai yang dihitung dari objek State lain. Alih-alih menghitungnya pada setiap rekomposisi dan membuang CPU untuk hasil yang identik, remember dengan derivedStateOf menghitung nilai hanya saat sumber berubah. Ini sangat berguna untuk memfilter, mengurutkan, dan menggabungkan data.

remember dengan kunci (remember(key) { calculation }) — mekanisme optimasi lain. Jika kunci tidak berubah sejak rekomposisi sebelumnya, blok perhitungan tidak dijalankan dan nilai cache dikembalikan. Ini berguna untuk menyimpan cache objek yang pembuatannya mahal: format tanggal, parsing JSON, pembuatan koleksi tak terubah besar.

@Composable
fun SearchResults(allItems: List<Item>, query: String) {
    // derivedStateOf: filter dihitung ulang hanya saat input berubah
    val filtered = remember {
        derivedStateOf {
            allItems.filter { it.title.contains(query, true) }
        }
    }

    // remember dengan kunci: statistik terformat dihitung ulang hanya saat kueri berubah
    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 — adalah derivedStateOf yang secara otomatis dihitung ulang saat allItems atau query berubah. statsText menggunakan remember(query) — format string mahal hanya dijalankan saat kueri pencarian berubah. Kombinasi derivedStateOf dan remember dengan kunci memberikan kinerja maksimal: status turunan hanya dihitung saat diperlukan, dan objek kompleks disimpan cache hingga kunci berubah.