Fragment Lifecycle: alapok, onCreateView onViewCreated metódusok

Fragment Lifecycle: az életciklus alapjai

Fragment Lifecycle az egymással összefüggő állapotok és metódusok halmaza, amelyen minden Fragment-példány áthalad a létrehozástól a megsemmisülésig. Az Activity-től eltérően a Fragment életciklusa két kontextushoz kötődik: magához a Fragmenthez (onAttach-tól onDetach-ig él) és a View-jához (onCreateView-tól onDestroyView-ig él). Ez a szétválasztás a Fragment kulcsfontosságú jellemzője, amely lehetővé teszi a View megsemmisülésének túlélését képernyőelforgatáskor anélkül, hogy maga a Fragment megsemmisülne.

A Fragment callback-ek teljes sorozata:

• onAttach(Context) — A Fragment az Activity-hez kapcsolódik. Elsőként hívódik meg. Context — Activity-gazda.
• onCreate(Bundle) — A Fragment inicializálódik. Itt jön létre a ViewModel, konfigurálódnak az adapterek.
• onCreateView(LayoutInflater, ViewGroup, Bundle) — létrejön a Fragment View-hierarchiája. Visszaadja a gyökér View-t.
• onViewCreated(View, Bundle) — A View létrejött. Itt konfigurálódnak az UI-elemek, a LiveData feliratkozások.
• onStart() — A Fragment látható. Animációk indulnak, érzékelők regisztrálódnak.
• onResume() — A Fragment aktív, kapcsolatba lép a felhasználóval.
• onPause() — A Fragment elveszíti a fókuszt. Animációk leállnak.
• onStop() — A Fragment láthatatlan. Nem kritikus erőforrások szabadulnak fel.
• onDestroyView() — a View-hierarchia megsemmisül. A View-ra mutató referenciák nullázódnak.
• onDestroy() — A Fragment megsemmisül. A viewModelScope-on kívüli korutinok törlődnek.
• onDetach() — A Fragment leválik az Activity-ről. Végső tisztítás.

A Google szerint az átlagos fragmentum egy modern alkalmazásban 3–5 alkalommal megy át a teljes cikluson felhasználói munkamenetenként (a képernyőelforgatások és navigáció miatt). Az összes fázis helyes kezelése az UI stabilitásának alapja.

A Fragment állapotai: INITIALIZED-tól DESTROYED-ig

A FragmentManager öt fő állapoton keresztül kezeli a Fragmentet, amelyek a Fragment.State osztályban vannak meghatározva. Minden állapot a végrehajtott callback-ek egy meghatározott készletének felel meg.

A FragmentManager a Fragmentet a felhasználói műveletektől és rendszereseményektől függően mozgatja az állapotok között. Amikor egy Fragmentet hozzáadnak egy konténerhez, egymás után INITIALIZED → CREATED → STARTED → RESUMED állapotokon megy keresztül. Eltávolításkor — RESUMED → STARTED → CREATED → DESTROYED.

A CREATED állapot — különleges: a View megsemmisülhet (onDestroyView után), de maga a Fragment a CREATED állapotban marad (onDestroyView után, onDestroy előtt). Ez lehetővé teszi a FragmentManager számára, hogy a Fragmentet View nélkül tartsa a memóriában, ami szükséges a képernyőelforgatások túléléséhez.

A Fragment Lifecycle és Activity Lifecycle közötti különbség

A Fragment Lifecycle és az Activity Lifecycle szorosan kapcsolódnak, de alapvető különbségek vannak közöttük. A Fragment mindig egy Activity-n belül él, és életciklusa a gazda-Activity-től függ, de nem azonos azzal.

A fő gyakorlati különbség: képernyőelforgatáskor az Activity teljesen megsemmisül (onDestroy) és újra létrejön (onCreate). A Fragment forgatáskor az onDestroyView (View megsemmisül) → onCreateView (View újra létrejön) útvonalon halad, de maga a Fragment és ViewModel-je életben marad. Ez teszi a Fragmentet ideális tárolóvá az olyan UI-logika számára, amelynek túl kell élnie a konfigurációs változásokat.

