onRestart — lényege, az Activity helyreállítása az életciklusban

onRestart — a metódus lényege az Android életciklusban

onRestart — egy callback metódus, amelyet Android az onStart előtt hív meg, amikor az Activity visszatér a láthatatlan Stopped állapotból a látható állapotba. Ez a metódus egyedi, mert csak az Activity ismételt megjelenítésekor hívódik meg — az első példány létrehozásakor a sorozat az onCreate-tel kezdődik, kihagyva az onRestart-ot. Teljes ciklus: onCreate → onStart → onResume (első indítás) vagy onRestart → onStart → onResume (ismételt megjelenítés).

Az Android rendszer szempontjából az onRestart egy optimalizálás, amely lehetővé teszi az Activity számára, hogy felkészüljön a visszatérésre: frissítse az adatokat a repositoryból, szinkronizálja az UI-állapotot, ellenőrizze a hálózati kapcsolatot. Ellentétben az onResume-mal, amely minden egyes fókusz megszerzésekor meghívódik (beleértve a párbeszédablakból vagy rendszermenüből való visszatérést is), az onRestart csak a teljes elrejtés-visszatérés ciklusban aktiválódik. Ez teszi az onRestart-ot ideális hellyé a „nehéz“ frissítési műveletek számára, amelyek nem szükségesek részleges fókuszvesztés esetén.

Az Android Activity életciklus specifikációja szerint az onStop és onRestart közötti időintervallum néhány másodperctől (a felhasználó gyorsan váltott) néhány óráig (az alkalmazás a háttérben volt és a felhasználó visszatért) terjedhet. Ez idő alatt a távoli forrásban (API, DB) lévő adatok megváltozhattak, ezért az onRestart természetes pont az aktualitás ellenőrzésére.

Mikor hívódik meg az onRestart: feltételek és sorrend

Az onRestart csak az Activity Stopped állapotból való visszatérésekor hívódik meg, amelybe az Activity az onStop meghívása után került. Az alábbiakban felsoroljuk az onRestart-hoz vezető összes forgatókönyvet.

Az onRestart meghívásának forgatókönyvei:

• Visszatérés másik Activity-ből — a felhasználó megnyitott egy új Activity-t (pl. rákattintott egy értesítésre), majd visszatért (megnyomta a „Vissza“ gombot). Verem: MainActivity.onPause → MainActivity.onStop → SecondActivity létrejön → a felhasználó megnyomja a „Vissza“ gombot → SecondActivity.onPause → SecondActivity.onStop → SecondActivity.onDestroy → MainActivity.onRestart → MainActivity.onStart → MainActivity.onResume.
• Visszatérés minimalizálásból — a felhasználó minimalizálta az alkalmazást (Home), és egy idő után visszatért. CurrentActivity.onPause → CurrentActivity.onStop → (alkalmazás a háttérben) → a felhasználó visszatér → CurrentActivity.onRestart → CurrentActivity.onStart → CurrentActivity.onResume.
• Visszatérés a zárolási képernyőről — a zárolási képernyő eltakarja az Activity-t; feloldás után az Activity onRestart-ot kap, ha jelentős idő telt el (több mint 5 másodperc).
• Visszatérés Intent-en keresztül indított alkalmazásból — kamera, galéria, böngésző — bármely harmadik féltől származó alkalmazás, amely a startActivityForResult() vagy ActivityResultLauncher segítségével indult.

Mikor NEM hívódik meg az onRestart: képernyőelforgatáskor (az Activity megsemmisül és az onCreate-en keresztül újra létrejön), párbeszédablakból való visszatéréskor (az Activity nem megy onStop-ba, csak onPause → onResume), process death esetén (az Activity újra létrejön).

Különbség az onRestart és onCreate között: mit válasszunk

Az onRestart és az onCreate két különböző megközelítés az Activity helyreállítására. A választás attól függ, hogy az Activity teljesen megsemmisült vagy csak elrejtették.

Választási szabály: a View inicializálását és a LiveData/StateFlow-ra való feliratkozást az onCreate-ben (vagy Fragment esetén onViewCreated-ben) végezze. Az adatok frissítését, listák újratöltését és állapotellenőrzést — az onRestart-ban. Ha az adatok ViewModel-en keresztül töltődnek be, az onRestart egyszerűen meghívhatja a refresh() metódust a ViewModel-en, a View pedig feliratkozik a frissített adatokra a reaktív folyamon keresztül.

A Google azt ajánlja: ne duplikálja az onCreate logikáját az onRestart-ban. Különítse el a ViewModel-ben a refresh() metódusokat, amelyek az aktuális adatokat töltik be, és hívja meg őket az onRestart-ban. Ez megőrzi az MVVM architektúra tisztaságát és kiküszöböli a kódismétlést.

Az onRestart használati forgatókönyvei: adat- és UI-frissítés

Az onRestart — ideális hely azon műveletek számára, amelyeket minden egyes képernyőre való visszatéréskor végre kell hajtani, de az első megnyitáskor nem szükségesek. Íme a tipikus forgatókönyvek:

