onStop — Android जीवनचक्र में Activity छिपाना

Android में onStop क्या है?

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

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

Android संगतता परिभाषा दस्तावेज़ (CDD) संस्करण 14+ के अनुसार, Stopped स्थिति में प्रक्रिया की OOM Killer द्वारा मारे जाने की प्राथमिकता कम होती है — पृष्ठभूमि चरण की प्रक्रियाओं से कम, लेकिन कैश की गई प्रक्रियाओं से अधिक। Google आँकड़ों के अनुसार, 68% प्रक्रिया मृत्यु के मामले तब होते हैं जब Activity Stopped स्थिति में होती है, न कि Paused में।

onStop कब कॉल किया जाता है: परिदृश्य और क्रम

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

onStop कॉल के मुख्य परिदृश्य:

• वर्तमान के ऊपर नई Activity शुरू करना — वर्तमान Activity को onPause, फिर onStop मिलता है; नई Activity onCreate → onStart → onResume से गुज़रती है।
• एप्लिकेशन छोटा करना (होम) — Activity 200–300 मिलीसेकंड में onPause → onStop में जाती है, Stopped स्थिति में मेमोरी में रहती है।
• स्क्रीन लॉक करना — सिस्टम onPause → onStop कॉल करता है क्योंकि लॉक स्क्रीन Activity को पूरी तरह से ढक देती है।
• इनकमिंग कॉल — फ़ोन एप्लिकेशन (डायलर) ऊपर शुरू होता है, वर्तमान Activity onStop में जाती है।
• दूसरे एप्लिकेशन पर स्विच करना (हाल के एप्लिकेशन) — Activity छिप जाती है, onStop प्राप्त करती है, लेकिन प्रक्रिया कैश में रहती है।

यह समझना महत्वपूर्ण है कि स्क्रीन रोटेशन पर onStop कॉल नहीं किया जाता — इस मामले में, Activity नष्ट (onPause → onStop → onDestroy) और पुनः निर्मित (onCreate → onStart → onResume) होती है। अपवाद मेनिफ़ेस्ट में android:configChanges="orientation" फ़्लैग है, जो Activity पुनर्निर्माण को रोकता है और इसके बजाय onConfigurationChanged() कॉल करता है।

Activity जीवनचक्र में onStop

onStop Activity जीवनचक्र अनुक्रम में दृश्य और अदृश्य स्थिति के बीच एक केंद्रीय स्थान रखता है। पूरा अनुक्रम: onCreate → onStart → onResume → (सक्रिय स्थिति) → onPause → onStop → onDestroy (या वापसी पर onRestart → onStart → onResume)।

*Stopped स्थिति में, Activity मेमोरी में रखी जाती है लेकिन संसाधनों की कमी पर सिस्टम द्वारा मारी जा सकती है। Stopped प्रक्रियाओं की मारने की प्राथमिकता अंतिम से दूसरी है, केवल कैश की गई खाली प्रक्रियाओं से ऊपर।

onStop और onSaveInstanceState: सिस्टम गतिशील UI स्थिति को सहेजने के लिए onStop से पहले onSaveInstanceState(Bundle) कॉल करता है। डेवलपर इस विधि को ओवरराइड करता है ताकि इनपुट फ़ील्ड मान, RecyclerView स्थिति और चयनित आइटम Bundle में सहेज सके। भले ही Activity नष्ट न हो (उपयोगकर्ता ने केवल छोटा किया और लौटा), Bundle कॉन्फ़िगरेशन परिवर्तनों पर onCreate को पास किया जाता है। Google केवल क्षणिक UI स्थिति — रिपॉज़िटरी डेटा या ViewModel नहीं, जो Activity के बाहर रहते हैं — सहेजने की सलाह देता है।

onStop में कौन से संसाधन मुक्त करें

onStop में, डेवलपर को उन सभी संसाधनों को मुक्त करना चाहिए जो Activity के दृश्य न होने पर आवश्यक नहीं हैं। इससे बैटरी, CPU और मेमोरी पर भार कम होता है, और Activity पर वापस आने पर ANR को भी रोकता है।

onStop में क्या मुक्त करें:

• एनिमेशन और ट्रांज़िशन — ObjectAnimator, ValueAnimator, ViewPropertyAnimator रोकें। अदृश्य Activity पर चलने वाले एनिमेशन GPU चक्र बर्बाद करते हैं।
• सेंसर — SensorManager से सदस्यता रद्द करें (एक्सेलेरोमीटर, जायरोस्कोप, मैग्नेटोमीटर)। सेंसर Activity छिपे होने पर भी ऊर्जा खपत करते हैं।
• कैमरा और माइक्रोफ़ोन — Camera2 या CameraX मुक्त करें, MediaRecorder रोकें। Activity छिपे होने पर कैमरा सक्रिय छोड़ना Google Play नीति द्वारा निषिद्ध है।
• LocationListener — FusedLocationProviderClient या LocationManager से सदस्यता रद्द करें। भू-स्थान सबसे अधिक ऊर्जा खपत करने वाला संसाधन है।
• नेटवर्क श्रोता — WebSocket बंद करें, HTTP अनुरोध रद्द करें जो पृष्ठभूमि में आवश्यक नहीं हैं।
• MediaPlayer और ExoPlayer — प्लेबैक रोकें या बंद करें यदि इसे पृष्ठभूमि में जारी नहीं रहना चाहिए।

onStop में क्या न करें: लंबी अवधि के संचालन न करें — डेटाबेस में बड़ा डेटा सहेजना, नेटवर्क अनुरोध, जटिल गणनाएँ। onStop मुख्य थ्रेड पर चलता है और Activity पर वापसी को अवरुद्ध करता है। लंबी अवधि के संचालन के लिए, विलंब के साथ WorkManager या viewModelScope में कोरूटीन का उपयोग करें। ViewModel संसाधनों को मुक्त न करें — ViewModel onStop से बच जाता है और वापसी पर उपयोग किया जाएगा।

onStop और onPause में अंतर

onPause और onStop दृश्यता हानि की डिग्री और अनिवार्य कार्यों के दायरे में भिन्न होते हैं। onPause आंशिक फ़ोकस हानि पर कॉल किया जाता है (जैसे डायलॉग विंडो या सिस्टम मेनू खोलना), onStop — पूर्ण दृश्यता हानि पर। यह अंतर यह चुनने के लिए महत्वपूर्ण है कि प्रत्येक चरण पर कौन से संसाधन मुक्त करने हैं।

सामान्य नियम: onPause में, उन सिस्टम संसाधनों को मुक्त करें जो तुरंत किसी अन्य एप्लिकेशन के उपयोगकर्ता अनुभव को प्रभावित करते हैं (कैमरा, मीडिया प्लेयर); onStop में — वे सभी अन्य संसाधन जो Activity छिपे होने पर आवश्यक नहीं हैं। Google तेज़ स्विचिंग के दौरान onStop कॉल न होने की संभावना के कारण onPause में महत्वपूर्ण उपयोगकर्ता डेटा (ईमेल ड्राफ्ट, सेटिंग्स) सहेजने की सलाह देता है।

onStop → onRestart: स्क्रीन पर वापसी

जब उपयोगकर्ता छिपी हुई Activity पर वापस आता है, तो सिस्टम onRestart → onStart → onResume कॉल करता है। onRestart विधि संकेत देती है कि Activity Stopped स्थिति से वापस आ रही है। यह UI और उन संसाधनों को पुनर्स्थापित करने के लिए एक महत्वपूर्ण चरण है जो onStop में मुक्त किए गए थे।

वापसी पर कॉल अनुक्रम:

• onRestart() — Activity को सूचित किया जाता है कि इसे फिर से दिखाया जाएगा। विशिष्ट क्रियाएँ: डेटा पुनः लोड करना, सूचियाँ अपडेट करना।
• onStart() — Activity दृश्य हो जाती है लेकिन अभी सक्रिय नहीं है। यहाँ onStop में मुक्त किए गए संसाधनों को फिर से आरंभ किया जाता है।
• onResume() — Activity फ़ोकस प्राप्त करती है और इंटरैक्शन के लिए तैयार होती है। एनिमेशन शुरू होते हैं, सेंसर पंजीकृत होते हैं।

यदि एप्लिकेशन प्रक्रिया Stopped स्थिति में सिस्टम द्वारा मार दी गई थी, तो onRestart के बजाय onCreate कॉल किया जाता है, और onSaveInstanceState से Bundle स्थिति पुनर्स्थापना के लिए पास किया जाता है। यह परिदृश्य (प्रक्रिया मृत्यु) Android एप्लिकेशन में बग के सबसे सामान्य कारणों में से एक है: डेवलपर onRestart लागू करते हैं लेकिन प्रक्रिया मृत्यु के बाद onCreate के माध्यम से पुनर्स्थापना पर विचार करना भूल जाते हैं।

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

उदाहरण 1: सेंसर मुक्ति के साथ मूल onStop कार्यान्वयन

Activity छिपाने पर सही सेंसर सदस्यता रद्दीकरण और एनिमेशन रोकना प्रदर्शित करता है। स्क्रीन पर वापस आने पर, onStart में संसाधन पुनर्स्थापित होते हैं।

