Fragment Lifecycle: मूल बातें, onCreateView और onViewCreated विधियाँ

Fragment Lifecycle: जीवनचक्र की मूल बातें

Fragment Lifecycle परस्पर जुड़ी अवस्थाओं और विधियों का एक समूह है जिससे प्रत्येक Fragment इंस्टेंस निर्माण से विनाश तक गुज़रता है। Activity के विपरीत, Fragment का जीवनचक्र दो संदर्भों से जुड़ा होता है: स्वयं Fragment (onAttach से onDetach तक जीवित रहता है) और इसका View (onCreateView से onDestroyView तक जीवित रहता है)। यह पृथक्करण Fragment की एक प्रमुख विशेषता है, जो इसे Fragment को नष्ट किए बिना स्क्रीन घुमाने पर View के विनाश से बचने की अनुमति देता है।

Fragment कॉलबैक का पूरा अनुक्रम:

• onAttach(Context) — Fragment Activity से जुड़ता है। सबसे पहले कॉल किया जाता है। Context मेज़बान Activity है।
• onCreate(Bundle) — Fragment प्रारंभ किया जाता है। यहाँ ViewModel बनाया जाता है, एडेप्टर कॉन्फ़िगर किए जाते हैं।
• onCreateView(LayoutInflater, ViewGroup, Bundle) — Fragment View पदानुक्रम बनाया जाता है। मूल View लौटाता है।
• onViewCreated(View, Bundle) — View बन चुका है। यहाँ UI तत्व कॉन्फ़िगर किए जाते हैं, LiveData सब्सक्रिप्शन सेट किए जाते हैं।
• onStart() — Fragment दृश्यमान होता है। एनिमेशन शुरू होते हैं, सेंसर पंजीकृत होते हैं।
• onResume() — Fragment सक्रिय है, उपयोगकर्ता के साथ इंटरैक्ट करता है।
• onPause() — Fragment फ़ोकस खो देता है। एनिमेशन रुक जाते हैं।
• onStop() — Fragment दृश्यमान नहीं है। गैर-महत्वपूर्ण संसाधन मुक्त किए जाते हैं।
• onDestroyView() — View पदानुक्रम नष्ट हो जाता है। View संदर्भ शून्य किए जाते हैं।
• onDestroy() — Fragment नष्ट हो जाता है। viewModelScope में नहीं होने वाले कोरूटीन रद्द किए जाते हैं।
• onDetach() — Fragment Activity से अलग हो जाता है। अंतिम सफाई।

Google के अनुसार, एक आधुनिक अनुप्रयोग में औसत फ़्रैगमेंट प्रति उपयोगकर्ता सत्र 3–5 बार पूर्ण चक्र से गुज़रता है (स्क्रीन घुमाव और नेविगेशन के कारण)। सभी चरणों का सही संचालन UI स्थिरता का आधार है।

Fragment की अवस्थाएँ: INITIALIZED से DESTROYED तक

FragmentManager Fragment को पाँच मुख्य अवस्थाओं के माध्यम से प्रबंधित करता है, जो Fragment.State वर्ग में परिभाषित हैं। प्रत्येक अवस्था कॉलबैक के एक विशिष्ट सेट से मेल खाती है जिन्हें निष्पादित किया गया है।

FragmentManager उपयोगकर्ता क्रियाओं और सिस्टम घटनाओं के आधार पर Fragment को अवस्थाओं के बीच ले जाता है। कंटेनर में Fragment जोड़ने पर, यह क्रमिक रूप से INITIALIZED → CREATED → STARTED → RESUMED से गुज़रता है। हटाने पर — RESUMED → STARTED → CREATED → DESTROYED।

CREATED अवस्था विशेष है: View नष्ट हो सकता है (onDestroyView के बाद), लेकिन Fragment स्वयं CREATED अवस्था में रहता है (onDestroyView के बाद, onDestroy से पहले)। यह FragmentManager को Fragment को बिना View के मेमोरी में रखने की अनुमति देता है, जो स्क्रीन घुमाव से बचने के लिए आवश्यक है।

Fragment Lifecycle और Activity Lifecycle में अंतर

Fragment Lifecycle और Activity Lifecycle निकटता से संबंधित हैं लेकिन इनमें मूलभूत अंतर हैं। Fragment हमेशा Activity के अंदर रहता है, और इसका जीवनचक्र मेज़बान Activity पर निर्भर करता है, लेकिन इसके समान नहीं है।

