Activity Lifecycle: यह क्या है, Android में onCreate onStart onResume

Activity Lifecycle क्या है

Activity Lifecycle (Activity का जीवनचक्र) एक अवस्था मशीन है जिससे Android एप्लिकेशन की प्रत्येक स्क्रीन निर्माण के क्षण से पूर्ण विनाश तक गुज़रती है। Android सिस्टम उपयोगकर्ता की क्रियाओं के आधार पर इस प्रक्रिया को प्रबंधित करता है: एप्लिकेशन खोलना, छोटा करना, स्क्रीन घुमाना, आने वाली कॉल का जवाब देना, एप्लिकेशन के बीच स्विच करना और कार्य समाप्त करना।

जीवनचक्र को समझना प्रत्येक Android डेवलपर के लिए आवश्यक है, क्योंकि सिस्टम मेमोरी कम होने पर किसी भी क्षण Activity को नष्ट कर सकता है — और एप्लिकेशन को अपनी स्थिति सही ढंग से पुनर्स्थापित करनी होती है। Google Android Vitals (2025) के अनुसार, जो एप्लिकेशन onSaveInstanceState() में स्थिति सहेजने को संभालते नहीं हैं, वे Activity पुनर्निर्माण पर 42% अधिक क्रैश दिखाते हैं।

जीवनचक्र में छह मुख्य कॉलबैक विधियाँ शामिल हैं: onCreate(), onStart(), onResume(), onPause(), onStop(), onDestroy()। इसके अतिरिक्त onRestart() विधि है, जो onStart() से पहले कॉल की जाती है जब Activity रुकी स्थिति से वापस आती है। प्रत्येक विधि का सख्ती से परिभाषित उद्देश्य और निष्पादन समय होता है — सिस्टम उन्हें क्रमिक रूप से कॉल करता है, और डेवलपर अपने तर्क को लागू करने के लिए किसी भी विधि को ओवरराइड कर सकता है।

चक्र को तीन प्रमुख चरणों में विभाजित किया जा सकता है: पूर्ण जीवनकाल (onCreate → onDestroy), दृश्य जीवनकाल (onStart → onStop) और अग्रभूमि जीवनकाल (onResume → onPause)। इन तीन स्तरों को समझने से प्रारंभीकरण और संसाधन मुक्ति कोड को सही ढंग से वितरित करने में मदद मिलती है।

Activity जीवनचक्र की विधियाँ

जीवनचक्र की प्रत्येक विधि एक सख्ती से परिभाषित कार्य करती है। सिस्टम उन्हें एक निश्चित क्रम में कॉल करता है, और डेवलपर को केवल विशिष्ट तर्क के लिए आवश्यक विधियों को ओवरराइड करना चाहिए। जीवनचक्र विधियों को सीधे कॉल करने की अनुशंसा नहीं की जाती — यह Android Runtime द्वारा संभाला जाता है।

सामान्य कॉल अनुक्रम

एप्लिकेशन लॉन्च करते समय विशिष्ट अनुक्रम: onCreate → onStart → onResume। बैक बटन दबाने पर: onPause → onStop → onDestroy। छोटा करने पर: onPause → onStop, फिर वापसी पर: onRestart → onStart → onResume।

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }

    override fun onStart() {
        super.onStart()
    }

    override fun onResume() {
        super.onResume()
    }

    override fun onPause() {
        super.onPause()
    }

    override fun onStop() {
        super.onStop()
    }

    override fun onDestroy() {
        super.onDestroy()
    }

    override fun onRestart() {
        super.onRestart()
    }
}

प्रत्येक ओवरराइड की गई विधि अपने super संस्करण को कॉल करना अनिवार्य है — इसके बिना, सिस्टम स्थिति संक्रमण को सही ढंग से पूरा नहीं कर सकता। यह नियम Android Developers दस्तावेज़ीकरण में स्थापित है और Android Studio के lint नियमों द्वारा जाँचा जाता है।

जीवनचक्र के तीन स्तर

