Activity Lifecycle: co to je, onCreate onStart onResume v Androidu

Co je Activity Lifecycle

Activity Lifecycle (životní cyklus Activity) — konečný automat stavů, kterým prochází každá obrazovka Android aplikace od okamžiku vytvoření až po úplné zničení. Systém Android řídí tento proces na základě akcí uživatele: otevření aplikace, minimalizace, otočení obrazovky, odpověď na příchozí hovor, přepínání mezi aplikacemi a ukončení.

Porozumění životnímu cyklu je nezbytné pro každého Android vývojáře, protože systém může kdykoli zničit Activity při nedostatku paměti — a aplikace je povinna správně obnovit svůj stav. Podle údajů Google Android Vitals (2025) vykazují aplikace, které nezpracovávají ukládání stavu v onSaveInstanceState(), o 42 % více pádů při opětovném vytváření Activity.

Životní cyklus zahrnuje šest hlavních metod zpětného volání: onCreate(), onStart(), onResume(), onPause(), onStop(), onDestroy(). Dále existuje metoda onRestart(), která se volá před onStart(), když se Activity vrací ze zastaveného stavu. Každá metoda má přesně definovaný účel a čas provedení — systém je volá sekvenčně a vývojář může kteroukoli z nich přepsat pro provedení své vlastní logiky.

Cyklus lze rozdělit do tří klíčových fází: celá doba života (onCreate → onDestroy), viditelná doba života (onStart → onStop) a doba života v popředí (onResume → onPause). Porozumění těmto třem úrovním pomáhá správně rozložit inicializační kód a uvolňování zdrojů.

Metody životního cyklu Activity

Každá metoda životního cyklu provádí přesně definovaný úkol. Systém je volá v pevném pořadí a vývojář by měl přepisovat pouze ty metody, které jsou potřebné pro konkrétní logiku. Nedoporučuje se volat metody životního cyklu přímo — to provádí Android Runtime.

Obecné schéma volání

Typická posloupnost při spuštění aplikace: onCreate → onStart → onResume. Při stisknutí tlačítka „Zpět“: onPause → onStop → onDestroy. Při minimalizaci: onPause → onStop, poté při návratu: onRestart → onStart → onResume.

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }

    override fun onStart() {
        super.onStart()
    }

    override fun onResume() {
        super.onResume()
    }

    override fun onPause() {
        super.onPause()
    }

    override fun onStop() {
        super.onStop()
    }

    override fun onDestroy() {
        super.onDestroy()
    }

    override fun onRestart() {
        super.onRestart()
    }
}

Každá přepsaná metoda musí volat super verzi — bez toho systém nemůže správně dokončit přechod mezi stavy. Toto pravidlo je zakotveno v dokumentaci Android Developers a je kontrolováno lint pravidly Android Studio.

Tři úrovně životního cyklu

První úroveň — celá doba života (entire lifetime): interval mezi onCreate a onDestroy. Zde probíhá jednorázová inicializace a konečné uvolnění globálních zdrojů. Druhá úroveň — viditelná doba života (visible lifetime): mezi onStart a onStop. Activity je viditelné na obrazovce, ale může být částečně zakryto jiným oknem. Třetí úroveň — doba života v popředí (foreground lifetime): mezi onResume a onPause. Activity je na vrcholu zásobníku úloh a komunikuje s uživatelem.

onCreate — vytvoření Activity

onCreate() — první a jediná povinná metoda životního cyklu Activity. Je volána systémem jednou při vytváření instance Activity. Tato metoda přijímá parametr savedInstanceState: Bundle?, který obsahuje dříve uložený stav, pokud je Activity po zničení znovu vytvářeno — například při otáčení obrazovky.

Uvnitř onCreate se provádějí následující úkoly: inicializace uživatelského rozhraní pomocí setContentView() s předáním layout zdroje, propojení View prvků pomocí findViewById(), nastavení adaptérů pro RecyclerView a ViewPager, obnovení stavu z savedInstanceState, inicializace ViewModel a LiveData, nastavení posluchačů kliknutí a gest. Metoda by měla být dokončena co nejrychleji — dlouhé operace zde blokují vykreslení prvního snímku, což zvyšuje dobu spouštění aplikace.

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_profile)

    val userNameText: TextView = findViewById(R.id.user_name)
    val loadButton: Button = findViewById(R.id.load_button)

    if (savedInstanceState != null) {
        userNameText.text = savedInstanceState.getString("user_name")
    }

    loadButton.setOnClickListener {
        loadUserProfile()
    }
}