Hívások sorrendje képernyőelforgatáskor: Activity.onPause → Fragment.onPause → Activity.onStop → Fragment.onStop → Activity.onDestroy → Fragment.onDestroyView → (Activity megsemmisült) → Activity.onCreate → Fragment.onAttach → Fragment.onCreate → Fragment.onCreateView → Fragment.onViewCreated → Activity.onStart → Fragment.onStart → Activity.onResume → Fragment.onResume.

FragmentManager: állapotok és tranzakciók kezelése

FragmentManager — a központi osztály, amely felelős a fragmentumok hozzáadásáért, eltávolításáért, cseréjéért és állapotuk kezeléséért. A FragmentManager a BackStack vermet kezeli és garantálja a callback-ek helyes sorrendjét a tranzakciókban. Minden Activity és minden beágyazott Fragment saját FragmentManager-rel rendelkezik.

A FragmentManager fő műveletei:

• beginTransaction() — tranzakciót nyit egy műveletcsoporthoz.
• add() — Fragmentet ad hozzá egy konténerhez. A Fragment teljes lifecycle-on megy keresztül a RESUMED-ig.
• replace() — lecseréli az aktuális Fragmentet egy újra. egyenlő a remove() + add().
• remove() — eltávolítja a Fragmentet. A Fragment a RESUMED-től a DESTROYED-ig terjedő lifecycle-on megy keresztül.
• hide()/show() — elrejti/megjeleníti a Fragmentet a View megsemmisítése nélkül. A Fragment hide-kor STARTED-be, show-kor vissza RESUMED-be kerül.
• detach()/attach() — leválasztja/visszacsatolja a Fragmentet. A detach megsemmisíti a View-t (onDestroyView), az attach újra létrehozza (onCreateView).
• addToBackStack() — tranzakciót ad a BackStackhez a „Vissza“ navigáció lehetővé tételéhez.

BackStack — a FragmentManager tranzakcióinak verme. A rendszer „Vissza“ gombjának megnyomásakor a BackStack utolsó tranzakciója visszavonásra kerül (popBackStack()). A popBackStack által eltávolított Fragment helyreáll. Ha a BackStack üres, a „Vissza“ gomb megnyomása befejezi az Activity-t.

A Google szerint a Fragment problémák 78%-a (duplikáció, üres képernyők, IllegalStateException) a FragmentManager helytelen használatához kapcsolódik. Fő szabály: a tranzakciókat a commit() (aszinkron) vagy commitNow() (szinkron) segítségével hajtsa végre a kontextustól függően. A commit() garantálja a helyes sorrendet többszörös tranzakciók esetén.

A Fragment állapotának mentése: onSaveInstanceState

A Fragment támogatja saját állapotmentési mechanizmusát az onSaveInstanceState segítségével, amely az Activity-től függetlenül működik. A Fragment az állapotot Bundle-ben menti, amely a visszaállításkor az onCreate és onCreateView metódusokba kerül továbbításra.

Mikor menti a Fragment az állapotot:

• Képernyőelforgatáskor — a View megsemmisül, a Fragment az állapotot Bundle-ben menti.
• A Fragment Activity-hez csatolásakor process death után.
• Az onSaveInstanceState Activity-ből történő meghívásakor (a rendszer kiterjeszti a mentést az összes gyermek fragmentumra).

Modern megközelítés: használja a SavedStateHandle-t a ViewModel-ben a Fragment állapotának mentéséhez. A SavedStateHandle automatikusan menti és visszaállítja az adatokat képernyőelforgatáskor és process death esetén, anélkül hogy kézi onSaveInstanceState-ra lenne szükség. A Google a SavedStateHandle-t ajánlja az UI állapotának mentésére a Fragment-ben.