पहला स्तर — पूर्ण जीवनकाल: onCreate और onDestroy के बीच का अंतराल। यहाँ एकमुश्त प्रारंभीकरण और वैश्विक संसाधनों की अंतिम मुक्ति की जाती है। दूसरा स्तर — दृश्य जीवनकाल: onStart और onStop के बीच। Activity स्क्रीन पर दिखाई देती है लेकिन किसी अन्य विंडो से आंशिक रूप से ढकी हो सकती है। तीसरा स्तर — अग्रभूमि जीवनकाल: onResume और onPause के बीच। Activity कार्य स्टैक के शीर्ष पर है और उपयोगकर्ता के साथ इंटरैक्ट करती है।

onCreate — Activity का निर्माण

onCreate() — Activity जीवनचक्र की पहली और एकमात्र अनिवार्य विधि। इसे सिस्टम द्वारा Activity इंस्टेंस बनाते समय एक बार कॉल किया जाता है। यह विधि savedInstanceState: Bundle? पैरामीटर स्वीकार करती है, जिसमें पहले से सहेजी गई स्थिति होती है यदि Activity विनाश के बाद पुनर्निर्मित की जा रही है — उदाहरण के लिए, स्क्रीन रोटेशन के दौरान।

onCreate के अंदर निम्नलिखित कार्य किए जाते हैं: setContentView() के माध्यम से लेआउट संसाधन के साथ उपयोगकर्ता इंटरफ़ेस प्रारंभीकरण, findViewById() के माध्यम से View तत्वों का बंधन, RecyclerView और ViewPager के लिए एडेप्टर सेटअप, savedInstanceState से स्थिति पुनर्स्थापना, ViewModel और LiveData प्रारंभीकरण, क्लिक और जेस्चर श्रोताओं का सेटअप। विधि जितनी जल्दी हो सके पूरी होनी चाहिए — यहाँ लंबी संक्रियाएँ पहले फ्रेम के रेंडरिंग को अवरुद्ध करती हैं, जिससे एप्लिकेशन प्रारंभ समय बढ़ जाता है।

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_profile)

    val userNameText: TextView = findViewById(R.id.user_name)
    val loadButton: Button = findViewById(R.id.load_button)

    if (savedInstanceState != null) {
        userNameText.text = savedInstanceState.getString("user_name")
    }

    loadButton.setOnClickListener {
        loadUserProfile()
    }
}

यदि Activity पहली बार बनाई जा रही है, तो savedInstanceState null है। स्क्रीन रोटेशन के बाद पुनर्निर्माण पर, Bundle में onSaveInstanceState() में सहेजा गया डेटा होता है। null जाँच उपयोगकर्ता द्वारा दर्ज डेटा को खोए बिना UI को सही ढंग से पुनर्स्थापित करने के लिए मानक अभ्यास है।

onStart — स्क्रीन पर प्रकट होना

onStart() onCreate() के तुरंत बाद या onRestart() के बाद कॉल किया जाता है, जब Activity उपयोगकर्ता को दिखाई देने लगती है। इस अवस्था में, Activity अभी अग्रभूमि में नहीं है और उपयोगकर्ता के साथ इंटरैक्ट नहीं कर सकती, लेकिन इसका उपयोगकर्ता इंटरफ़ेस पहले से ही स्क्रीन पर दिखाई देता है। उदाहरण के लिए, एप्लिकेशन लॉन्च करते समय, सिस्टम onStart और onResume कॉल के बीच इंटरफ़ेस का पहला फ्रेम रेंडर करता है।

onStart विधि में आमतौर पर निम्नलिखित क्रियाएँ की जाती हैं: एनिमेशन शुरू करना जो Activity के दिखाई रहने तक चलने चाहिए; ब्रॉडकास्ट रिसीवर (BroadcastReceiver) बांधना; भू-स्थान सेवाओं और सेंसर से कनेक्ट होना; ViewModel या Room से डेटा अपडेट करना। यहाँ bindService() के माध्यम से Bound सेवाओं से बंधन भी किया जाता है यदि एप्लिकेशन प्रक्रिया के भीतर क्लाइंट-सर्वर आर्किटेक्चर का उपयोग करता है।

