Fragment Lifecycle: basis, methoden onCreateView onViewCreated

Fragment Lifecycle: basis van de levenscyclus

Fragment Lifecycle is een set van onderling verbonden toestanden en methoden waar elke Fragment-instantie doorheen gaat van het moment van creatie tot vernietiging. In tegenstelling tot Activity is de levenscyclus van Fragment verbonden met twee contexten: het Fragment zelf (leeft van onAttach tot onDetach) en zijn View (leeft van onCreateView tot onDestroyView). Deze scheiding is een belangrijk kenmerk van Fragment, waardoor het vernietiging van de View bij schermrotatie kan overleven zonder het Fragment zelf te vernietigen.

Volledige reeks callbacks van Fragment:

• onAttach(Context) — Fragment wordt aan Activity gekoppeld. Wordt als eerste aangeroepen. Context — Activity-host.
• onCreate(Bundle) — Fragment wordt geïnitialiseerd. Hier worden ViewModel gemaakt, adapters geconfigureerd.
• onCreateView(LayoutInflater, ViewGroup, Bundle) — de View-hiërarchie van Fragment wordt gemaakt. Geeft de root-View terug.
• onViewCreated(View, Bundle) — View is gemaakt. Hier worden UI-elementen geconfigureerd, LiveData-abonnementen ingesteld.
• onStart() — Fragment is zichtbaar. Animatie wordt gestart, sensoren worden geregistreerd.
• onResume() — Fragment is actief, werkt samen met de gebruiker.
• onPause() — Fragment verliest focus. Animatie wordt gestopt.
• onStop() — Fragment is onzichtbaar. Niet-kritieke bronnen worden vrijgemaakt.
• onDestroyView() — de View-hiërarchie wordt vernietigd. Verwijzingen naar View worden op nul gezet.
• onDestroy() — Fragment wordt vernietigd. Coroutines die niet in viewModelScope zijn, worden geannuleerd.
• onDetach() — Fragment wordt losgekoppeld van Activity. Definitieve opschoning.

Volgens Google doorloopt de gemiddelde fragment in een moderne app de volledige cyclus 3–5 keer per gebruikerssessie (vanwege schermrotaties en navigatie). Correcte verwerking van alle fasen is de basis van UI-stabiliteit.

Toestanden van Fragment: van INITIALIZED tot DESTROYED

FragmentManager beheert Fragment via vijf hoofdtoestanden, gedefinieerd in de klasse Fragment.State. Elke toestand komt overeen met een specifieke set callbacks die zijn uitgevoerd.

FragmentManager verplaatst Fragment tussen toestanden op basis van gebruikersacties en systeemgebeurtenissen. Bij het toevoegen van Fragment aan een container doorloopt het achtereenvolgens INITIALIZED → CREATED → STARTED → RESUMED. Bij verwijdering — RESUMED → STARTED → CREATED → DESTROYED.

Toestand CREATED — bijzonder: View kan worden vernietigd (na onDestroyView), maar het Fragment zelf blijft in de toestand CREATED (na onDestroyView, vóór onDestroy). Hierdoor kan FragmentManager het Fragment in het geheugen houden zonder View, wat nodig is om schermrotaties te overleven.

Verschil tussen Fragment Lifecycle en Activity Lifecycle

Fragment Lifecycle en Activity Lifecycle zijn nauw verbonden, maar hebben fundamentele verschillen. Fragment leeft altijd binnen een Activity en zijn levenscyclus hangt af van de gastheer-Activity, maar is er niet identiek aan.

Belangrijkste praktische verschil: bij schermrotatie wordt Activity volledig vernietigd (onDestroy) en opnieuw gemaakt (onCreate). Fragment doorloopt bij rotatie onDestroyView (View wordt vernietigd) → onCreateView (View wordt opnieuw gemaakt), maar het Fragment zelf en zijn ViewModel blijven leven. Dit maakt Fragment een ideale container voor UI-logica die configuratiewijzigingen moet overleven.

Aanroepvolgorde bij schermrotatie: Activity.onPause → Fragment.onPause → Activity.onStop → Fragment.onStop → Activity.onDestroy → Fragment.onDestroyView → (Activity vernietigd) → Activity.onCreate → Fragment.onAttach → Fragment.onCreate → Fragment.onCreateView → Fragment.onViewCreated → Activity.onStart → Fragment.onStart → Activity.onResume → Fragment.onResume.