Pokud je Activity vytvářeno poprvé, savedInstanceState je null. Při opětovném vytvoření po otočení obrazovky obsahuje Bundle data uložená v onSaveInstanceState(). Kontrola na null je standardní praxí pro správné obnovení UI bez ztráty dat zadaných uživatelem.

onStart — zobrazení na obrazovce

onStart() se volá ihned po onCreate() nebo po onRestart(), když se Activity stane viditelným pro uživatele. V tomto stavu Activity ještě není v popředí a nemůže komunikovat s uživatelem, ale jeho uživatelské rozhraní je již viditelné na obrazovce. Například při spouštění aplikace mezi voláním onStart a onResume systém vykreslí první snímek rozhraní.

V metodě onStart se obvykle provádějí následující akce: spuštění animací, které mají fungovat, dokud je Activity viditelné; propojení BroadcastReceiverů; připojení ke službám geolokace a senzorům; aktualizace dat z ViewModel nebo Room. Zde se také provádí propojení s Bound službami pomocí bindService(), pokud aplikace používá architekturu klient-server v rámci procesu.

override fun onStart() {
    super.onStart()
    val locationManager = getSystemService(Context.LOCATION_SERVICE) as LocationManager
    locationManager.requestLocationUpdates(
        LocationManager.GPS_PROVIDER,
        5000L,
        10f,
        locationListener
    )
}

override fun onStop() {
    super.onStop()
    val locationManager = getSystemService(Context.LOCATION_SERVICE) as LocationManager
    locationManager.removeUpdates(locationListener)
}

Důležité pravidlo: zdroje připojené v onStart musí být uvolněny v onStop. To zaručuje, že když Activity není viditelné na obrazovce, nespotřebovává baterii a systémové zdroje. Google Play Store kontroluje aplikace na únik LocationListener a dalších systémových služeb při moderování aktualizací.

onResume — získání fokusu

onResume() — stav, ve kterém je Activity v popředí a připraveno k interakci s uživatelem. Toto je pracovní stav obrazovky: systém předá vstupní fokus Activity a všechny události dotyku, klávesnice a gest jsou směrovány na tuto obrazovku. Metoda onResume se volá pokaždé, když se Activity vrátí do popředí — po dokončení jiného Activity, po zavření dialogového okna, po odemknutí zařízení.

V onResume se provádí: obnovení animací, které byly pozastaveny v onPause; otevření kamery a dalších exkluzivních zdrojů; registrace senzorových posluchačů (akcelerometr, gyroskop); spuštění časovačů a stopek pro UI; aktualizace obsahu obrazovky aktuálními daty. V páru onResume / onPause se pracuje se zdroji, které by měly být aktivní pouze při fokusu — například nepřetržité rozpoznávání řeči nebo snímání videa.

override fun onResume() {
    super.onResume()
    cameraHolder.openCamera()
    animator.resume()
    sensorManager.registerListener(
        stepCounter,
        sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER),
        SensorManager.SENSOR_DELAY_NORMAL
    )
}

override fun onPause() {
    super.onPause()
    cameraHolder.closeCamera()
    animator.pause()
    sensorManager.unregisterListener(stepCounter)
}

Rozdíl mezi onStart a onResume je významný: Activity může být viditelné (onStart), ale ne aktivní (onResume) — například když je nad ním zobrazeno vyskakovací dialogové okno nebo průhledná zamykací obrazovka. Právě v onResume, ne v onStart, by se měly otevírat exkluzivní zdroje, které vyžadují monopolní přístup.

onPause — ztráta fokusu

onPause() se volá, když Activity ztrácí vstupní fokus, ale zůstává částečně viditelné. Typické scénáře: otevření dialogového okna, stisknutí tlačítka „Nedávné aplikace“, příchozí hovor, stisknutí tlačítka „Domů“ (v tomto případě po onPause následuje onStop). Metoda onPause je poslední spolehlivé místo pro uložení dat, která by uživatel neměl ztratit.

V onPause se provádí: ukládání konceptů e-mailů a vstupních formulářů do Room nebo SharedPreferences; zastavení animací a přehrávání videa; zavření kamery a uvolnění monopolních zdrojů; zrušení nákladných operací, které nejsou kritické pro pozadí. Metoda onPause musí být dokončena za méně než 100 milisekund — systém blokuje přechod na další Activity, dokud onPause nevrátí řízení, a překročení limitu vede k ANR (Application Not Responding).