override fun onStart() {
    super.onStart()
    val locationManager = getSystemService(Context.LOCATION_SERVICE) as LocationManager
    locationManager.requestLocationUpdates(
        LocationManager.GPS_PROVIDER,
        5000L,
        10f,
        locationListener
    )
}

override fun onStop() {
    super.onStop()
    val locationManager = getSystemService(Context.LOCATION_SERVICE) as LocationManager
    locationManager.removeUpdates(locationListener)
}

महत्वपूर्ण नियम: onStart में जुड़े संसाधनों को onStop में मुक्त किया जाना चाहिए। यह सुनिश्चित करता है कि जब Activity स्क्रीन पर दिखाई नहीं देती, तो वह बैटरी और सिस्टम संसाधनों का उपभोग नहीं करती। Google Play Store अपडेट की समीक्षा करते समय LocationListener और अन्य सिस्टम सेवाओं के लीक के लिए एप्लिकेशन की जाँच करता है।

onResume — फोकस प्राप्त करना

onResume() — वह अवस्था जिसमें Activity अग्रभूमि में है और उपयोगकर्ता के साथ इंटरैक्ट करने के लिए तैयार है। यह स्क्रीन की कार्यशील स्थिति है: सिस्टम Activity को इनपुट फोकस स्थानांतरित करता है, और सभी स्पर्श घटनाएँ, कीबोर्ड इनपुट और जेस्चर इस स्क्रीन पर निर्देशित होते हैं। onResume विधि हर बार कॉल की जाती है जब Activity अग्रभूमि में लौटती है — किसी अन्य Activity के समाप्त होने के बाद, डायलॉग बॉक्स बंद होने के बाद, या डिवाइस अनलॉक होने के बाद।

onResume में निम्नलिखित किए जाते हैं: onPause में रोके गए एनिमेशन को पुनः शुरू करना; कैमरा और अन्य अनन्य संसाधन खोलना; सेंसर श्रोताओं (एक्सेलेरोमीटर, जायरोस्कोप) का पंजीकरण; UI के लिए टाइमर और स्टॉपवॉच शुरू करना; वर्तमान डेटा के साथ स्क्रीन सामग्री अपडेट करना। onResume/onPause युग्म का उपयोग उन संसाधनों के लिए किया जाता है जो केवल फोकस होने पर सक्रिय होने चाहिए — उदाहरण के लिए, निरंतर वाक् पहचान या वीडियो कैप्चर।

override fun onResume() {
    super.onResume()
    cameraHolder.openCamera()
    animator.resume()
    sensorManager.registerListener(
        stepCounter,
        sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER),
        SensorManager.SENSOR_DELAY_NORMAL
    )
}

override fun onPause() {
    super.onPause()
    cameraHolder.closeCamera()
    animator.pause()
    sensorManager.unregisterListener(stepCounter)
}

onStart और onResume के बीच अंतर महत्वपूर्ण है: एक Activity दिखाई (onStart) हो सकती है लेकिन सक्रिय (onResume) नहीं — उदाहरण के लिए, जब उसके ऊपर एक पॉपअप डायलॉग या पारदर्शी लॉक स्क्रीन प्रदर्शित होती है। अनन्य संसाधन जिन्हें अनन्य पहुँच की आवश्यकता है, उन्हें onResume में खोला जाना चाहिए, onStart में नहीं।

onPause — फोकस खोना

onPause() तब कॉल किया जाता है जब Activity इनपुट फोकस खो देती है लेकिन आंशिक रूप से दिखाई देती रहती है। विशिष्ट परिदृश्य: डायलॉग बॉक्स खोलना, हाल के एप्लिकेशन बटन दबाना, आने वाली कॉल, होम बटन दबाना (इस मामले में onPause के बाद onStop आएगा)। onPause विधि डेटा सहेजने का अंतिम विश्वसनीय स्थान है जिसे उपयोगकर्ता को नहीं खोना चाहिए।

