onRestart — ουσία, επαναφορά Activity στον κύκλο ζωής

onRestart — ουσία της μεθόδου στον κύκλο ζωής Android

onRestart — μέθοδος callback που καλεί το Android αυστηρά πριν από το onStart, όταν το Activity επιστρέφει από την αόρατη κατάσταση Stopped πίσω στην ορατή κατάσταση. Αυτή η μέθοδος είναι μοναδική επειδή καλείται μόνο κατά την επαναλαμβανόμενη εμφάνιση του Activity — κατά την πρώτη δημιουργία παρουσίας η σειρά ξεκινά με onCreate, παρακάμπτοντας το onRestart. Πλήρης κύκλος: onCreate → onStart → onResume (πρώτη εκκίνηση) ή onRestart → onStart → onResume (επαναλαμβανόμενη εμφάνιση).

Από την άποψη του συστήματος Android, το onRestart είναι μια βελτιστοποίηση που επιτρέπει στο Activity να προετοιμαστεί για επιστροφή: να ενημερώσει δεδομένα από το αποθετήριο, να συγχρονίσει την κατάσταση UI, να ελέγξει τη σύνδεση δικτύου. Σε αντίθεση με το onResume, το οποίο καλείται κάθε φορά κατά τη λήψη εστίασης (συμπεριλαμβανομένης της επιστροφής από διάλογο ή μενού συστήματος), το onRestart ενεργοποιείται μόνο κατά τον πλήρη κύκλο απόκρυψης-επιστροφής. Αυτό καθιστά το onRestart ιδανικό μέρος για «βαριές» λειτουργίες ενημέρωσης που δεν χρειάζονται σε μερική απώλεια εστίασης.

Σύμφωνα με τις προδιαγραφές του κύκλου ζωής Android Activity, το χρονικό διάστημα μεταξύ onStop και onRestart μπορεί να κυμαίνεται από λίγα δευτερόλεπτα (ο χρήστης άλλαξε γρήγορα) έως αρκετές ώρες (η εφαρμογή ήταν στο παρασκήνιο και ο χρήστης επέστρεψε). Κατά τη διάρκεια αυτού του χρόνου, τα δεδομένα στην απομακρυσμένη πηγή (API, DB) μπορεί να έχουν αλλάξει, γι' αυτό το onRestart είναι το φυσικό σημείο για έλεγχο ενημερότητας.

Πότε καλείται το onRestart: συνθήκες και σειρά

Το onRestart καλείται μόνο κατά την επιστροφή του Activity από την κατάσταση Stopped, στην οποία εισήλθε το Activity μετά την κλήση του onStop. Παρακάτω αναφέρονται όλα τα σενάρια που οδηγούν σε onRestart.

Σενάρια κλήσης onRestart:

• Επιστροφή από άλλο Activity — ο χρήστης άνοιξε ένα νέο Activity (π.χ. έκανε κλικ σε ειδοποίηση) και στη συνέχεια επέστρεψε (πάτησε «Πίσω»). Στοίβα: MainActivity.onPause → MainActivity.onStop → SecondActivity δημιουργείται → ο χρήστης πατά «Πίσω» → SecondActivity.onPause → SecondActivity.onStop → SecondActivity.onDestroy → MainActivity.onRestart → MainActivity.onStart → MainActivity.onResume.
• Επιστροφή από ελαχιστοποίηση — ο χρήστης ελαχιστοποίησε την εφαρμογή (Home) και μετά από λίγο επέστρεψε. CurrentActivity.onPause → CurrentActivity.onStop → (εφαρμογή στο παρασκήνιο) → ο χρήστης επιστρέφει → CurrentActivity.onRestart → CurrentActivity.onStart → CurrentActivity.onResume.
• Επιστροφή από οθόνη κλειδώματος — η οθόνη κλειδώματος καλύπτει το Activity· μετά το ξεκλείδωμα το Activity λαμβάνει onRestart αν έχει περάσει σημαντικός χρόνος (πάνω από 5 δευτερόλεπτα).
• Επιστροφή από εφαρμογή που εκκινήθηκε μέσω Intent — κάμερα, γκαλερί, πρόγραμμα περιήγησης — οποιαδήποτε εφαρμογή τρίτου μέρους που εκκινήθηκε μέσω startActivityForResult() ή ActivityResultLauncher.

Πότε ΔΕΝ καλείται το onRestart: κατά περιστροφή οθόνης (το Activity καταστρέφεται και δημιουργείται ξανά μέσω onCreate), κατά επιστροφή από παράθυρο διαλόγου (το Activity δεν πηγαίνει σε onStop, μόνο onPause → onResume), σε process death (το Activity δημιουργείται ξανά).

Διαφορά μεταξύ onRestart και onCreate: τι να επιλέξετε

