Activity Lifecycle: wat is het, onCreate onStart onResume in Android

Wat is Activity Lifecycle

Activity Lifecycle (levenscyclus van Activity) — een eindige toestandsmachine waar elke scherm van een Android-app doorheen gaat, van het moment van aanmaken tot volledige vernietiging. Het Android-systeem beheert dit proces op basis van gebruikersacties: openen van de app, minimaliseren, schermrotatie, beantwoorden van een inkomend gesprek, schakelen tussen apps en beëindigen.

Inzicht in de levenscyclus is noodzakelijk voor elke Android-ontwikkelaar, omdat het systeem op elk moment Activity kan vernietigen bij gebrek aan geheugen — en de app moet zijn status correct kunnen herstellen. Volgens Google Android Vitals (2025) vertonen apps die statusopslag in onSaveInstanceState() niet correct afhandelen 42% meer crashes bij het opnieuw aanmaken van Activity.

De levenscyclus omvat zes belangrijke callback-methoden: onCreate(), onStart(), onResume(), onPause(), onStop(), onDestroy(). Daarnaast is er de methode onRestart(), die wordt aangeroepen vóór onStart() wanneer Activity terugkeert uit de gestopte toestand. Elke methode heeft een strikt gedefinieerd doel en uitvoeringstijd — het systeem roept ze in volgorde aan en de ontwikkelaar kan elke methode overschrijven om zijn eigen logica uit te voeren.

De cyclus kan worden onderverdeeld in drie belangrijke fasen: volledige levensduur (onCreate → onDestroy), zichtbare levensduur (onStart → onStop) en voorgrond-levensduur (onResume → onPause). Inzicht in deze drie niveaus helpt bij het correct verdelen van initialisatiecode en het vrijgeven van bronnen.

Methoden van de Activity-levenscyclus

Elke methode van de levenscyclus voert een strikt gedefinieerde taak uit. Het systeem roept ze in een vaste volgorde aan en de ontwikkelaar mag alleen die methoden overschrijven die nodig zijn voor de specifieke logica. Het wordt afgeraden om levenscyclusmethoden rechtstreeks aan te roepen — dit wordt gedaan door Android Runtime.

Algemene aanroepschema

Typische volgorde bij het starten van de app: onCreate → onStart → onResume. Bij het indrukken van de knop “Terug”: onPause → onStop → onDestroy. Bij minimaliseren: onPause → onStop, vervolgens bij terugkeer: 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()
    }
}

Elke overschreven methode moet de super-versie aanroepen — zonder dit kan het systeem de overgang tussen toestanden niet correct voltooien. Deze regel is vastgelegd in de Android Developers-documentatie en wordt gecontroleerd door lint-regels in Android Studio.

Drie niveaus van de levenscyclus

Eerste niveau — volledige levensduur (entire lifetime): interval tussen onCreate en onDestroy. Hier vindt eenmalige initialisatie en definitieve vrijgave van globale bronnen plaats. Tweede niveau — zichtbare levensduur (visible lifetime): tussen onStart en onStop. Activity is zichtbaar op het scherm, maar kan gedeeltelijk worden bedekt door een ander venster. Derde niveau — voorgrond-levensduur (foreground lifetime): tussen onResume en onPause. Activity staat bovenaan de taakstapel en heeft interactie met de gebruiker.

onCreate — Activity aanmaken

onCreate() — de eerste en enige verplichte methode van de Activity-levenscyclus. Het wordt eenmaal door het systeem aangeroepen bij het maken van een Activity-instantie. Deze methode ontvangt de parameter savedInstanceState: Bundle? die de eerder opgeslagen status bevat, als Activity na vernietiging opnieuw wordt aangemaakt — bijvoorbeeld bij schermrotatie.

Binnen onCreate worden de volgende taken uitgevoerd: initialisatie van de gebruikersinterface via setContentView() met doorgeven van de layout-resource, binding van View-elementen via findViewById(), instellen van adapters voor RecyclerView en ViewPager, herstellen van status uit savedInstanceState, initialisatie van ViewModel en LiveData, instellen van klik- en gebarenluisteraars. De methode moet zo snel mogelijk worden voltooid — langdurige bewerkingen blokkeren hier het renderen van het eerste frame, wat de opstarttijd van de app verlengt.

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