override fun onPause() {
    super.onPause()
    val editor = SharedPreferences.Manager ...
    editor.putString("draft_text", draftEditText.text.toString())
    editor.apply()
    videoView.pause()
    cameraHolder.release()
}

Důležité: onPause se provádí v UI vlákně, proto všechny blokující operace, jako je zápis do databáze přes Room se synchronním dotazem, musí být nahrazeny asynchronními (korutiny) nebo prováděny na vlákně na pozadí. Používejte apply() místo commit() pro SharedPreferences — apply zapisuje data asynchronně a neblokuje UI vlákno.

onStop — skrytí z obrazovky

onStop() se volá, když Activity přestane být viditelné pro uživatele. K tomu dochází v následujících případech: Activity je zcela zakryto jiným Activity; uživatel stiskl tlačítko „Domů“ nebo přešel na jinou aplikaci; Activity se ukončuje (poté bude volán onDestroy). Ve stavu onStop zůstává Activity v paměti a zachovává všechna svá pole — není zničeno, ale ani aktivní.

V onStop se provádí: odhlášení z BroadcastReceiverů registrovaných v onStart; odpojení od Bound služeb; uvolnění LocationListener, SensorListener a dalších systémových posluchačů; zastavení dlouhých operací na pozadí, které nejsou potřeba, když je aplikace skrytá; zápis aktuálního stavu UI do Bundle přes onSaveInstanceState(), pokud to nebylo provedeno v onPause.

override fun onStop() {
    super.onStop()
    unregisterReceiver(connectivityReceiver)
    unbindService(serviceConnection)
    if (isChangingConfigurations()) {
        Log.d("Lifecycle", "Activity je znovu vytvářeno kvůli konfiguraci")
    }
}

Systém může zničit Activity ve stavu onStop bez volání onDestroy při nedostatku paměti. Proto musí být všechna kritická data uložena před přechodem do onStop. Příznak isChangingConfigurations() umožňuje určit, zda volání onStop souvisí s otočením obrazovky — v tomto případě bude Activity znovu vytvořeno, nikoli ukončeno.

onDestroy — zničení Activity

onDestroy() — poslední metoda životního cyklu, volaná před úplným zničením Activity. Systém volá onDestroy ve dvou případech: Activity je ukončeno voláním finish() nebo uživatel stiskne tlačítko „Zpět“; Activity je zničeno systémem kvůli změně konfigurace (například otočení obrazovky) a bude znovu vytvořeno. Metoda onDestroy umožňuje konečné vyčištění zdrojů: odpojení vláken a korutin, zavření trvale otevřených kurzorů a socketů, uvolnění nativní paměti přes NDK.

override fun onDestroy() {
    super.onDestroy()
    backgroundJob.cancel()
    dbHelper.close()
    if (isFinishing) {
        Log.d("Lifecycle", "Activity je definitivně ukončeno")
    } else {
        Log.d("Lifecycle", "Activity bude znovu vytvořeno")
    }
}

Důležitá poznámka: onDestroy není zaručeno, pokud je proces aplikace zabit systémem (out-of-memory kill). Proto se nelze spoléhat na onDestroy pro ukládání dat — tento úkol se řeší v onPause nebo onStop. Vlastnost isFinishing umožňuje rozlišit ukončení Activity pomocí finish() od opětovného vytvoření při změně konfigurace.

onRestart — návrat ze zastaveného stavu

onRestart() se volá před onStart(), když se Activity vrací ze zastaveného stavu (onStop) zpět do popředí. K tomu dochází, když uživatel znovu otevře aplikaci z nabídky „Nedávné“ nebo se vrátí k Activity stisknutím tlačítka „Zpět“ na podřízené obrazovce. Metoda onRestart umožňuje provést logiku odlišnou od onCreate — například aktualizovat data, která se mohla změnit, zatímco bylo Activity skryto.

override fun onRestart() {
    super.onRestart()
    refreshDataFromNetwork()
    Log.d("Lifecycle", "Activity je restartováno ze zásobníku")
}

Typický scénář: uživatel otevřel aplikaci, přepnul se na jiný úkol a o hodinu později se vrátil. V onRestart může aplikace zkontrolovat aktuálnost dat a, pokud uplynulo mnoho času, nabídnout opětovné načtení obsahu. To zlepšuje uživatelský zážitek a snižuje pravděpodobnost zobrazení zastaralých informací.

