onDestroy: wat is het, beëindigen van Activity in Android

onDestroy: wat is het in Android?

onDestroy — een callback-methode die Android aanroept voordat het Activity of Fragment definitief vernietigt. Dit is de laatste kans voor de ontwikkelaar om bronnen vrij te maken, achtergrondbewerkingen te annuleren en het werk met gegevens te beëindigen. Na uitvoering van onDestroy wordt de instantie Activity/Fragment gemarkeerd voor garbage collection (GC) en kan niet meer worden gebruikt.

Redenen voor het aanroepen van onDestroy:

• Expliciete aanroep van finish() — de gebruiker heeft op „Terug" gedrukt of de ontwikkelaar heeft finishActivity() aangeroepen.
• Schermrotatie — Activity wordt vernietigd en opnieuw gemaakt met een nieuwe configuratie.
• Configuratiewijziging — toetsenbord, taalwijziging, wijziging van schermgrootte (multi-window).
• Systeembeslissing — Android vernietigt Activity om bronnen vrij te maken (maar onDestroy wordt mogelijk niet aangeroepen).

Volgens Google Android Vitals-statistieken (2025) is ongeveer 12% van alle gevallen van vernietiging van Activity te wijten aan schermrotatie, 65% aan finish() en 23% aan configuratiewijziging. Het percentage procesdodingen met overslaan van onDestroy is ongeveer 5–8%, afhankelijk van apparaten met weinig RAM (minder dan 4 GB).

Wanneer onDestroy wordt aangeroepen — en wanneer niet

onDestroy wordt in de meeste standaardsituaties aangeroepen, maar er zijn belangrijke uitzonderingen waar de ontwikkelaar rekening mee moet houden. Inzicht in de garanties van de aanroep van onDestroy is cruciaal voor de architectuur van de applicatie, met name voor het opslaan van gegevens en het annuleren van WorkManager-taken.

Wanneer onDestroy wordt aangeroepen:

• De gebruiker drukt op de knop „Terug" — Activity.finish() → onPause → onStop → onDestroy.
• Schermrotatie — Activity wordt vernietigd (onPause → onStop → onDestroy), vervolgens opnieuw gemaakt.
• Configuratiewijziging — systeeminstelling die het opnieuw maken van Activity vereist.
• Aanroep van finishAffinity() — beëindigen van alle Activity in de stack.
• Verwijderen van Fragment uit FragmentManager — Fragment ontvangt onPause → onStop → onDestroyView → onDestroy → onDetach.

Wanneer onDestroy NIET wordt aangeroepen:

• Procesdoding door het systeem (process death) — Android doodt het hele proces van de applicatie bij geheugengebrek. Activity ontvangt geen onDestroy omdat het proces op Linux-kernelniveau wordt beëindigd.
• Noodstop — een niet-afgevangen uitzondering in de hoofdthread doodt de applicatie zonder aanroep van onDestroy.
• Force Stop — de gebruiker stopt de applicatie geforceerd in de instellingen.

Vanwege het ontbreken van een garantie voor de aanroep van onDestroy beveelt Google aan: vertrouw nooit op onDestroy voor het opslaan van kritieke gegevens. Gebruik onSaveInstanceState(), WorkManager of Room met automatisch opslaan. onDestroy — voor het vrijmaken van bronnen, niet voor persistentie.

onDestroy in Activity en Fragment: overeenkomsten en verschillen

onDestroy bestaat zowel voor Activity als voor Fragment, maar met verschillende contracten. Bij Fragment is de levenscyclus gedetailleerder: naast onDestroy zijn er onDestroyView (vernietiging van de View-hiërarchie) en onDetach (loskoppeling van Activity).

Het belangrijkste verschil: bij Fragment wordt View vaker opnieuw gemaakt dan het Fragment zelf. Bij schermrotatie doorloopt Fragment onDestroyView (vernietiging van View), maar het Fragment zelf en zijn ViewModel blijven leven. onDestroyView — de juiste plaats voor het opschonen van verwijzingen naar View om geheugenlekken te voorkomen. onDestroy van Fragment — analoog aan onDestroy van Activity, aangeroepen bij volledige verwijdering van Fragment.

Geneste fragmenten (child fragments) worden vernietigd vóór onDestroy van het bovenliggende Fragment. In Activity ontvangen onderliggende fragmenten onDestroy bij het aanroepen van onDestroy van het bovenliggende Activity. De volgorde is gegarandeerd: fragmenten eindigen eerder dan het Activity dat ze bevat.

Wat te doen in onDestroy: opruimchecklist

onDestroy is bedoeld voor het vrijmaken van alle bronnen die niet langer mogen leven dan Activity of Fragment. In tegenstelling tot onStop, dat bronnen vrijmaakt tot de terugkeer, voert onDestroy de definitieve opschoning uit.

Checklist van verplichte acties in onDestroy:

• Annuleren van coroutines en Flow — annuleer jobs die niet zijn gekoppeld aan viewModelScope. viewModelScope wordt automatisch geannuleerd, maar lifecycleScope is gekoppeld aan de levenscyclus van Activity.
• Sluiten van sockets en kanalen — WebSocket (OkHttp), BluetoothSocket, ServerSocket. Ze open houden na vernietiging is een lek van systeembronnen.
• Sluiten van bestanden en streams — FileInputStream, FileOutputStream, Cursor. Cursor kan ANR veroorzaken op ContentProvider als deze niet wordt gesloten.
• Uitschrijven van ContentObserver — als Activity inhoudswijzigingen (contacten, mediatheek) volgt.
• Uitschrijven van BroadcastReceiver — dynamisch geregistreerde receivers moeten worden geannuleerd.
• Sluiten van de database — Room sluit de verbinding automatisch bij vernietiging van Application, maar directe SQLiteDatabase vereist handmatig close().