Als Activity voor de eerste keer wordt aangemaakt, is savedInstanceState gelijk aan null. Bij opnieuw aanmaken na schermrotatie bevat de Bundle de gegevens die zijn opgeslagen in onSaveInstanceState(). Null-controle is een standaardpraktijk voor correct herstel van de UI zonder verlies van door de gebruiker ingevoerde gegevens.

onStart — verschijnen op het scherm

onStart() wordt onmiddellijk na onCreate() of na onRestart() aangeroepen, wanneer Activity zichtbaar wordt voor de gebruiker. In deze toestand staat Activity nog niet op de voorgrond en kan het niet met de gebruiker interageren, maar de gebruikersinterface is al zichtbaar op het scherm. Bij het starten van de app, tussen de aanroep van onStart en onResume, rendert het systeem bijvoorbeeld het eerste frame van de interface.

In de methode onStart worden meestal de volgende acties uitgevoerd: starten van animaties die moeten werken zolang Activity zichtbaar is; binden van BroadcastReceivers; verbinden met geolocatie-services en sensoren; bijwerken van gegevens uit ViewModel of Room. Ook wordt hier binding met Bound-services via bindService() uitgevoerd, als de app een client-server-architectuur binnen het proces gebruikt.

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)
}

Belangrijke regel: bronnen die in onStart zijn verbonden, moeten in onStop worden vrijgegeven. Dit garandeert dat wanneer Activity niet zichtbaar is op het scherm, het geen batterij en systeembronnen verbruikt. Google Play Store controleert apps op lekkage van LocationListener en andere systeemdiensten bij het modereren van updates.

onResume — focus krijgen

onResume() — de toestand waarin Activity op de voorgrond staat en klaar is voor interactie met de gebruiker. Dit is de werktoestand van het scherm: het systeem geeft de invoerfocus aan Activity en alle aanraak-, toetsenbordinvoer- en gebeurtenissen worden naar dit scherm gestuurd. De methode onResume wordt elke keer aangeroepen wanneer Activity terugkeert naar de voorgrond — na voltooiing van een andere Activity, na het sluiten van een dialoogvenster, na het ontgrendelen van het apparaat.

In onResume wordt uitgevoerd: hervatten van animaties die in onPause waren gepauzeerd; openen van de camera en andere exclusieve bronnen; registreren van sensorluisteraars (accelerometer, gyroscoop); starten van timers en stopwatches voor de UI; bijwerken van de scherminhoud met actuele gegevens. In het paar onResume / onPause wordt gewerkt met bronnen die alleen actief mogen zijn bij focus — bijvoorbeeld continue spraakherkenning of video-opname.

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)
}

Het verschil tussen onStart en onResume is aanzienlijk: Activity kan zichtbaar zijn (onStart), maar niet actief (onResume) — bijvoorbeeld wanneer er een pop-updialoogvenster of een transparant vergrendelscherm boven wordt weergegeven. Juist in onResume, niet in onStart, moeten exclusieve bronnen worden geopend die monopolistische toegang nodig hebben.

onPause — focus verliezen

onPause() wordt aangeroepen wanneer Activity de invoerfocus verliest, maar gedeeltelijk zichtbaar blijft. Typische scenario's: openen van een dialoogvenster, indrukken van de knop “Recente apps”, inkomend gesprek, indrukken van de knop “Home” (in dit geval volgt na onPause onStop). De methode onPause is de laatste betrouwbare plek om gegevens op te slaan die de gebruiker niet mag verliezen.

In onPause wordt uitgevoerd: opslaan van e-mailconcepten en invoerformulieren in Room of SharedPreferences; stoppen van animaties en videoweergave; sluiten van de camera en vrijgeven van monopolistische bronnen; annuleren van dure bewerkingen die niet kritisch zijn voor de achtergrond. De methode onPause moet binnen minder dan 100 milliseconden worden voltooid — het systeem blokkeert de overgang naar de volgende Activity totdat onPause de controle teruggeeft en overschrijding van de limiet leidt tot 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()
}

Belangrijk: onPause wordt uitgevoerd in de UI-thread, dus alle blokkerende bewerkingen, zoals schrijven naar de database via Room met een synchrone query, moeten worden vervangen door asynchrone (coroutines) of worden uitgevoerd in een achtergrondthread. Gebruik apply() in plaats van commit() voor SharedPreferences — apply schrijft gegevens asynchroon en blokkeert de UI-thread niet.

