onStart: सार, Android स्क्रीन पर Activity की दृश्यता

Android में onStart का सार

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

onStart विधि Activity के «दृश्य जीवनकाल» (visible lifetime) में आती है — onStart और onStop के बीच का अंतराल। इस अवधि के दौरान, Activity अन्य विंडो (जैसे पारदर्शी Activity या डायलॉग विंडो) द्वारा आंशिक रूप से ढकी हो सकती है, लेकिन इसका UI दृश्य रहता है। यह दृश्य जीवनकाल को «अग्रभूमि जीवनकाल» (onResume — onPause) से अलग करता है, जब Activity में पूर्ण इनपुट फोकस होता है।

इस तीन-स्तरीय पदानुक्रम को समझना कोड के सही वितरण के लिए महत्वपूर्ण है। onCreate — एक बार की प्रारंभिकता, onStart — दृश्य संसाधनों को जोड़ना, onResume — विशिष्ट संसाधनों तक अनन्य पहुँच। डेवलपर जो इन स्तरों को भ्रमित करता है, वह स्क्रीन के बीच स्विच करते समय मेमोरी लीक या एप्लिकेशन के गलत व्यवहार का जोखिम उठाता है।

Activity में onStart

Activity में, onStart विधि हर बार कॉल की जाती है जब स्क्रीन डिस्प्ले पर प्रकट होती है — पहले लॉन्च पर (onCreate के बाद) और पृष्ठभूमि से वापस आने पर (onRestart के बाद) दोनों। onCreate के विपरीत, onStart को Activity इंस्टेंस के जीवनकाल में कई बार कॉल किया जा सकता है, इसलिए यहाँ वह कोड रखा जाता है जो स्क्रीन प्रकट होने पर हर बार निष्पादित होना चाहिए।

class DashboardActivity : AppCompatActivity() {
    private val connectivityReceiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context?, intent: Intent?) {
            val isConnected = ... // ConnectivityManager जाँच
            binding?.statusIndicator?.setColor(
                if (isConnected) Color.GREEN else Color.RED
            )
        }
    }

    override fun onStart() {
        super.onStart()
        registerReceiver(
            connectivityReceiver,
            IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION)
        )
        SensorManager.getInstance().registerStepCounter()
    }

    override fun onStop() {
        unregisterReceiver(connectivityReceiver)
        SensorManager.getInstance().unregisterStepCounter()
        super.onStop()
    }
}

मुख्य नियम: onStart में जुड़े सभी संसाधनों को onStop में जारी किया जाना चाहिए। यह सुनिश्चित करता है कि जब Activity स्क्रीन से छिपी हो, तो वह बैटरी न खाए, सिस्टम इवेंट न सुने, और मेमोरी न घेरे। Android Studio में lint नियम हैं जो संबंधित अपंजीकरण के बिना BroadcastReceiver पंजीकृत करने पर चेतावनी देते हैं।

Fragment में onStart

Fragment में onStart कंटेनर Activity के जीवनचक्र से निकटता से जुड़ा है. Fragment को onStart कॉल तब मिलता है जब उसके कंटेनर Activity को onStart मिल चुका होता है। हालाँकि, यदि Fragment को विलंबित मोड में जोड़ा गया है (FragmentTransaction.commit() बिना addToBackStack), तो onStart विलंब से कॉल हो सकता है।

class MapFragment : Fragment() {
    private var mapView: MapView? = null

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        mapView = MapView(requireContext())
        return mapView!!
    }

    override fun onStart() {
        super.onStart()
        mapView?.onStart()
        LocationService.connect(requireContext())
    }

    override fun onStop() {
        mapView?.onStop()
        LocationService.disconnect()
        super.onStop()
    }
}

Fragment.onStart की विशिष्टता: यदि Fragment offscreenPageLimit = 1 के साथ ViewPager में है, तो पड़ोसी फ़्रैगमेंट भी दृश्य होने से पहले onStart प्राप्त करेंगे। यह समय से पहले लिसनर पंजीकरण का कारण बन सकता है। ऐसे मामलों के लिए, setUserVisibleHint() विधि का उपयोग करें या केवल वास्तव में दृश्य फ़्रैगमेंट के लिए लिसनर पंजीकृत करने हेतु onStart के अंदर isVisible जाँचें।

onStart और onResume में अंतर

onStart और onResume के बीच मुख्य अंतर स्क्रीन गतिविधि का स्तर है. onStart संकेत देता है कि Activity स्क्रीन पर दृश्य है लेकिन जरूरी नहीं कि अग्रभूमि में हो। onResume संकेत देता है कि Activity अग्रभूमि में है और उसके पास इनपुट फोकस है। अंतर डायलॉग विंडो उदाहरण द्वारा प्रदर्शित किया गया है: जब Activity के ऊपर Dialog प्रकट होता है, तो Activity onResume खो देती है (onPause कॉल होता है) लेकिन दृश्य रहती है — onStart/onStop कॉल नहीं होते।