Το onRestart και το onCreate είναι δύο διαφορετικές προσεγγίσεις για την επαναφορά του Activity. Η επιλογή μεταξύ τους εξαρτάται από το αν το Activity καταστράφηκε πλήρως ή απλώς κρύφτηκε.

Κανόνας επιλογής: την αρχικοποίηση View και την εγγραφή σε LiveData/StateFlow κάντε στο onCreate (ή onViewCreated για Fragment). Ενημέρωση δεδομένων, επαναφόρτωση λιστών και έλεγχο κατάστασης — στο onRestart. Εάν τα δεδομένα φορτώνονται μέσω ViewModel, το onRestart μπορεί απλά να καλέσει τη μέθοδο refresh() στο ViewModel και το View θα εγγραφεί στα ενημερωμένα δεδομένα μέσω αντιδραστικής ροής.

Η Google συνιστά: μην αντιγράφετε τη λογική του onCreate στο onRestart. Απομονώστε στο ViewModel τις μεθόδους refresh() που φορτώνουν τρέχοντα δεδομένα και καλέστε τις στο onRestart. Αυτό διατηρεί την καθαρότητα της αρχιτεκτονικής MVVM και εξαλείφει την αντιγραφή κώδικα.

Σενάρια χρήσης onRestart: ενημέρωση δεδομένων και UI

Το onRestart — ιδανικό μέρος για λειτουργίες που πρέπει να εκτελούνται σε κάθε επιστροφή στην οθόνη, αλλά δεν χρειάζονται στο πρώτο άνοιγμα. Ακολουθούν τυπικά σενάρια:

• Ενημέρωση λίστας από DB ή API — ο χρήστης πήγε σε άλλο Activity, εκεί άλλαξε δεδομένα, επέστρεψε — η λίστα πρέπει να είναι ενημερωμένη. Καλέστε viewModel.refreshItems() στο onRestart.
• Έλεγχος εξουσιοδότησης — εάν το Activity ήταν κρυμμένο για μεγάλο χρονικό διάστημα, το διακριτικό πρόσβασης μπορεί να έχει λήξει. Το onRestart είναι το σημείο για έλεγχο εγκυρότητας του διακριτικού και ανακατεύθυνση στην οθόνη σύνδεσης.
• Συγχρονισμός κατάστασης UI — εναλλαγή θεμάτων, αλλαγή γλώσσας, ενημέρωση ρυθμίσεων — οι αλλαγές πρέπει να εφαρμόζονται κατά την επιστροφή στην οθόνη.
• Επαναφόρτωση πολυμέσων — εάν το Activity εμφανίζει περιεχόμενο που μπορεί να έχει αλλάξει (ροή ειδήσεων, ισοτιμία νομισμάτων, καιρός), ενημερώστε τα δεδομένα στο onRestart.
• Έλεγχος σύνδεσης δικτύου — κατά την επιστροφή από λειτουργία εκτός σύνδεσης, το Activity πρέπει να ελέγξει τη διαθεσιμότητα δικτύου και να αλλάξει το UI.
• Επαναφορά κινούμενων εικόνων — κινούμενες εικόνες που απελευθερώθηκαν στο onStop, επανεκκινήστε στο onRestart πριν από το onStart.

Τι να μην κάνετε στο onRestart: μην αρχικοποιείτε ξανά το View — ζουν επειδή το Activity δεν καταστράφηκε. Μην εγγράφεστε ξανά στο LiveData — η εγγραφή στο onCreate ζει. Μην δημιουργείτε νέα τμήματα — είναι ήδη στο FragmentManager.

onRestart και process death: σημαντική εξαίρεση

Η πιο σημαντική εξαίρεση: το onRestart δεν καλείται εάν η διεργασία της εφαρμογής σκοτώθηκε από το σύστημα. Αυτό είναι το βασικό σημείο που οι προγραμματιστές συχνά παραβλέπουν βασιζόμενοι στο onRestart για επαναφορά κατάστασης.

Σε process death:

• Η εφαρμογή ήταν στο παρασκήνιο, το Android σκότωσε τη διεργασία για να ελευθερώσει μνήμη.
• Ο χρήστης επιστρέφει — το σύστημα εκκινεί μια νέα διεργασία.
• Το Activity δημιουργείται ξανά: onCreate(Bundle) → onStart → onResume.
• Το onRestart ΔΕΝ καλείται — για το σύστημα αυτή είναι μια νέα παρουσία Activity.

Πώς να προστατευτείτε: αποθηκεύετε πάντα την κρίσιμη κατάσταση στο onSaveInstanceState(Bundle) (καλείται πριν από onStop) ή χρησιμοποιείτε SavedStateHandle στο ViewModel. Στο onCreate ελέγξτε το savedInstanceState: αν δεν είναι null, επαναφέρετε την κατάσταση από το Bundle, αν είναι null — φορτώστε φρέσκα δεδομένα.