onStop — verbergen van het scherm

onStop() wordt aangeroepen wanneer Activity niet langer zichtbaar is voor de gebruiker. Dit gebeurt in de volgende gevallen: Activity is volledig bedekt door een andere Activity; de gebruiker heeft op “Home” gedrukt of is naar een andere app geschakeld; Activity wordt beëindigd (vervolgens wordt onDestroy aangeroepen). In de toestand onStop blijft Activity in het geheugen en behoudt al zijn velden — het is niet vernietigd, maar ook niet actief.

In onStop wordt uitgevoerd: uitschrijven van BroadcastReceivers die in onStart zijn geregistreerd; loskoppelen van Bound-services; vrijgeven van LocationListener, SensorListener en andere systeemluisteraars; stoppen van langdurige achtergrondbewerkingen die niet nodig zijn wanneer de app verborgen is; schrijven van de huidige UI-status naar Bundle via onSaveInstanceState(), als dit niet in onPause is gedaan.

override fun onStop() {
    super.onStop()
    unregisterReceiver(connectivityReceiver)
    unbindService(serviceConnection)
    if (isChangingConfigurations()) {
        Log.d("Lifecycle", "Activity wordt opnieuw aangemaakt vanwege configuratie")
    }
}

Het systeem kan Activity in de toestand onStop vernietigen zonder onDestroy aan te roepen bij gebrek aan geheugen. Daarom moeten alle kritieke gegevens worden opgeslagen vóór de overgang naar onStop. De vlag isChangingConfigurations() maakt het mogelijk om te bepalen of de aanroep van onStop verband houdt met schermrotatie — in dat geval wordt Activity opnieuw aangemaakt, niet beëindigd.

onDestroy — Activity vernietigen

onDestroy() — de laatste methode van de levenscyclus, aangeroepen vóór volledige vernietiging van Activity. Het systeem roept onDestroy in twee gevallen aan: Activity wordt beëindigd door aanroep van finish() of de gebruiker drukt op de knop “Terug”; Activity wordt door het systeem vernietigd vanwege een configuratiewijziging (bijv. schermrotatie) en wordt opnieuw aangemaakt. De methode onDestroy maakt definitieve opschoning van bronnen mogelijk: loskoppelen van threads en coroutines, sluiten van permanent geopende cursors en sockets, vrijgeven van native geheugen via NDK.

override fun onDestroy() {
    super.onDestroy()
    backgroundJob.cancel()
    dbHelper.close()
    if (isFinishing) {
        Log.d("Lifecycle", "Activity wordt definitief beëindigd")
    } else {
        Log.d("Lifecycle", "Activity wordt opnieuw aangemaakt")
    }
}

Belangrijke opmerking: onDestroy is niet gegarandeerd als het proces van de app door het systeem wordt gedood (out-of-memory kill). Daarom kan niet op onDestroy worden vertrouwd voor het opslaan van gegevens — deze taak wordt in onPause of onStop opgelost. De eigenschap isFinishing maakt het mogelijk om beëindiging van Activity via finish() te onderscheiden van opnieuw aanmaken bij configuratiewijziging.

onRestart — terugkeer uit de gestopte toestand

onRestart() wordt aangeroepen vóór onStart(), wanneer Activity terugkeert uit de gestopte toestand (onStop) naar de voorgrond. Dit gebeurt wanneer de gebruiker de app opnieuw opent vanuit het menu “Recente apps” of terugkeert naar Activity door op “Terug” te drukken in een onderliggend scherm. De methode onRestart maakt het mogelijk om logica uit te voeren die verschilt van onCreate — bijvoorbeeld het bijwerken van gegevens die mogelijk zijn gewijzigd terwijl Activity verborgen was.

override fun onRestart() {
    super.onRestart()
    refreshDataFromNetwork()
    Log.d("Lifecycle", "Activity wordt vanuit de stack opnieuw gestart")
}

Typisch scenario: de gebruiker opende de app, schakelde over naar een andere taak en keerde een uur later terug. In onRestart kan de app de actualiteit van gegevens controleren en, als er veel tijd is verstreken, aanbieden om de inhoud opnieuw te laden. Dit verbetert de gebruikerservaring en vermindert de kans op het tonen van verouderde informatie.