तुलना तालिका स्पष्ट रूप से दिखाती है कि किन परिदृश्यों में प्रत्येक विधि कॉल की जाती है:

यह तालिका डेवलपर को यह तय करने में मदद करती है कि किस विधि में विशिष्ट कोड रखना है। उदाहरण के लिए, यदि एप्लिकेशन को किसी भी स्क्रीन ओवरलैप (यहाँ तक कि डायलॉग) पर वीडियो प्लेबैक रोकना चाहिए, तो कोड onPause में रखा जाता है। यदि वीडियो केवल स्क्रीन पूरी तरह छिपने पर रुकना चाहिए — कोड onStop में रखा जाता है।

लिसनर्स और सेवाओं का पंजीकरण

onStart उन लिसनर्स को पंजीकृत करने के लिए सर्वोत्तम स्थान है जिन्हें केवल तब काम करना चाहिए जब Activity स्क्रीन पर दृश्य हो. यह तीन मुख्य प्रकार के सिस्टम घटकों से संबंधित है: सिस्टम इवेंट के लिए BroadcastReceiver, जियोलोकेशन के लिए LocationListener, और डिवाइस सेंसर के लिए SensorListener.

onStart में BroadcastReceiver

BroadcastReceiver को onStart में Context.registerReceiver() के माध्यम से गतिशील रूप से पंजीकृत किया जाता है और onStop में unregisterReceiver() के माध्यम से हटाया जाता है। गतिशील पंजीकरण स्थिर पंजीकरण (मेनिफेस्ट में) से बेहतर है क्योंकि यह रिसीवर के जीवनकाल को Activity की दृश्यता अवधि तक सीमित करता है — जब Activity छिपी होती है तो एप्लिकेशन सिस्टम ब्रॉडकास्ट संदेशों से नहीं जागता।

private val batteryReceiver = object : BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent) {
        val level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1)
        binding?.batteryText?.text = "$level%"
    }
}

override fun onStart() {
    super.onStart()
    registerReceiver(batteryReceiver, IntentFilter(Intent.ACTION_BATTERY_CHANGED))
}

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

LocationListener और SensorListener

जियोलोकेशन और सेंसर संसाधन-गहन संचालन हैं. onStart में GPS अपडेट का अनुरोध करना और onStop में रद्द करना सुनिश्चित करता है कि स्क्रीन छिपी होने पर एप्लिकेशन बैटरी खत्म न करे। बारीक ट्यूनिंग के लिए, न्यूनतम अंतराल और दूरी के साथ requestLocationUpdates का उपयोग करें — उदाहरण के लिए, 10 सेकंड और 10 मीटर, जो सटीकता और ऊर्जा खपत के बीच इष्टतम संतुलन देता है।

एनिमेशन और onStart

onCreate के बजाय onStart में एनिमेशन शुरू करना सुनिश्चित करता है कि एनिमेशन हर बार स्क्रीन प्रकट होने पर शुरू हो. यदि आप onCreate में एनिमेशन शुरू करते हैं, तो यह केवल पहली Activity निर्माण पर काम करेगा, पृष्ठभूमि से वापस आने पर नहीं। onStart हर बार कॉल होता है जब Activity दृश्य होती है, जो इसे चक्रीय एनिमेशन और संक्रमण शुरू करने के लिए आदर्श स्थान बनाता है।

private lateinit var pulseAnimator: ValueAnimator

override fun onStart() {
    super.onStart()
    pulseAnimator.start()
    binding?.loadingIndicator?.animate()?.alpha(1f)?.start()
}

override fun onStop() {
    pulseAnimator.cancel()
    binding?.loadingIndicator?.animate()?.cancel()
    super.onStop()
}

ObjectAnimator या ValueAnimator का उपयोग करने वाले एनिमेशन के लिए, onStop में cancel() कॉल करना महत्वपूर्ण है। यदि Activity छिपने के बाद एनिमेशन चलता रहता है, तो यह बेकार में GPU और CPU संसाधनों का उपभोग करता है, जिससे डिवाइस का प्रदर्शन बिगड़ता है और बैटरी खत्म होने में तेजी आती है। Android Studio Profiler (GPU ग्राफ) आपको सक्रिय एनिमेशन ट्रैक करने और लीक का पता लगाने की अनुमति देता है।

onStart/onStop जोड़ी नियम पूर्वावलोकन के लिए कैमरे (CameraX) के साथ काम करने पर भी लागू होता है। onStart में कैमरा खोलना और onStop में बंद करना सुनिश्चित करता है कि जब आपका एप्लिकेशन स्क्रीन पर दृश्य नहीं है तो कैमरा अन्य एप्लिकेशन के लिए अवरुद्ध न हो। इस नियम का उल्लंघन Google Play पर नकारात्मक समीक्षाओं का एक सामान्य कारण है।