class MainActivity : AppCompatActivity() {
    private lateinit var sensorManager: SensorManager
    private var accelerometer: Sensor? = null
    private var rotationAnimator: ObjectAnimator? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
        accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
    }

    override fun onStart() {
        super.onStart()
        accelerometer?.let {
            sensorManager.registerListener(sensorListener, it, SensorManager.SENSOR_DELAY_NORMAL)
        }
        rotationAnimator = ObjectAnimator.ofFloat(findViewById(R.id.icon), "rotation", 0f, 360f)
        rotationAnimator?.apply {
            duration = 3000
            repeatMode = ValueAnimator.RESTART
            repeatCount = ValueAnimator.INFINITE
            start()
        }
    }

    override fun onStop() {
        super.onStop()
        sensorManager.unregisterListener(sensorListener)
        rotationAnimator?.cancel()
    }

    override fun onRestart() {
        super.onRestart()
        Log.d("MainActivity", "Activity Stopped स्थिति से वापस आ रही है")
    }

    private val sensorListener = SensorEventListener { event, _ ->
        Log.d("MainActivity", "त्वरण: x=${event.values[0]}, y=${event.values[1]}, z=${event.values[2]}")
    }
}

कोड onStart में एक्सेलेरोमीटर सेंसर पंजीकृत करता है और एक अनंत रोटेशन एनिमेशन शुरू करता है। onStop में, सेंसर अपंजीकृत हो जाता है और एनिमेशन रद्द हो जाता है — यह Activity छिपे होने पर बैटरी खपत को रोकता है। onRestart → onStart के माध्यम से वापसी के बाद, संसाधन पुनः निर्मित होते हैं।

उदाहरण 2: SavedStateHandle के माध्यम से स्थिति संरक्षण के साथ onStop

ViewModel + SavedStateHandle का उपयोग करके आधुनिक दृष्टिकोण। मैन्युअल Bundle हैंडलिंग के बिना onStop के दौरान फ़ॉर्म डेटा स्वचालित रूप से सहेजा जाता है।

class FormViewModel(
    private val savedStateHandle: SavedStateHandle
) : ViewModel() {
    var email: String
        get() = savedStateHandle["email"] ?: ""
        set(value) { savedStateHandle["email"] = value }

    var message: String
        get() = savedStateHandle["message"] ?: ""
        set(value) { savedStateHandle["message"] = value }
}

class FormActivity : AppCompatActivity() {
    private val viewModel: FormViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_form)
        Log.d("FormActivity", "onCreate: email=${viewModel.email}")
    }

    override fun onStop() {
        super.onStop()
        Log.d("FormActivity", "onStop: डेटा SavedStateHandle में सहेजा गया")
    }
}

SavedStateHandle स्वचालित रूप से onSaveInstanceState के दौरान Bundle में मान सहेजता है, जो onStop से पहले कॉल किया जाता है। स्क्रीन रोटेशन या प्रक्रिया मृत्यु पर, डेटा बिना हानि के पुनर्स्थापित होता है। Google प्रत्यक्ष onSaveInstanceState के बजाय फ़ॉर्म और ड्राफ्ट के लिए SavedStateHandle की सिफारिश करता है।

उदाहरण 3: onStop में संचालन के लिए lifecycleScope

onStop में संक्रमण के दौरान अतुल्यकालिक डेटा सहेजने के लिए कोरूटीन के साथ lifecycleScope का उपयोग। कोरूटीन मुख्य थ्रेड को अवरुद्ध किए बिना IO डिस्पैचर पर चलता है।

class NoteActivity : AppCompatActivity() {
    private val noteRepository = NoteRepository()

    override fun onStop() {
        lifecycleScope.launch(Dispatchers.IO) {
            val text = findViewById<EditText>(R.id.note_content).text.toString()
            noteRepository.saveDraft(text)
            withContext(Dispatchers.Main) {
                Log.d("NoteActivity", "ड्राफ्ट onStop में सहेजा गया")
            }
        }
        super.onStop()
    }
}

lifecycleScope.launch कोरूटीन स्वचालित रूप से रद्द हो जाता है यदि Activity जीवनचक्र समाप्त होता है। Dispatchers.IO का उपयोग सुनिश्चित करता है कि डेटाबेस या फ़ाइल लेखन Activity पर वापसी को अवरुद्ध न करे। Google के अनुसार, lifecycleScope में कोरूटीन onStop में अतुल्यकालिक संचालन करने का पसंदीदा तरीका है।