FragmentManager: beheer van toestanden en transacties

FragmentManager — de centrale klasse verantwoordelijk voor het toevoegen, verwijderen, vervangen van fragmenten en het beheren van hun toestanden. FragmentManager onderhoudt de BackStack-stack en garandeert de juiste volgorde van callbacks bij transacties. Elke Activity en elke geneste Fragment heeft zijn eigen FragmentManager.

Belangrijkste operaties van FragmentManager:

• beginTransaction() — opent een transactie voor een groep bewerkingen.
• add() — voegt Fragment toe aan een container. Fragment doorloopt de volledige lifecycle tot RESUMED.
• replace() — vervangt het huidige Fragment door een nieuwe. is gelijk aan remove() + add().
• remove() — verwijdert Fragment. Fragment doorloopt lifecycle van RESUMED tot DESTROYED.
• hide()/show() — verbergt/toont Fragment zonder de View te vernietigen. Fragment gaat naar STARTED bij hide, terug naar RESUMED bij show.
• detach()/attach() — koppelt los/koppelt Fragment. detach vernietigt View (onDestroyView), attach maakt opnieuw (onCreateView).
• addToBackStack() — voegt transactie toe aan BackStack voor navigatie „Terug“.

BackStack — stack van FragmentManager-transacties. Bij indrukken van de systeemknop „Terug“ wordt de laatste transactie in BackStack teruggedraaid (popBackStack()). Fragment verwijderd via popBackStack wordt hersteld. Als BackStack leeg is, beëindigt indrukken van „Terug“ de Activity.

Volgens Google is 78% van de problemen met Fragment (duplicatie, lege schermen, IllegalStateException) gerelateerd aan onjuist gebruik van FragmentManager. Hoofdregel: voer transacties uit via commit() (asynchroon) of commitNow() (synchroon) afhankelijk van de context. commit() garandeert de juiste volgorde bij meerdere transacties.

Status van Fragment opslaan: onSaveInstanceState

Fragment ondersteunt zijn eigen mechanisme voor statusopslag via onSaveInstanceState, dat onafhankelijk van Activity werkt. Fragment slaat status op in Bundle, die wordt doorgegeven aan onCreate en onCreateView bij herstel.

Wanneer Fragment status opslaat:

• Bij schermrotatie — View wordt vernietigd, Fragment slaat status op in Bundle.
• Bij koppeling van Fragment aan Activity na process death.
• Bij aanroep van onSaveInstanceState vanuit Activity (systeem verspreidt opslag naar alle onderliggende fragmenten).

Moderne aanpak: gebruik SavedStateHandle in ViewModel voor statusopslag van Fragment. SavedStateHandle slaat automatisch gegevens op en herstelt ze bij schermrotatie en process death, zonder handmatige onSaveInstanceState. Google beveelt SavedStateHandle aan als de voorkeursmethode voor statusopslag van UI in Fragment.

setRetainInstance (verouderd sinds Fragment 1.3): voorheen kon Fragment worden behouden via setRetainInstance(true) bij schermrotatie. Deze aanpak is vervangen door ViewModel + SavedStateHandle, die betrouwbaarder werken en geen speciale configuratie vereisen.

viewLifecycleOwner: aparte levenscyclus van de View

viewLifecycleOwner — Lifecycle gekoppeld aan de View van Fragment (van onCreateView tot onDestroyView). Dit is een fundamenteel belangrijk concept: LiveData/Flow-abonnementen gemaakt via viewLifecycleOwner worden automatisch geannuleerd bij vernietiging van de View (onDestroyView), maar hebben geen invloed op het Fragment zelf.

Verschil tussen viewLifecycleOwner en lifecycle van Fragment:

• lifecycle (Fragment) — leeft van onAttach tot onDetach. Abonnementen blijven actief, zelfs na vernietiging van de View.
• viewLifecycleOwner — leeft van onCreateView tot onDestroyView. Abonnementen worden geannuleerd bij vernietiging van de View.