Σύμφωνα με το Google Android Vitals, περίπου 7% των επιστροφών σε Activity μετά από παρατεταμένη παραμονή στο παρασκήνιο συμβαίνουν μετά από process death. Αυτό σημαίνει ότι κάθε 15ο Activity που έπρεπε να καλέσει onRestart, στην πραγματικότητα περνά από onCreate. Η αγνόηση αυτού του σεναρίου είναι μία από τις κύριες αιτίες σφαλμάτων «κενή οθόνη μετά από επιστροφή».

Παραδείγματα κώδικα με onRestart σε Kotlin

Παράδειγμα 1: onRestart με ενημέρωση λίστας μέσω ViewModel

Το Activity καλεί viewModel.refreshTasks() στο onRestart για ενημέρωση της λίστας εργασιών μετά από επιστροφή από την οθόνη επεξεργασίας.

class TaskListActivity : AppCompatActivity() {
    private val viewModel: TaskViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_task_list)
        viewModel.tasks.observe(this) { tasks ->
            Log.d("TaskList", "Λήφθηκαν ${tasks.size} εργασίες")
        }
    }

    override fun onRestart() {
        super.onRestart()
        Log.d("TaskList", "onRestart: ενημέρωση λίστας εργασιών")
        viewModel.refreshTasks()
    }
}

class TaskViewModel : ViewModel() {
    private val _tasks = MutableLiveData<List<Task>>()
    val tasks: LiveData<List<Task>> get() = _tasks

    fun refreshTasks() {
        viewModelScope.launch {
            _tasks.value = TaskRepository().getAllTasks()
        }
    }
}

Το ViewModel.refreshTasks() φορτώνει τρέχοντα δεδομένα από το αποθετήριο. Το LiveData ειδοποιεί αυτόματα το Activity για αλλαγή δεδομένων — το UI ενημερώνεται χωρίς επιπλέον κώδικα. Το OnRestart δεν δημιουργεί νέα εγγραφή — είναι ήδη ρυθμισμένη στο onCreate.

Παράδειγμα 2: onRestart με έλεγχο εξουσιοδότησης

Το Activity ελέγχει την εγκυρότητα του διακριτικού κατά την επιστροφή και ανακατευθύνει στη σύνδεση εάν χρειάζεται.

class ProfileActivity : AppCompatActivity() {
    private val authManager = AuthManager()
    private val launcher = registerForActivityResult(
        ActivityResultContracts.StartActivityForResult()
    ) { Log.d("Profile", "Επιστρέψαμε από την οθόνη σύνδεσης") }

    override fun onRestart() {
        super.onRestart()
        if (!authManager.isTokenValid()) {
            Log.d("Profile", "Το διακριτικό έληξε — ανακατεύθυνση στη σύνδεση")
            launcher.launch(Intent(this, LoginActivity::class.java))
        }
    }
}

class AuthManager {
    fun isTokenValid(): Boolean {
        val expiry = SharedPreferencesManager().getTokenExpiry()
        return System.currentTimeMillis() < expiry
    }
}

Εάν ο χρήστης ελαχιστοποίησε την εφαρμογή για μεγάλο χρονικό διάστημα και επέστρεψε μετά τη λήξη του διακριτικού, το onRestart θα τον ανακατευθύνει στην οθόνη σύνδεσης. Αυτό αποτρέπει σφάλματα API κατά την προσπάθεια εκτέλεσης αιτήματος με ληγμένο διακριτικό. Σημείωση: έλεγχος στο onRestart, όχι στο onResume, για αποφυγή περιττού ελέγχου κατά επιστροφή από διάλογο.

Παράδειγμα 3: onRestart σε Fragment με ViewLifecycleOwner

Το Fragment χρησιμοποιεί onRestart μέσω LifecycleObserver για ενημέρωση δεδομένων.

class FeedFragment : Fragment() {
    private val viewModel: FeedViewModel by viewModels()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        viewLifecycleOwner.lifecycle.addObserver(object : LifecycleObserver {
            @OnLifecycleEvent(Lifecycle.Event.ON_RESTART)
            fun onRestart() {
                Log.d("FeedFragment", "onRestart μέσω LifecycleObserver")
                viewModel.refreshFeed()
            }
        })
    }
}

Αντί να παρακάμψετε το onRestart στο Fragment, χρησιμοποιείται LifecycleObserver — μια πιο ευέλικτη προσέγγιση που επιτρέπει την προσθήκη λογικής σε γεγονότα κύκλου ζωής χωρίς κληρονομικότητα. Το ViewLifecycleOwner εγγυάται ότι ο παρατηρητής ζει στο πεδίο του View (δεν επιβιώνει του onDestroyView).