Fragment Lifecycle: grunder, metoder onCreateView onViewCreated

Fragment Lifecycle: livscykelns grunder

Fragment Lifecycle är en uppsättning sammanlänkade tillstånd och metoder som varje Fragment-instans går igenom från skapande till förstörelse. Till skillnad från Activity är Fragmentets livscykel bunden till två sammanhang: själva Fragmentet (lever från onAttach till onDetach) och dess View (lever från onCreateView till onDestroyView). Denna separation är en nyckelfunktion hos Fragment, som gör att det kan överleva förstörelse av View vid skärmrotation utan att förstöra själva Fragmentet.

Fullständig sekvens av Fragmentets callbacks:

• onAttach(Context) — Fragmentet kopplas till Activity. Anropas först. Context — Activity-värd.
• onCreate(Bundle) — Fragmentet initieras. Här skapas ViewModel, adaptrar konfigureras.
• onCreateView(LayoutInflater, ViewGroup, Bundle) — Fragmentets View-hierarki skapas. Returnerar rot-View.
• onViewCreated(View, Bundle) — View har skapats. Här konfigureras UI-element, LiveData-prenumerationer.
• onStart() — Fragmentet är synligt. Animationer startas, sensorer registreras.
• onResume() — Fragmentet är aktivt, interagerar med användaren.
• onPause() — Fragmentet förlorar fokus. Animationer stoppas.
• onStop() — Fragmentet är osynligt. Icke-kritiska resurser frigörs.
• onDestroyView() — View-hierarkin förstörs. Referenser till View nollställs.
• onDestroy() — Fragmentet förstörs. Korutiner som inte är i viewModelScope avbryts.
• onDetach() — Fragmentet kopplas loss från Activity. Slutlig rensning.

Enligt Google går det genomsnittliga fragmentet i en modern applikation igenom en fullständig cykel 3–5 gånger per användarsession (på grund av skärmrotationer och navigering). Korrekt hantering av alla faser är grunden för UI-stabilitet.

Fragmentets tillstånd: från INITIALIZED till DESTROYED

FragmentManager hanterar Fragmentet genom fem huvudtillstånd, definierade i klassen Fragment.State. Varje tillstånd motsvarar en specifik uppsättning callbacks som har utförts.

FragmentManager flyttar Fragmentet mellan tillstånd beroende på användaråtgärder och systemhändelser. När Fragmentet läggs till i en behållare går det sekventiellt igenom INITIALIZED → CREATED → STARTED → RESUMED. Vid borttagning — RESUMED → STARTED → CREATED → DESTROYED.

Tillstånd CREATED — speciellt: View kan förstöras (efter onDestroyView), men själva Fragmentet förblir i tillståndet CREATED (efter onDestroyView, före onDestroy). Detta gör att FragmentManager kan behålla Fragmentet i minnet utan View, vilket är nödvändigt för att överleva skärmrotationer.

Skillnad mellan Fragment Lifecycle och Activity Lifecycle

Fragment Lifecycle och Activity Lifecycle är nära kopplade men har fundamentala skillnader. Fragment lever alltid inuti ett Activity, och dess livscykel beror på värd-Activity, men är inte identisk med den.

Främsta praktiska skillnad: vid skärmrotation förstörs Activity helt (onDestroy) och återskapas (onCreate). Fragmentet går vid rotation igenom onDestroyView (View förstörs) → onCreateView (View återskapas), men själva Fragmentet och dess ViewModel förblir levande. Detta gör Fragmentet till en idealisk behållare för UI-logik som måste överleva konfigurationsändringar.

Anropsordning vid skärmrotation: Activity.onPause → Fragment.onPause → Activity.onStop → Fragment.onStop → Activity.onDestroy → Fragment.onDestroyView → (Activity förstört) → Activity.onCreate → Fragment.onAttach → Fragment.onCreate → Fragment.onCreateView → Fragment.onViewCreated → Activity.onStart → Fragment.onStart → Activity.onResume → Fragment.onResume.

FragmentManager: hantering av tillstånd och transaktioner

FragmentManager — den centrala klassen som ansvarar för att lägga till, ta bort, ersätta fragment och hantera deras tillstånd. FragmentManager underhåller BackStack-stacken och garanterar korrekt ordning på callbacks vid transaktioner. Varje Activity och varje nästlat Fragment har sin egen FragmentManager.

Huvudoperationer för FragmentManager:

• beginTransaction() — öppnar en transaktion för en grupp operationer.
• add() — lägger till Fragment i en behållare. Fragmentet går igenom full lifecycle till RESUMED.
• replace() — ersätter nuvarande Fragment med ett nytt. är lika med remove() + add().
• remove() — tar bort Fragment. Fragmentet går igenom lifecycle från RESUMED till DESTROYED.
• hide()/show() — döljer/visar Fragment utan att förstöra View. Fragmentet går till STARTED vid hide, tillbaka till RESUMED vid show.
• detach()/attach() — kopplar loss/kopplar Fragment. detach förstör View (onDestroyView), attach återskapar (onCreateView).
• addToBackStack() — lägger till transaktion i BackStack för möjlighet till ”Tillbaka”-navigering.