• Lista frissítése DB-ből vagy API-ból — a felhasználó átment egy másik Activity-be, ott módosította az adatokat, visszatért — a listának naprakésznek kell lennie. Hívja meg a viewModel.refreshItems() metódust az onRestart-ban.
• Hitelesítés ellenőrzése — ha az Activity hosszú ideig rejtve volt, a hozzáférési token lejárhatott. Az onRestart a token érvényességének ellenőrzésére és a bejelentkezési képernyőre való átirányításra szolgáló pont.
• UI-állapot szinkronizálása — témaváltás, nyelvmódosítás, beállítások frissítése — a változtatásokat a képernyőre való visszatéréskor alkalmazni kell.
• Média újratöltése — ha az Activity olyan tartalmat jelenít meg, amely megváltozhatott (hírfolyam, árfolyam, időjárás), frissítse az adatokat az onRestart-ban.
• Hálózati kapcsolat ellenőrzése — offline módból való visszatéréskor az Activity-nek ellenőriznie kell a hálózat elérhetőségét és át kell kapcsolnia az UI-t.
• Animációk helyreállítása — az onStop-ban felszabadított animációkat indítsa újra az onRestart-ban az onStart előtt.

Mit NE tegyen az onRestart-ban: ne inicializálja újra a View-kat — élnek, mert az Activity nem semmisült meg. Ne iratkozzon fel újra a LiveData-ra — a feliratkozás az onCreate-ben él. Ne hozzon létre új fragmenteket — már a FragmentManager-ben vannak.

onRestart és process death: fontos kivétel

A legfontosabb kivétel: az onRestart nem hívódik meg, ha az alkalmazás folyamatát a rendszer megölte. Ez az a kulcsfontosságú pont, amelyet a fejlesztők gyakran elmulasztanak, az onRestart-ra támaszkodva az állapot helyreállításához.

Process death esetén:

• Az alkalmazás a háttérben volt, az Android megölte a folyamatot a memória felszabadítása érdekében.
• A felhasználó visszatér — a rendszer új folyamatot indít.
• Az Activity újra létrejön: onCreate(Bundle) → onStart → onResume.
• Az onRestart NEM hívódik meg — a rendszer számára ez egy új Activity-példány.

Hogyan védekezzen: mindig mentse el a kritikus állapotot az onSaveInstanceState(Bundle) metódusban (az onStop előtt hívódik meg), vagy használja a SavedStateHandle-et a ViewModel-ben. Az onCreate-ben ellenőrizze a savedInstanceState-et: ha nem null, állítsa vissza az állapotot a Bundle-ből, ha null — töltsön be friss adatokat.

A Google Android Vitals szerint az Activity-hez való visszatérések körülbelül 7%-a történik a háttérben való hosszú tartózkodás után process death következtében. Ez azt jelenti, hogy minden 15. Activity, amelynek meg kellett volna hívnia az onRestart-ot, valójában az onCreate-en megy keresztül. Ennek a forgatókönyvnek a figyelmen kívül hagyása az „üres képernyő visszatérés után“ hibák egyik fő oka.

Kódpéldák onRestart-tal Kotlinban

1. példa: onRestart lista frissítéssel ViewModel-en keresztül

Az Activity meghívja a viewModel.refreshTasks() metódust az onRestart-ban a feladatlista frissítéséhez a szerkesztőképernyőről való visszatérés után.

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} feladat érkezett")
        }
    }

    override fun onRestart() {
        super.onRestart()
        Log.d("TaskList", "onRestart: feladatlista frissítése")
        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()
        }
    }
}

A ViewModel.refreshTasks() betölti az aktuális adatokat a repositoryból. A LiveData automatikusan értesíti az Activity-t az adatok változásáról — az UI további kód nélkül frissül. Az OnRestart nem hoz létre új feliratkozást — az már az onCreate-ben be van állítva.

2. példa: onRestart hitelesítés ellenőrzéssel

Az Activity ellenőrzi a token érvényességét visszatéréskor, és szükség esetén átirányít a bejelentkezési képernyőre.

class ProfileActivity : AppCompatActivity() {
    private val authManager = AuthManager()
    private val launcher = registerForActivityResult(
        ActivityResultContracts.StartActivityForResult()
    ) { Log.d("Profile", "Visszatértünk a bejelentkezési képernyőről") }

    override fun onRestart() {
        super.onRestart()
        if (!authManager.isTokenValid()) {
            Log.d("Profile", "Token lejárt — átirányítás a bejelentkezésre")
            launcher.launch(Intent(this, LoginActivity::class.java))
        }
    }
}

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

Ha a felhasználó hosszú időre minimalizálta az alkalmazást, és a token lejárta után tért vissza, az onRestart átirányítja a bejelentkezési képernyőre. Ez megakadályozza az API-hibákat, amikor lejárt tokenű kérést próbál végrehajtani. Figyelem: ellenőrzés az onRestart-ban, nem az onResume-ban, hogy elkerülje a szükségtelen ellenőrzést a párbeszédablakból való visszatéréskor.

3. példa: onRestart Fragment-ben ViewLifecycleOwner-ral

A Fragment az onRestart-ot a LifecycleObserver-en keresztül használja az adatfrissítéshez.

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-en keresztül")
                viewModel.refreshFeed()
            }
        })
    }
}

Az onRestart Fragment-ben történő felülírása helyett LifecycleObserver-t használunk — egy rugalmasabb megközelítés, amely lehetővé teszi logika hozzáadását az életciklus-eseményekhez öröklődés nélkül. A ViewLifecycleOwner garantálja, hogy a megfigyelő a View hatókörében él (nem éli túl az onDestroyView-t).