Wat NIET te doen in onDestroy: Sla geen gegevens op in onDestroy — gebruik onPause of onSaveInstanceState. Start geen nieuwe Service of WorkManager-taken — Activity wordt vernietigd en u kunt het resultaat niet volgen. Probeer de UI niet bij te werken — de View-hiërarchie is al vernietigd of in het proces van vernietiging; aanroep van findViewById() retourneert null.

onDestroy en ViewModel: samenwerking

ViewModel is ontworpen om onDestroy van Activity te overleven bij schermrotatie, maar samen met Activity te worden vernietigd bij finish(). Dit asymmetrische gedrag — de belangrijkste oorzaak van verwarring bij ontwikkelaars.

Bij schermrotatie:

• Activity: onPause → onStop → onDestroy (Activity vernietigd).
• ViewModel: NIET vernietigd — ViewModelStore wordt bewaard en doorgegeven aan het nieuwe Activity.
• Nieuw Activity: onCreate → onStart → onResume, ontvangt dezelfde ViewModel.

Bij finish() (gebruiker heeft op „Terug" gedrukt):

• Activity: onPause → onStop → onDestroy.
• ViewModel: onCleared() — aangeroepen na onDestroy van Activity.
• Alle coroutines van viewModelScope worden automatisch geannuleerd.

Het annuleren van viewModelScope in onDestroy is dus niet nodig — ViewModel doet dit zelf. Als u lifecycleScope (gebonden aan Activity, niet aan ViewModel) gebruikt, annuleer deze dan in onDestroy via lifecycleScope.cancel() of beheer Job handmatig.

Codevoorbeelden met onDestroy in Kotlin

Voorbeeld 1: onDestroy Activity met annuleren van lifecycleScope-coroutine

Demonstreert correct beheer van lifecycleScope in Activity: de coroutine wordt gestart voor het volgen van de netwerkstatus en geannuleerd in onDestroy.

class NetworkMonitorActivity : AppCompatActivity() {
    private val networkCallback = object : ConnectivityManager.NetworkCallback() {
        override fun onAvailable(network: Network) {
            Log.d("NetworkMonitor", "Netwerk beschikbaar")
        }
        override fun onLost(network: Network) {
            Log.d("NetworkMonitor", "Netwerk verloren")
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_network)
        val connectivityManager = getSystemService(ConnectivityManager::class.java)
        connectivityManager.registerDefaultNetworkCallback(networkCallback)
        lifecycleScope.launch {
            Log.d("NetworkMonitor", "Netwerkmonitoring gestart")
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        val connectivityManager = getSystemService(ConnectivityManager::class.java)
        connectivityManager.unregisterNetworkCallback(networkCallback)
        Log.d("NetworkMonitor", "onDestroy: callback geannuleerd")
    }
}

In onDestroy wordt de registratie van de netwerk-callback geannuleerd. lifecycleScope wordt automatisch geannuleerd bij vernietiging van de levenscyclus — afzonderlijk annuleren van de coroutine is niet nodig. De netwerk-callback moet verplicht worden uitgeschreven, anders blijft deze in het systeem hangen, zelfs na vernietiging van Activity.

Voorbeeld 2: onDestroy Fragment met opschonen van View-verwijzingen

Fragment ruimt correct verwijzingen naar View op in onDestroyView, waardoor geheugenlekken veroorzaakt door closures worden voorkomen.

class ProfileFragment : Fragment() {
    private var avatarView: ImageView? = null
    private var progressBar: ProgressBar? = null
    private val imageLoader = ImageLoader()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        avatarView = view.findViewById(R.id.avatar)
        progressBar = view.findViewById(R.id.progress)
        loadProfile()
    }

    private fun loadProfile() {
        viewLifecycleOwner.lifecycleScope.launch {
            try {
                progressBar?.visibility = View.VISIBLE
                val bitmap = imageLoader.load("https://example.com/avatar.png")
                avatarView?.setImageBitmap(bitmap)
            } finally {
                progressBar?.visibility = View.GONE
            }
        }
    }

    override fun onDestroyView() {
        super.onDestroyView()
        avatarView = null
        progressBar = null
        imageLoader.cancel()
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.d("ProfileFragment", "onDestroy: Fragment volledig vernietigd")
    }
}

In onDestroyView worden verwijzingen naar View op nul gezet — dit voorkomt geheugenlekken als de closure in imageLoader een verwijzing naar avatarView vasthoudt. Het Fragment zelf en zijn ViewModel blijven leven tot onDestroy. imageLoader.cancel() annuleert het laden als Fragment het scherm verlaat.

Voorbeeld 3: Controleren van isFinishing in onDestroy

Het gebruik van isFinishing() maakt het mogelijk te onderscheiden of Activity wordt beëindigd op gebruikerscommando of voor opnieuw maken.

class AnalyticsActivity : AppCompatActivity() {
    private val analytics = Analytics()

    override fun onDestroy() {
        if (isFinishing) {
            Log.d("AnalyticsActivity", "Activity eindigt met finish() — analytics verzenden")
            analytics.sendSessionEnd()
        } else {
            Log.d("AnalyticsActivity", "Activity wordt opnieuw gemaakt (rotatie/configuratie) — geen analytics verzenden")
        }
        super.onDestroy()
    }
}

Het controleren van isFinishing() — een belangrijk patroon voor analytics, logging en opschonen van sessiegegevens. Bij rotatie hoeven geen sessie-eindegebeurtenissen te worden verzonden — de gebruiker werkt nog steeds met de applicatie. Volgens Google Analytics is onjuiste controle van isFinishing() de oorzaak van 40% van de valse sessiegebeurtenissen.