Otáčení obrazovky a ukládání stavu

Otáčení obrazovky — nejčastější scénář opětovného vytvoření Activity. Ve výchozím nastavení Android ničí aktuální Activity a vytváří nové při každé změně orientace. Pokud není stav uložen, uživatel ztratí všechna zadaná data. K tomu Android poskytuje dva mechanismy: onSaveInstanceState() pro serializovatelná data a ViewModel pro data, která přežívají změny konfigurace.

onSaveInstanceState a onRestoreInstanceState

onSaveInstanceState() se volá před zničením Activity pro uložení dočasného stavu. Uložená data jsou předána do onCreate prostřednictvím parametru savedInstanceState a do metody onRestoreInstanceState(), která se volá po onStart. Bundle má omezení velikosti — přibližně 500 KB, proto se velké objemy dat (například bitmapy) ukládají přes ViewModel.

<!-- AndroidManifest.xml — fixace orientace -->
<activity android:name=".MainActivity"
    android:configChanges="orientation|screenSize" />

Fixace orientace pomocí android:configChanges zabraňuje opětovnému vytvoření Activity, ale považuje se za anti-vzor, pokud má aplikace podporovat obě orientace. Moderní doporučení Google — používat ViewModel v kombinaci s onSaveInstanceState pro data, která uživatel zadává do UI.

Životní cyklus Fragmentu

Fragment má svůj vlastní životní cyklus, podobný Activity, ale s dalšími metodami: onAttach, onCreate, onCreateView, onViewCreated, onStart, onResume, onPause, onStop, onDestroyView, onDestroy, onDetach. Fragment vždy existuje uvnitř Activity a jeho životní cyklus je vázán na životní cyklus kontejnerového Activity. Pokud je Activity zničeno, Fragment ho následuje.

Hlavní rozdíl: Fragment spravuje nejen stav komponenty, ale také hierarchii View. Metoda onCreateView vrací kořenový View fragmentu a onDestroyView tuto hierarchii ničí. To umožňuje Fragmentu přežít opětovné vytvoření Activity při otáčení obrazovky: Fragment je zachován a jeho View je znovu vytvořeno v onCreateView.

class ProfileFragment : Fragment() {
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        return inflater.inflate(R.layout.fragment_profile, container, false)
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        val avatarImage: ImageView = view.findViewById(R.id.avatar_image)
        loadAvatar(avatarImage)
    }
}

Porozumění rozdílu mezi onCreate a onCreateView je kriticky důležité: onCreate se volá jednou za život Fragmentu (i při opětovném vytvoření View), zatímco onCreateView se volá pokaždé, když Fragment vytváří nebo znovu vytváří svou hierarchii View. Inicializace dat se provádí v onCreate a propojení UI v onViewCreated.

LifecycleObserver a Jetpack

LifecycleObserver — komponenta knihovny Android Jetpack, která umožňuje reagovat na změny životního cyklu bez přepisování metod v Activity nebo Fragmentu. Místo duplikování kódu v každé metodě životního cyklu vytvoří vývojář samostatnou třídu s anotacemi @OnLifecycleEvent a předá ji do lifecycle.addObserver().

Jetpack také poskytuje třídu LifecycleOwner — rozhraní, které implementují AppCompatActivity a Fragment. Jakýkoli objekt implementující LifecycleOwner může spravovat odběry LiveData, korutiny pomocí lifecycleScope a práci WorkManageru ve vazbě na životní cyklus. To je základní kámen moderní architektury Android založené na MVVM a Jetpack.

class MyLocationObserver(private val context: Context) : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        startLocationUpdates()
    }

    override fun onStop(owner: LifecycleOwner) {
        stopLocationUpdates()
    }
}

// V Activity:
lifecycle.addObserver(MyLocationObserver(this))

Použití DefaultLifecycleObserver zjednodušuje testování, snižuje duplicitu kódu a činí logiku životního cyklu znovu použitelnou mezi různými obrazovkami. To je moderní náhrada ručního přepisování onStart/onStop v každém Activity. V Android aplikacích vyvinutých společností IT Sectr používáme LifecycleObserver pro geolokaci, Bluetooth skenování a analytiku — to snižuje množství boilerplate kódu o 30–40 %.