मुख्य व्यावहारिक अंतर: स्क्रीन घुमाने पर, Activity पूरी तरह नष्ट (onDestroy) और पुनः निर्मित (onCreate) होती है। Fragment घुमाव के दौरान onDestroyView (View नष्ट) → onCreateView (View पुनः निर्मित) से गुज़रता है, लेकिन Fragment स्वयं और उसका ViewModel जीवित रहते हैं। यह Fragment को UI लॉजिक के लिए एक आदर्श कंटेनर बनाता है जिसे कॉन्फ़िगरेशन परिवर्तनों से बचना चाहिए।

स्क्रीन घुमाव के दौरान कॉल क्रम: Activity.onPause → Fragment.onPause → Activity.onStop → Fragment.onStop → Activity.onDestroy → Fragment.onDestroyView → (Activity नष्ट) → Activity.onCreate → Fragment.onAttach → Fragment.onCreate → Fragment.onCreateView → Fragment.onViewCreated → Activity.onStart → Fragment.onStart → Activity.onResume → Fragment.onResume।

FragmentManager: अवस्था प्रबंधन और लेनदेन

FragmentManager केंद्रीय वर्ग है जो fragments को जोड़ने, हटाने, बदलने और उनकी अवस्थाओं का प्रबंधन करने के लिए ज़िम्मेदार है। FragmentManager BackStack बनाए रखता है और लेनदेन के दौरान कॉलबैक का सही क्रम सुनिश्चित करता है। प्रत्येक Activity और प्रत्येक नेस्टेड Fragment का अपना FragmentManager होता है।

FragmentManager के मुख्य संचालन:

• beginTransaction() — संचालन के समूह के लिए लेनदेन खोलता है।
• add() — कंटेनर में Fragment जोड़ता है। Fragment RESUMED तक पूर्ण जीवनचक्र से गुज़रता है।
• replace() — वर्तमान Fragment को नए से बदलता है। remove() + add() के बराबर।
• remove() — Fragment हटाता है। Fragment RESUMED से DESTROYED तक जीवनचक्र से गुज़रता है।
• hide()/show() — View को नष्ट किए बिना Fragment छिपाता/दिखाता है। छिपाने पर Fragment STARTED में जाता है, दिखाने पर RESUMED में वापस आता है।
• detach()/attach() — Fragment को अलग/पुनः जोड़ता है। detach View नष्ट करता है (onDestroyView), attach पुनः बनाता है (onCreateView)।
• addToBackStack() — पीछे नेविगेशन के लिए लेनदेन को BackStack में जोड़ता है।

BackStack FragmentManager का लेनदेन स्टैक है। सिस्टम Back बटन दबाने पर, BackStack में अंतिम लेनदेन वापस रोल किया जाता है (popBackStack())। popBackStack के माध्यम से हटाया गया Fragment पुनर्स्थापित होता है। यदि BackStack खाली है, तो Back दबाने से Activity समाप्त हो जाती है।

Google के अनुसार, 78% Fragment समस्याएँ (डुप्लिकेशन, खाली स्क्रीन, IllegalStateException) FragmentManager के गलत उपयोग से संबंधित हैं। मुख्य नियम: संदर्भ के अनुसार commit() (एसिंक्रोनस) या commitNow() (सिंक्रोनस) के माध्यम से लेनदेन निष्पादित करें। commit() एकाधिक लेनदेन के तहत सही क्रम सुनिश्चित करता है।

Fragment स्थिति सहेजना: onSaveInstanceState

Fragment onSaveInstanceState के माध्यम से अपनी स्वयं की स्थिति सहेजने की सुविधा का समर्थन करता है, जो Activity से स्वतंत्र रूप से काम करता है। Fragment स्थिति को Bundle में सहेजता है जो पुनर्स्थापना के दौरान onCreate और onCreateView को भेजा जाता है।

Fragment कब स्थिति सहेजता है:

• स्क्रीन घुमाने पर — View नष्ट होता है, Fragment Bundle में स्थिति सहेजता है।
• प्रक्रिया मृत्यु के बाद Fragment को Activity से पुनः जोड़ने पर।
• Activity से onSaveInstanceState कॉल करने पर (सिस्टम सहेजना सभी चाइल्ड fragments में प्रसारित करता है)।

आधुनिक दृष्टिकोण: Fragment स्थिति सहेजने के लिए ViewModel में SavedStateHandle का उपयोग करें। SavedStateHandle स्वचालित रूप से स्क्रीन घुमाव और प्रक्रिया मृत्यु पर डेटा सहेजता और पुनर्स्थापित करता है, बिना मैन्युअल onSaveInstanceState की आवश्यकता के। Google Fragment में UI स्थिति सहेजने के लिए SavedStateHandle को पसंदीदा तरीके के रूप में सुझाता है।