Waarom dit belangrijk is: als u zich abonneert op LiveData via de lifecycle van Fragment (this), blijft het abonnement na onDestroyView actief en zal LiveData proberen de null-View bij te werken, wat NPE veroorzaakt. Abonnement via viewLifecycleOwner garandeert dat er na onDestroyView geen UI-updates plaatsvinden.

Regel: gebruik in Fragment altijd viewLifecycleOwner voor abonnementen op LiveData, Flow en coroutines die verband houden met UI. Gebruik voor ViewModel-coroutines viewModelScope — deze is gekoppeld aan ViewModel, niet aan Fragment.

Codevoorbeelden van Fragment in Kotlin

Voorbeeld 1: Basis Fragment met onViewCreated en viewLifecycleOwner

Demonstreert correcte initialisatie van UI en LiveData-abonnement via viewLifecycleOwner.

class UserListFragment : Fragment() {
    private val viewModel: UserListViewModel by viewModels()

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

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        val button: Button = view.findViewById(R.id.load_button)
        button.setOnClickListener { viewModel.loadUsers() }
        viewModel.users.observe(viewLifecycleOwner) { users ->
            Log.d("UserListFragment", "Lijst bijwerken: ${users.size} gebruikers")
        }
    }

    override fun onDestroyView() {
        super.onDestroyView()
        Log.d("UserListFragment", "onDestroyView: View vernietigd")
    }
}

Fragment blaast de layout op in onCreateView, configureert UI en abonneert zich op LiveData in onViewCreated. Abonnement via viewLifecycleOwner — een verplichte vereiste om geheugenlekken te voorkomen. onDestroyView logt de vernietiging van View — bevestiging dat Fragment schermrotatie overleeft.

Voorbeeld 2: Fragment met FragmentManager en transacties

Demonstreert het toevoegen van Fragment via FragmentManager in Activity, vervanging met BackStack en herstel.

class HostActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_host)
        if (savedInstanceState == null) {
            supportFragmentManager.beginTransaction()
                .add(R.id.fragment_container, HomeFragment())
                .addToBackStack(null)
                .commit()
        }
    }

    fun openDetail(userId: String) {
        supportFragmentManager.beginTransaction()
            .replace(R.id.fragment_container, DetailFragment.newInstance(userId))
            .addToBackStack(null)
            .commit()
    }

    override fun onBackPressed() {
        if (supportFragmentManager.backStackEntryCount > 0) {
            supportFragmentManager.popBackStack()
        } else {
            super.onBackPressed()
        }
    }
}

class DetailFragment : Fragment() {
    companion object {
        fun newInstance(userId: String): DetailFragment {
            return DetailFragment().apply {
                arguments = Bundle().apply { putString("user_id", userId) }
            }
        }
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        val userId = arguments?.getString("user_id")
        Log.d("DetailFragment", "Gebruikersdetails laden: $userId")
    }
}

Activity gebruikt supportFragmentManager voor het beheren van fragmenten. De transactie add() met BackStack garandeert dat HomeFragment wordt hersteld bij indrukken van „Terug“. openDetail() vervangt het huidige Fragment door DetailFragment met argumenten. Controle savedInstanceState == null voorkomt duplicatie van fragmenten bij schermrotatie.

Voorbeeld 3: Fragment met LifecycleObserver en StateFlow

Gebruik van Flow en StateFlow in Fragment met viewLifecycleOwner voor reactieve UI-updates.

class SearchFragment : Fragment() {
    private val viewModel: SearchViewModel by viewModels()
    private var binding: FragmentSearchBinding? = null

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        binding = FragmentSearchBinding.inflate(inflater, container, false)
        return binding!!.root
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        binding?.searchButton?.setOnClickListener {
            viewModel.search(binding?.queryInput?.text.toString())
        }
        viewLifecycleOwner.lifecycleScope.launch {
            viewModel.searchResults.collectLatest { results ->
                Log.d("SearchFragment", "Zoekresultaten: ${results.size}")
            }
        }
    }

    override fun onDestroyView() {
        super.onDestroyView()
        binding = null
    }
}

Fragment gebruikt View Binding voor toegang tot View. De coroutine viewLifecycleOwner.lifecycleScope.launch wordt automatisch geannuleerd bij vernietiging van View. Binding wordt op nul gezet in onDestroyView om geheugenlekken te voorkomen. StateFlow garandeert actualiteit van gegevens bij het opnieuw maken van de View.