BackStack — stacken för FragmentManager-transaktioner. När systemknappen ”Tillbaka” trycks in, återställs den senaste transaktionen i BackStack (popBackStack()). Fragment som tagits bort via popBackStack återställs. Om BackStack är tom avslutar tryckning av ”Tillbaka” Activity.

Enligt Google är 78% av problemen med Fragment (duplicering, tomma skärmar, IllegalStateException) relaterade till felaktig användning av FragmentManager. Huvudregel: utför transaktioner via commit() (asynkront) eller commitNow() (synkront) beroende på sammanhang. commit() garanterar korrekt ordning vid flera transaktioner.

Spara Fragmentets tillstånd: onSaveInstanceState

Fragment stöder sin egen mekanism för att spara tillstånd via onSaveInstanceState, som fungerar oberoende av Activity. Fragmentet sparar tillstånd i Bundle, som skickas till onCreate och onCreateView vid återställning.

När Fragmentet sparar tillstånd:

• Vid skärmrotation — View förstörs, Fragmentet sparar tillstånd i Bundle.
• Vid koppling av Fragment till Activity efter process death.
• Vid anrop av onSaveInstanceState från Activity (systemet sprider sparandet till alla underordnade fragment).

Modern metod: använd SavedStateHandle i ViewModel för att spara Fragmentets tillstånd. SavedStateHandle sparar och återställer automatiskt data vid skärmrotation och process death, utan att kräva manuell onSaveInstanceState. Google rekommenderar SavedStateHandle som föredragen metod för att spara UI-tillstånd i Fragment.

setRetainInstance (föråldrad från Fragment 1.3): tidigare kunde Fragmentet bevaras via setRetainInstance(true) vid skärmrotation. Denna metod har ersatts av ViewModel + SavedStateHandle, som fungerar mer tillförlitligt och inte kräver speciell konfiguration.

viewLifecycleOwner: separat livscykel för View

viewLifecycleOwner — Lifecycle kopplad till Fragmentets View (från onCreateView till onDestroyView). Detta är ett grundläggande viktigt koncept: LiveData/Flow-prenumerationer gjorda via viewLifecycleOwner avbryts automatiskt vid förstörelse av View (onDestroyView), men påverkar inte själva Fragmentet.

Skillnad mellan viewLifecycleOwner och Fragmentets lifecycle:

• lifecycle (Fragment) — lever från onAttach till onDetach. Prenumerationer förblir aktiva även efter förstörelse av View.
• viewLifecycleOwner — lever från onCreateView till onDestroyView. Prenumerationer avbryts vid förstörelse av View.

Varför detta är viktigt: om du prenumererar på LiveData via Fragmentets lifecycle (this), efter onDestroyView förblir prenumerationen aktiv och LiveData kommer att försöka uppdatera null View, vilket orsakar NPE. Prenumeration via viewLifecycleOwner garanterar att inga UI-uppdateringar sker efter onDestroyView.

Regel: i Fragment, använd alltid viewLifecycleOwner för prenumerationer på LiveData, Flow och korutiner relaterade till UI. För ViewModel-korutiner, använd viewModelScope — den är bunden till ViewModel, inte till Fragment.

Kodexempel för Fragment i Kotlin

Exempel 1: Grundläggande Fragment med onViewCreated och viewLifecycleOwner

Visar korrekt initiering av UI och LiveData-prenumeration 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", "Uppdatera lista: ${users.size} användare")
        }
    }

    override fun onDestroyView() {
        super.onDestroyView()
        Log.d("UserListFragment", "onDestroyView: View förstörd")
    }
}

Fragmentet blåser upp layout i onCreateView, konfigurerar UI och prenumererar på LiveData i onViewCreated. Prenumeration via viewLifecycleOwner — ett obligatoriskt krav för att förhindra minnesläckor. onDestroyView loggar förstörelse av View — bekräftelse att Fragmentet överlever skärmrotation.

Exempel 2: Fragment med FragmentManager och transaktioner

Visar tillägg av Fragment via FragmentManager i Activity, ersättning med BackStack och återställning.

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", "Ladda användarinformation: $userId")
    }
}

Activity använder supportFragmentManager för att hantera fragment. Transaktionen add() med BackStack garanterar att HomeFragment återställs när ”Tillbaka” trycks. openDetail() ersätter nuvarande Fragment med DetailFragment med argument. Kontroll av savedInstanceState == null förhindrar duplicering av fragment vid skärmrotation.

Exempel 3: Fragment med LifecycleObserver och StateFlow

Användning av Flow och StateFlow i Fragment med viewLifecycleOwner för reaktiv UI-uppdatering.

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", "Sökresultat: ${results.size}")
            }
        }
    }

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

Fragmentet använder View Binding för åtkomst till View. Korutinen viewLifecycleOwner.lifecycleScope.launch avbryts automatiskt vid förstörelse av View. Binding nollställs i onDestroyView för att förhindra minnesläckor. StateFlow garanterar att data är aktuell när View återskapas.