remember — βασικές έννοιες, διατήρηση τιμών μεταξύ ανασυνθέσεων

Τι είναι το remember στο Jetpack Compose

remember — είναι μια ενσωματωμένη συνάρτηση του Jetpack Compose από το πακέτο androidx.compose.runtime που δημιουργεί ένα αντικείμενο το οποίο διατηρεί την τιμή του μεταξύ διαδοχικών κλήσεων της συνάρτησης Composable. Τεχνικά, το remember λειτουργεί με υποδοχές — ειδικά κελιά μνήμης που εκχωρούνται για κάθε θέση κλήσης συνάρτησης στο δέντρο UI. Όσο η συνάρτηση παραμένει στη σύνθεση (δεν έχει αφαιρεθεί μέσω συνθήκης if), το remember θα επιστρέφει την αποθηκευμένη τιμή σε κάθε ανασύνθεση.

Η σύνταξη του remember είναι απλή: μέσα σε άγκιστρα καθορίζεται το μπλοκ υπολογισμού της αρχικής τιμής. Το μπλοκ εκτελείται μόνο μία φορά — κατά την πρώτη σύνθεση της συνάρτησης. Όλες οι επόμενες ανασυνθέσεις επιστρέφουν την ήδη αποθηκευμένη τιμή, χωρίς να καλούν ξανά το μπλοκ. Ωστόσο, εάν έχει καθοριστεί ένα κλειδί (παράμετρος key), το μπλοκ εκτελείται ξανά όταν αλλάξει το κλειδί, επιτρέποντας τον εκ νέου υπολογισμό της τιμής με βάση τα δεδομένα εισόδου.

Το remember δεν είναι μαγεία Kotlin — είναι μια απλή συνάρτηση με παράμετρο key και lambda υπολογισμού. Η εσωτερική της υλοποίηση χρησιμοποιεί το 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 περιγράφεται από ένα ζεύγος lambda: 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 με κλειδιά δίνει μέγιστη απόδοση: η παράγωγη κατάσταση υπολογίζεται μόνο όταν χρειάζεται και τα σύνθετα αντικείμενα αποθηκεύονται προσωρινά μέχρι να αλλάξει το κλειδί.