setRetainInstance (elavult a Fragment 1.3 óta): korábban a Fragment megőrizhető volt a setRetainInstance(true) segítségével képernyőelforgatáskor. Ezt a megközelítést felváltotta a ViewModel + SavedStateHandle, amelyek megbízhatóbban működnek és nem igényelnek különleges konfigurációt.

viewLifecycleOwner: a View külön életciklusa

viewLifecycleOwner — a Fragment View-jához kapcsolódó Lifecycle (onCreateView-től onDestroyView-ig). Ez egy alapvetően fontos koncepció: a viewLifecycleOwner segítségével létrehozott LiveData/Flow feliratkozások automatikusan törlődnek a View megsemmisülésekor (onDestroyView), de nem érintik magát a Fragmentet.

Különbség a viewLifecycleOwner és a Fragment lifecycle között:

• lifecycle (Fragment) — onAttach-tól onDetach-ig él. A feliratkozások a View megsemmisülése után is aktívak maradnak.
• viewLifecycleOwner — onCreateView-től onDestroyView-ig él. A feliratkozások a View megsemmisülésekor törlődnek.

Miért fontos ez: ha a LiveData-ra a Fragment lifecycle (this) segítségével fizet fel, az onDestroyView után a feliratkozás aktív marad, és a LiveData megpróbálja frissíteni a null View-t, NPE-t okozva. A viewLifecycleOwner segítségével történő feliratkozás garantálja, hogy onDestroyView után nem történik UI-frissítés.

Szabály: Fragment-ben mindig a viewLifecycleOwner-t használja az UI-hoz kapcsolódó LiveData, Flow és korutin feliratkozásokhoz. A ViewModel korutinjaihoz a viewModelScope-ot használja — ez a ViewModel-hez kapcsolódik, nem a Fragmenthez.

Fragment kódpéldák Kotlinban

1. példa: Alap Fragment onViewCreated és viewLifecycleOwner segítségével

Bemutatja az UI helyes inicializálását és a LiveData feliratkozást a viewLifecycleOwner segítségével.

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", "Lista frissítése: ${users.size} felhasználó")
        }
    }

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

A Fragment az onCreateView-ben felfújja a layout-ot, konfigurálja az UI-t és feliratkozik a LiveData-ra az onViewCreated-ben. A viewLifecycleOwner segítségével történő feliratkozás — kötelező követelmény a memóriaszivárgás megelőzéséhez. Az onDestroyView naplózza a View megsemmisülését — megerősítés, hogy a Fragment túléli a képernyőelforgatást.

2. példa: Fragment FragmentManager és tranzakciók segítségével

Bemutatja a Fragment hozzáadását a FragmentManager segítségével az Activity-ben, a BackStack-es cserét és a visszaállítást.

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", "Felhasználói adatok betöltése: $userId")
    }
}

Az Activity a supportFragmentManager-t használja a fragmentumok kezeléséhez. Az add() tranzakció BackStack-el garantálja, hogy a „Vissza“ gomb megnyomásakor a HomeFragment helyreáll. Az openDetail() lecseréli az aktuális Fragmentet DetailFragment-re argumentumokkal. A savedInstanceState == null ellenőrzés megakadályozza a fragmentumok duplikálódását képernyőelforgatáskor.

3. példa: Fragment LifecycleObserver és StateFlow segítségével

A Flow és StateFlow használata Fragment-ben viewLifecycleOwner segítségével az UI reaktív frissítéséhez.

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", "Keresési eredmények: ${results.size}")
            }
        }
    }

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

A Fragment View Binding-et használ a View eléréséhez. A viewLifecycleOwner.lifecycleScope.launch korutin automatikusan törlődik a View megsemmisülésekor. A Binding nullázódik az onDestroyView-ben a memóriaszivárgás megelőzése érdekében. A StateFlow garantálja az adatok időszerűségét a View újralétrehozásakor.