Schermrotatie en status opslaan

Schermrotatie — het meest voorkomende scenario voor het opnieuw aanmaken van Activity. Standaard vernietigt Android de huidige Activity en maakt een nieuwe bij elke oriëntatiewijziging. Als de status niet wordt opgeslagen, verliest de gebruiker alle ingevoerde gegevens. Hiervoor biedt Android twee mechanismen: onSaveInstanceState() voor serialiseerbare gegevens en ViewModel voor gegevens die configuratiewijzigingen overleven.

onSaveInstanceState en onRestoreInstanceState

onSaveInstanceState() wordt aangeroepen vóór vernietiging van Activity om de tijdelijke status op te slaan. Opgeslagen gegevens worden doorgegeven aan onCreate via de parameter savedInstanceState en aan de methode onRestoreInstanceState(), die na onStart wordt aangeroepen. Bundle heeft een groottebeperking — ongeveer 500 KB, dus grote hoeveelheden gegevens (bijv. bitmaps) worden opgeslagen via ViewModel.

<!-- AndroidManifest.xml — oriëntatie vastzetten -->
<activity android:name=".MainActivity"
    android:configChanges="orientation|screenSize" />

Het vastzetten van de oriëntatie via android:configChanges voorkomt het opnieuw aanmaken van Activity, maar wordt beschouwd als een antipatroon als de app beide oriëntaties moet ondersteunen. De moderne aanbeveling van Google — gebruik ViewModel in combinatie met onSaveInstanceState voor gegevens die de gebruiker in de UI invoert.

Levenscyclus van Fragment

Fragment heeft zijn eigen levenscyclus, vergelijkbaar met Activity, maar met extra methoden: onAttach, onCreate, onCreateView, onViewCreated, onStart, onResume, onPause, onStop, onDestroyView, onDestroy, onDetach. Fragment bestaat altijd binnen Activity en zijn levenscyclus is gekoppeld aan de levenscyclus van de container-Activity. Als Activity wordt vernietigd, volgt Fragment.

Het belangrijkste verschil: Fragment beheert niet alleen de status van de component, maar ook de View-hiërarchie. De methode onCreateView retourneert de root-View van het fragment en onDestroyView vernietigt deze hiërarchie. Dit stelt Fragment in staat om het opnieuw aanmaken van Activity bij schermrotatie te overleven: Fragment blijft behouden en zijn View wordt opnieuw aangemaakt in 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)
    }
}

Inzicht in het verschil tussen onCreate en onCreateView is van cruciaal belang: onCreate wordt eenmaal aangeroepen in de levensduur van Fragment (zelfs bij opnieuw aanmaken van View), terwijl onCreateView elke keer wordt aangeroepen wanneer Fragment zijn View-hiërarchie aanmaakt of opnieuw aanmaakt. Initialisatie van gegevens gebeurt in onCreate en UI-binding in onViewCreated.

LifecycleObserver en Jetpack

LifecycleObserver — een component van de Android Jetpack-bibliotheek die het mogelijk maakt om te reageren op veranderingen in de levenscyclus zonder methoden in Activity of Fragment te overschrijven. In plaats van code te dupliceren in elke levenscyclusmethode, maakt de ontwikkelaar een aparte klasse met @OnLifecycleEvent-annotaties en geeft deze door aan lifecycle.addObserver().

Jetpack biedt ook de klasse LifecycleOwner — een interface die wordt geïmplementeerd door AppCompatActivity en Fragment. Elk object dat LifecycleOwner implementeert, kan LiveData-abonnementen, coroutines via lifecycleScope en WorkManager-taken beheren in combinatie met de levenscyclus. Dit is de hoeksteen van moderne Android-architectuur op basis van MVVM en Jetpack.

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

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

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

Het gebruik van DefaultLifecycleObserver vereenvoudigt testen, vermindert codeduplicatie en maakt de levenscycluslogica herbruikbaar tussen verschillende schermen. Dit is een moderne vervanging voor het handmatig overschrijven van onStart/onStop in elke Activity. In Android-apps ontwikkeld door IT Sectr passen we LifecycleObserver toe voor geolocatie, Bluetooth-scannen en analyse — dit vermindert de hoeveelheid boilerplate-code met 30–40%.