setRetainInstance (Fragment 1.3 से अप्रचलित): पहले Fragment स्क्रीन घुमाव पर setRetainInstance(true) के माध्यम से संरक्षित रह सकता था। इस दृष्टिकोण को ViewModel + SavedStateHandle द्वारा बदल दिया गया है, जो अधिक विश्वसनीय रूप से काम करते हैं और किसी विशेष कॉन्फ़िगरेशन की आवश्यकता नहीं होती है।

viewLifecycleOwner: View का अलग जीवनचक्र

viewLifecycleOwner Fragment View से जुड़ा Lifecycle है (onCreateView से onDestroyView तक)। यह एक मौलिक रूप से महत्वपूर्ण अवधारणा है: viewLifecycleOwner के माध्यम से LiveData/Flow पर की गई सब्सक्रिप्शन View नष्ट होने (onDestroyView) पर स्वचालित रूप से रद्द हो जाती हैं, लेकिन स्वयं Fragment को प्रभावित नहीं करती हैं।

viewLifecycleOwner और Fragment lifecycle के बीच अंतर:

• lifecycle (Fragment) — onAttach से onDetach तक जीवित रहता है। View नष्ट होने के बाद भी सब्सक्रिप्शन सक्रिय रहती हैं।
• viewLifecycleOwner — onCreateView से onDestroyView तक जीवित रहता है। View नष्ट होने पर सब्सक्रिप्शन रद्द हो जाती हैं।

यह क्यों महत्वपूर्ण है: यदि आप Fragment lifecycle (this) के माध्यम से LiveData पर सब्सक्राइब करते हैं, तो onDestroyView के बाद सब्सक्रिप्शन सक्रिय रहती है और LiveData शून्य View को अपडेट करने का प्रयास करेगा, जिससे NPE होगा। viewLifecycleOwner के माध्यम से सब्सक्राइब करना गारंटी देता है कि onDestroyView के बाद कोई UI अपडेट नहीं होगा।

नियम: Fragment में, LiveData, Flow और UI-संबंधित कोरूटीन की सब्सक्रिप्शन के लिए हमेशा viewLifecycleOwner का उपयोग करें। ViewModel कोरूटीन के लिए viewModelScope का उपयोग करें — यह Fragment के बजाय ViewModel से बंधा है।

Kotlin में Fragment कोड उदाहरण

उदाहरण 1: onViewCreated और viewLifecycleOwner के साथ बुनियादी Fragment

सही UI आरंभीकरण और viewLifecycleOwner के माध्यम से LiveData सब्सक्रिप्शन दर्शाता है।

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", "सूची अपडेट हो रही है: ${users.size} उपयोगकर्ता")
        }
    }

    override fun onDestroyView() {
        super.onDestroyView()
        Log.d("UserListFragment", "onDestroyView: View नष्ट हो गया")
    }
}

Fragment onCreateView में लेआउट इन्फ्लेट करता है, UI कॉन्फ़िगर करता है और onViewCreated में LiveData पर सब्सक्राइब करता है। viewLifecycleOwner के माध्यम से सब्सक्रिप्शन लीक को रोकने के लिए एक अनिवार्य आवश्यकता है। onDestroyView View विनाश को लॉग करता है — पुष्टि कि Fragment स्क्रीन घुमाव से बचता है।

उदाहरण 2: FragmentManager और लेनदेन के साथ Fragment

Activity में FragmentManager के माध्यम से Fragment जोड़ना, BackStack के साथ बदलना और पुनर्स्थापना दर्शाता है।

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", "उपयोगकर्ता विवरण लोड हो रहे हैं: $userId")
    }
}

Activity fragments प्रबंधित करने के लिए supportFragmentManager का उपयोग करती है। BackStack के साथ add() लेनदेन सुनिश्चित करता है कि Back दबाने पर HomeFragment पुनर्स्थापित हो। openDetail() वर्तमान Fragment को DetailFragment से तर्कों के साथ बदलता है। savedInstanceState == null की जाँच स्क्रीन घुमाव पर फ़्रैगमेंट डुप्लिकेशन को रोकती है।

उदाहरण 3: LifecycleObserver और StateFlow के साथ Fragment

रिएक्टिव UI अपडेट के लिए viewLifecycleOwner के साथ Fragment में Flow और StateFlow का उपयोग।

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", "खोज परिणाम: ${results.size}")
            }
        }
    }

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

Fragment View तक पहुँचने के लिए View Binding का उपयोग करता है। viewLifecycleOwner.lifecycleScope.launch कोरूटीन View नष्ट होने पर स्वचालित रूप से रद्द हो जाती है। लीक रोकने के लिए onDestroyView में binding शून्य किया जाता है। StateFlow View पुनः निर्मित होने पर डेटा की ताज़गी सुनिश्चित करता है।