onPause में निम्नलिखित किए जाते हैं: ईमेल ड्राफ्ट और इनपुट फॉर्म को Room या SharedPreferences में सहेजना; एनिमेशन और वीडियो प्लेबैक रोकना; कैमरा बंद करना और अनन्य संसाधन मुक्त करना; पृष्ठभूमि में गैर-महत्वपूर्ण महँगी संक्रियाएँ रद्द करना। onPause विधि 100 मिलीसेकंड से कम में पूरी होनी चाहिए — सिस्टम अगली Activity में संक्रमण को तब तक अवरुद्ध करता है जब तक onPause नियंत्रण वापस नहीं करता, और सीमा से अधिक होने पर ANR (Application Not Responding) होता है।

override fun onPause() {
    super.onPause()
    val editor = SharedPreferences.Manager ...
    editor.putString("draft_text", draftEditText.text.toString())
    editor.apply()
    videoView.pause()
    cameraHolder.release()
}

महत्वपूर्ण: onPause UI थ्रेड पर निष्पादित होता है, इसलिए Room के माध्यम से सिंक्रोनस क्वेरी के साथ डेटाबेस में लिखने जैसी कोई भी अवरोधक संक्रिया एसिंक्रोनस (कोरूटीन) से बदली जानी चाहिए या पृष्ठभूमि थ्रेड पर निष्पादित की जानी चाहिए। SharedPreferences के लिए commit() के बजाय apply() का उपयोग करें — apply एसिंक्रोनस रूप से डेटा लिखता है और UI थ्रेड को अवरुद्ध नहीं करता।

onStop — स्क्रीन से छिपना

onStop() तब कॉल किया जाता है जब Activity उपयोगकर्ता को दिखाई देना बंद कर देती है। यह निम्नलिखित मामलों में होता है: Activity पूरी तरह से किसी अन्य Activity द्वारा ढकी हुई है; उपयोगकर्ता ने होम बटन दबाया या किसी अन्य एप्लिकेशन पर स्विच किया; Activity समाप्त हो रही है (बाद में onDestroy कॉल किया जाएगा)। onStop अवस्था में, Activity मेमोरी में रहती है और अपने सभी फ़ील्ड बनाए रखती है — यह नष्ट नहीं हुई है, लेकिन सक्रिय भी नहीं है।

onStop में निम्नलिखित किए जाते हैं: onStart में पंजीकृत BroadcastReceiver को अनपंजीकृत करना; Bound सेवाओं से डिस्कनेक्ट करना; LocationListener, SensorListener और अन्य सिस्टम श्रोताओं को मुक्त करना; लंबी पृष्ठभूमि संक्रियाएँ रोकना जो एप्लिकेशन छिपे होने पर आवश्यक नहीं हैं; onSaveInstanceState() के माध्यम से Bundle में वर्तमान UI स्थिति लिखना यदि यह onPause में नहीं किया गया था।

override fun onStop() {
    super.onStop()
    unregisterReceiver(connectivityReceiver)
    unbindService(serviceConnection)
    if (isChangingConfigurations()) {
        Log.d("Lifecycle", "कॉन्फ़िगरेशन के कारण Activity पुनर्निर्मित होती है")
    }
}

सिस्टम मेमोरी कम होने पर onStop अवस्था में Activity को onDestroy कॉल किए बिना नष्ट कर सकता है। इसलिए सभी महत्वपूर्ण डेटा onStop में संक्रमण से पहले सहेजा जाना चाहिए। isChangingConfigurations() फ़्लैग यह निर्धारित करने की अनुमति देता है कि क्या onStop कॉल स्क्रीन रोटेशन से संबंधित है — इस मामले में, Activity पुनर्निर्मित की जाएगी, समाप्त नहीं की जाएगी।

onDestroy — Activity का विनाश

onDestroy() — जीवनचक्र की अंतिम विधि जो Activity के पूर्ण विनाश से पहले कॉल की जाती है। सिस्टम onDestroy को दो मामलों में कॉल करता है: Activity finish() के माध्यम से समाप्त होती है या उपयोगकर्ता बैक बटन दबाता है; Activity सिस्टम द्वारा कॉन्फ़िगरेशन परिवर्तन (जैसे स्क्रीन रोटेशन) के कारण नष्ट की जाती है और फिर से बनाई जाएगी। onDestroy विधि अंतिम संसाधन सफाई करने की अनुमति देती है: थ्रेड और कोरूटीन को अनबाइंड करना, स्थायी रूप से खुले कर्सर और सॉकेट बंद करना, NDK के माध्यम से नेटिव मेमोरी मुक्त करना।

override fun onDestroy() {
    super.onDestroy()
    backgroundJob.cancel()
    dbHelper.close()
    if (isFinishing) {
        Log.d("Lifecycle", "Activity स्थायी रूप से समाप्त हो रही है")
    } else {
        Log.d("Lifecycle", "Activity पुनर्निर्मित की जाएगी")
    }
}

महत्वपूर्ण नोट: onDestroy के कॉल की गारंटी नहीं है यदि एप्लिकेशन प्रक्रिया सिस्टम द्वारा मार दी जाती है (out-of-memory kill)। इसलिए डेटा सहेजने के लिए onDestroy पर निर्भर नहीं रहा जा सकता — यह कार्य onPause या onStop में हल किया जाता है। isFinishing प्रॉपर्टी finish() द्वारा Activity समाप्ति और कॉन्फ़िगरेशन परिवर्तन पर पुनर्निर्माण के बीच अंतर करने की अनुमति देती है।

onRestart — रुकी स्थिति से वापसी

onRestart() onStart() से पहले कॉल किया जाता है जब Activity रुकी स्थिति (onStop) से वापस अग्रभूमि में आती है। यह तब होता है जब उपयोगकर्ता हाल के एप्लिकेशन मेनू से एप्लिकेशन फिर से खोलता है या किसी चाइल्ड स्क्रीन पर बैक दबाकर Activity पर लौटता है। onRestart विधि onCreate से अलग तर्क निष्पादित करने की अनुमति देती है — उदाहरण के लिए, डेटा अपडेट करना जो Activity के छिपे होने पर बदल सकता है।

override fun onRestart() {
    super.onRestart()
    refreshDataFromNetwork()
    Log.d("Lifecycle", "Activity स्टैक से पुनः प्रारंभ हो रही है")
}

विशिष्ट परिदृश्य: उपयोगकर्ता ने एप्लिकेशन खोला, दूसरे कार्य पर स्विच किया, और एक घंटे बाद वापस आया। onRestart में, एप्लिकेशन डेटा की प्रासंगिकता की जाँच कर सकता है और, यदि बहुत समय बीत गया है, तो सामग्री को पुनः लोड करने का सुझाव दे सकता है। यह उपयोगकर्ता अनुभव में सुधार करता है और पुरानी जानकारी प्रदर्शित करने की संभावना को कम करता है।

स्क्रीन रोटेशन और स्थिति सहेजना

स्क्रीन रोटेशन Activity पुनर्निर्माण का सबसे सामान्य परिदृश्य है। डिफ़ॉल्ट रूप से, Android प्रत्येक ओरिएंटेशन परिवर्तन पर वर्तमान Activity को नष्ट करता है और एक नई बनाता है। यदि स्थिति सहेजी नहीं गई है, तो उपयोगकर्ता सभी दर्ज डेटा खो देगा। Android इसके लिए दो क्रियाविधियाँ प्रदान करता है: onSaveInstanceState() धारावाहिक डेटा के लिए और ViewModel कॉन्फ़िगरेशन परिवर्तनों से बचे रहने वाले डेटा के लिए।

onSaveInstanceState और onRestoreInstanceState

अस्थायी स्थिति सहेजने के लिए Activity के नष्ट होने से पहले onSaveInstanceState() कॉल किया जाता है। सहेजा गया डेटा savedInstanceState पैरामीटर के माध्यम से onCreate और onRestoreInstanceState() विधि को पारित किया जाता है, जो onStart के बाद कॉल की जाती है। Bundle का आकार सीमा होती है — लगभग 500 KB, इसलिए डेटा की बड़ी मात्रा (जैसे बिटमैप) ViewModel के माध्यम से सहेजी जाती है।

<!-- AndroidManifest.xml — ओरिएंटेशन स्थिरीकरण -->
<activity android:name=".MainActivity"
    android:configChanges="orientation|screenSize" />

android:configChanges के माध्यम से ओरिएंटेशन को स्थिर करना Activity पुनर्निर्माण को रोकता है, लेकिन यदि एप्लिकेशन को दोनों ओरिएंटेशन का समर्थन करना है तो इसे एंटीपैटर्न माना जाता है। आधुनिक Google अनुशंसा UI में उपयोगकर्ता द्वारा दर्ज डेटा के लिए onSaveInstanceState के साथ ViewModel का उपयोग करना है।

Fragment जीवनचक्र

Fragment का अपना जीवनचक्र होता है, जो Activity के समान है लेकिन अतिरिक्त विधियों के साथ: onAttach, onCreate, onCreateView, onViewCreated, onStart, onResume, onPause, onStop, onDestroyView, onDestroy, onDetach। Fragment हमेशा Activity के अंदर मौजूद होता है, और इसका जीवनचक्र कंटेनर Activity के जीवनचक्र से बंधा होता है। यदि Activity नष्ट होती है, तो Fragment उसका अनुसरण करता है।

मुख्य अंतर: Fragment न केवल घटक की स्थिति बल्कि View पदानुक्रम का भी प्रबंधन करता है। onCreateView विधि Fragment की मूल View लौटाती है, और onDestroyView इस पदानुक्रम को नष्ट करती है। यह Fragment को स्क्रीन रोटेशन के दौरान Activity पुनर्निर्माण से बचने की अनुमति देता है: Fragment संरक्षित रहता है, और इसकी View onCreateView में फिर से बनाई जाती है।

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

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        val avatarImage: ImageView = view.findViewById(R.id.avatar_image)
        loadAvatar(avatarImage)
    }
}

onCreate और onCreateView के बीच अंतर को समझना अत्यंत महत्वपूर्ण है: onCreate Fragment के जीवनकाल में एक बार कॉल होता है (View पुनर्निर्मित होने पर भी), जबकि onCreateView हर बार कॉल होता है जब Fragment अपना View पदानुक्रम बनाता या पुनर्निर्मित करता है। डेटा प्रारंभीकरण onCreate में किया जाता है, जबकि UI बंधन onViewCreated में किया जाता है।

LifecycleObserver और Jetpack

LifecycleObserver — Android Jetpack लाइब्रेरी का एक घटक है जो Activity या Fragment में विधियों को ओवरराइड किए बिना जीवनचक्र परिवर्तनों पर प्रतिक्रिया करने की अनुमति देता है। प्रत्येक जीवनचक्र विधि में कोड दोहराने के बजाय, डेवलपर @OnLifecycleEvent एनोटेशन के साथ एक अलग वर्ग बनाता है और इसे lifecycle.addObserver() में पारित करता है।

Jetpack LifecycleOwner इंटरफ़ेस भी प्रदान करता है, जिसे AppCompatActivity और Fragment लागू करते हैं। कोई भी ऑब्जेक्ट जो LifecycleOwner लागू करता है, LiveData सब्सक्रिप्शन, lifecycleScope के माध्यम से कोरूटीन, और जीवनचक्र के संबंध में WorkManager का प्रबंधन कर सकता है। यह MVVM और Jetpack पर आधारित आधुनिक Android आर्किटेक्चर की आधारशिला है।

class MyLocationObserver(private val context: Context) : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        startLocationUpdates()
    }

    override fun onStop(owner: LifecycleOwner) {
        stopLocationUpdates()
    }
}

// Activity में:
lifecycle.addObserver(MyLocationObserver(this))

DefaultLifecycleObserver का उपयोग परीक्षण को सरल बनाता है, कोड दोहराव को कम करता है, और जीवनचक्र तर्क को विभिन्न स्क्रीनों पर पुन: प्रयोज्य बनाता है। यह प्रत्येक Activity में मैन्युअल रूप से onStart/onStop ओवरराइड करने का आधुनिक विकल्प है। IT Sectr द्वारा विकसित Android एप्लिकेशन में, हम भू-स्थान, Bluetooth स्कैनिंग और एनालिटिक्स के लिए LifecycleObserver लागू करते हैं — इससे boilerplate कोड की मात्रा 30–40% कम हो जाती है।