onCreate — यह क्या है, Android में Activity आरंभ करना

Android में onCreate क्या है

onCreate एक कॉलबैक विधि है जिसे Android Activity या Fragment का नया उदाहरण बनाते समय बुलाता है. यह यूजर स्क्रीन कोड में पहला प्रवेश बिंदु है: onCreate बुलाए जाने से पहले कोई यूजर कोड नहीं चलता। सिस्टम विधि में एक Bundle पैरामीटर पास करता है, जिसमें पहले से संग्रहीत डेटा (पुनर्निर्माण पर) या null (पहली लॉन्च पर) होता है।

onCreate विधि को क्लास android.app.Activity और क्लास androidx.fragment.app.Fragment में परिभाषित किया गया है। दोनों संस्करण समान कार्य करते हैं: कंपोनेंट आरंभ, UI सेटअप और स्थिति पुनर्स्थापन। हालाँकि, विशिष्ट कार्यान्वयन अलग है — Activity लैआउट लोड करने के लिए setContentView का उपयोग करता है, जबकि Fragment onCreateView के माध्यम से View लौटाता है। डिवेलपर को Activity में कम से कम onCreate को ओवरराइड करना चाहिए — इसके बिना, Android स्क्रीन प्रदर्शित नहीं कर सकता।

onCreate एक Activity उदाहरण के पूर्ण जीवनचक्र में सदिव एक बार बुलाया जाता है। स्क्रीन रोटेशन पर भी, एक नया Activity उदाहरण पिछले उदाहरण से Bundle के साथ एक नया onCreate कॉल प्राप्त करता है। यह onCreate को एक-बार आरंभ के लिए आदर्श स्थान बनाता है: डेटा लोड करना, एडाप्टर बनाना, Dagger या Hilt के माध्यम से DI कंपोनेंट सेटअप करना।

Activity में onCreate

Activity में, onCreate विधि चार मुख्य कार्य करती है: लैआउट मार्कअप लोड करना, View तत्वों को आरंभ करना, Bundle से स्थिति पुनर्स्थापित करना और प्राथमिक ईवेंट हैंड्लर सेटअप करना. onCreate में अनिवार्य न्यूनतम कोड super.onCreate(savedInstanceState) और setContentView(R.layout.activity_main) को बुलाना है।

class MainActivity : AppCompatActivity() {
    private var binding: ActivityMainBinding? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // ViewBinding — findViewById का आधुनिक विकल्प
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding?.root)

        // binding का उपयोग करके आरंभ
        binding?.apply {
            welcomeText.text = getString(R.string.welcome)
            startButton.setOnClickListener { startGame() }
        }

        // स्थिति पुनर्स्थापन
        if (savedInstanceState != null) {
            score = savedInstanceState.getInt("score", 0)
            binding?.scoreText?.text = score.toString()
        }
    }
}

आधुनिक अभ्यास findViewById के बजाय ViewBinding का उपयोग करता है। ViewBinding कंपाइल टाइम पर क्लास ActivityMainBinding जेनरेट करता है, जो गलत ID से त्रुटियों को समाप्त करता है और बॉयलरप्लेट कोड कम करता है। Google Android Studio 3.6 से शुरू करते हुए Activity और Fragment में View तक पहुँचने के मानक तरीके के रूप में ViewBinding की अनुशंसा करता है।

onCreate में संचालनों का क्रम सदिव होना चाहिए: पहले super, फिर setContentView, फिर बाकी सब कुछ। setContentView से पहले findViewById को बुलाने पर null लौटता है — लैआउट अभी लोड नहीं हुआ है, और View तत्व अनुक्रम में मौजूद नहीं हैं। यह शुरुआती Android डिवेलपरों द्वारा की जाने वाली सबसे आम गलतियों में से एक है।

Fragment में onCreate

Fragment में onCreate Activity से अलग है: यहाँ setContentView नहीं बुलाया जाता, केवल UI से संबंधित नहीं डेटा आरंभ किया जाता है. Fragment कंपोनेंट निर्माण और View निर्माण को दो अलग-अलग विधियों में विभाजित करता है: onCreate (एक बार बुलाया जाता है) और onCreateView (हर बार बुलाया जाता है जब View बनाया या फिर से बनाया जाता है)।

class UserListFragment : Fragment() {
    private lateinit var viewModel: UserViewModel
    private var binding: FragmentUserListBinding? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // ViewModel आरंभ — View पुनर्निर्माण से बच जाता है
        viewModel = ViewModelProvider(this)[UserViewModel::class.java]

        // FragmentManager से आर्गुमेंट
        arguments?.let {
            viewModel.loadUser(it.getString("user_id") ?: "")
        }

        // रोटेशन पर सहेजना
        retainInstance = true
    }

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        binding = FragmentUserListBinding.inflate(inflater, container, false)
        return binding!!.root
    }
}

Activity और Fragment onCreate के बीच मुख्य अंतर: Fragment में onCreate में View से संबंधित कोड नहीं होना चाहिए, क्योंकि View को नष्ट और पुनर्निर्मित किया जा सकता है (उदाहरण के लिए, ViewPager टैब स्विच करते समय), जबकि onCreate केवल एक बार बुलाया जाता है। डेटा लोडिंग, ViewModel सेटअप और एडाप्टर आरंभ onCreate कार्य हैं, जबकि View बाँधना onViewCreated का कार्य है।

savedInstanceState और स्थिति पुनर्स्थापन

onCreate में savedInstanceState पैरामीटर Activity या Fragment की अस्थायी स्थिति को संग्रहीत और पुनर्स्थापित करने का एक तंत्र है. जब सिस्टम Activity को नष्ट करता है (स्क्रीन रोटेशन, कम मेमोरी), तो यह onSaveInstanceState() को बुलाता है, जहाँ डिवेलपर Bundle में की-वैल्यू एंट्री डालता है। जब एक नया उदाहरण बनाया जाता है, तो यह Bundle onCreate में लौटाया जाता है।

Bundle निम्नलिखित डेटा प्रकारों का समर्थन करता है: String, Integer, Boolean, Long, Float, Double, उनके एरे, साथ ही Parcelable और Serializable ऑब्जेक्ट। जटिल ऑब्जेक्ट के लिए, Parcelable का उपयोग किया जाता है — Android के लिए एक अधिक प्रदर्शन सीरियलिज़ेशन तंत्र। Bundle का आकार लगभग 500 KB तक सीमित है — सीमा पार करने पर TransactionTooLargeException होता है।

companion object {
    private const val KEY_USER_NAME = "user_name"
    private const val KEY_SCORE = "score"
}

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

    if (savedInstanceState != null) {
        userName = savedInstanceState.getString(KEY_USER_NAME) ?: ""
        currentScore = savedInstanceState.getInt(KEY_SCORE)
    }
}

override fun onSaveInstanceState(outState: Bundle) {
    super.onSaveInstanceState(outState)
    outState.putString(KEY_USER_NAME, userName)
    outState.putInt(KEY_SCORE, currentScore)
}

यह समझना महत्वपूर्ण है: onSaveInstanceState तब नहीं बुलाया जाता जब यूजर स्पष्ट रूप से finish() या बैक बटन के माध्यम से Activity बंद करता है. सिस्टम मानता है कि यूजर सचेत रूप से काम समाप्त कर रहा है और स्थिति को संग्रहीत करने की आवश्यकता नहीं है। इसलिए, आप दीर्घकालिक डेटा भंडारण के लिए केवल savedInstanceState पर निर्भर नहीं रह सकते — Room, DataStore या SharedPreferences का उपयोग करें।

onCreate का समय और सीमाएँ

onCreate मुख्य (UI) थ्रेड पर निष्पादित होता है, और सिस्टम Activity को स्क्रीन पर प्रदर्शित करने से पहले इसके पूरा होने का इंतजार करता है. यदि onCreate में 5 सेकंड से अधिक समय लगता है, तो सिस्टम एक ANR (Application Not Responding) संवाद दिखाता है और यूजर को एप्लिकेशन बंद करने का विकल्प देता है। लंबे ऑपरेशन, जैसे नेटवर्क से डेटा लोड करना या डेटाबेस से पढ़ना, को बैकग्रउंड थ्रेड में ले जाना चाहिए।

Google Android Performance (2025) की अनुशंसाओं के अनुसार, onCreate को मध्यम श्रेणी के उपकरणों पर 1 सेकंड से कम में पूरा होना चाहिए। इसे प्राप्त करने के लिए: लेज़ी इनिशियलिज़ेशन (Kotlin में lazy delegate) का उपयोग करें, भारी डेटा लोडिंग को onResume या कोरूटिन के माध्यम से विलंबित करें, शायद ही उपयोग किए जाने वाले UI कंपोनेंट के लिए ViewStub लागू करें, और Android Vitals के माध्यम से स्टार्टअप समय का प्रोफाइल करें।

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

    // आलस आरंभ — ऑब्जेक्ट केवल पहली पहुँच पर बनता है
    val heavyData by lazy {
        HeavyDataLoader.load()
    }

    // lifecycleScope के माध्यम से बैकग्रउंड थ्रेड में डेटा लोड करना
    lifecycleScope.launch(Dispatchers.IO) {
        val users = userDao.getAllUsers()
        withContext(Dispatchers.Main) {
            adapter.submitList(users)
        }
    }
}

प्रोफाइलिंग उपकरण: Android Studio Profiler (CPU टैब) प्रत्येक विधि का सटीक निष्पादन समय दिखाता है। Android Vitals (Google Play Console) में, आप «कोल्ड स्टार्ट टाइम» मैट्रिक ट्रैक कर सकते हैं — यदि आपके Activity का onCreate 500 ms से अधिक है, तो कंसोल इसे प्रदर्शन समस्या के रूप में चिह्नित करता है। IT Sectr में, हम CI पाइपलाइन में प्रत्येक Activity के स्टार्टअप समय के स्वचालित नियंत्रण के लिए Macrobenchmark परीक्षणों का उपयोग करते हैं।

ViewModel और onCreate

ViewModel में onCreate में डेटा आरंभ करने का सबसे अच्छा तरीका है जो स्क्रीन रोटेशन में बच सकता है. ViewModel onCreate में ViewModelProvider के माध्यम से बनाया जाता है और कॉन्फ़िगरेशन परिवर्तनों पर स्वचालित रूप से संरक्षित रहता है। जब रोटेशन के बाद Activity पुनर्निर्मित होता है, तो ViewModel मेमोरी में रहता है, और onCreate बिना डेटा हानि के वही ViewModel प्राप्त करता है।

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

    // ViewModel एक बार बनता है और कॉन्फ़िगरेशन परिवर्तनों से बच जाता है
    val viewModel: ProfileViewModel =
        ViewModelProvider(this)[ProfileViewModel::class.java]

    // LiveData अवलोकन — डेटा बदलने पर UI स्वचालित रूप से अपडेट होता है
    viewModel.user.observe(this) { user ->
        binding?.userName?.text = user.name
        binding?.userEmail?.text = user.email
    }

    // यदि ViewModel अभी बनाया गया है तो डेटा लोड करना
    if (savedInstanceState == null) {
        viewModel.loadProfile(userId)
    }
}

ViewModel + LiveData/StateFlow का संयोजन Bundle में मैनुअल सेविंग के बिना स्क्रीन रोटेशन समस्या को हल करता है। ViewModel डेटा को मेमोरी में संग्रहीत करता है, LiveData पुनर्निर्माण पर Activity को स्वचालित रूप से पुनर्सदस्यत करता है, और StateFlow (Kotlin Coroutines से) कोरूटिन समर्थन के साथ प्रतिक्रियाशीलता जोड़ता है। Google द्वारा Guide to App Architecture में अनुशंसित मानक आर्किटेक्चर यही है।

onCreate के साथ काम करते समय सामान्य गलतियाँ

अनुभवी डिवेलपर भी onCreate में विशिष्ट गलतियाँ करते हैं। आइए पाँच सबसे सामान्य समस्याओं और उनसे बचने के तरीकों पर नजर डालें।

setContentView से पहले View के साथ काम करना

सबसे आम गलती setContentView को बुलाने से पहले findViewById के माध्यम से View खोजने की कोशिश करना है. सभी View तत्व लैआउट इन्फलेशन के समय बनाए जाते हैं, इसलिए setContentView से पहले कोई भी findViewById कॉल null लौटाता है और View का उपयोग करने की कोशिश करने पर NullPointerException का कारण बनता है। हल: सदिव क्रम — पहले super, फिर setContentView, फिर findViewById या ViewBinding।

लंबे ऑपरेशनों से UI थ्रेड को अवरुद्ध करना

नेटवर्क से डेटा लोड करना, डेटाबेस से पढ़ना या बड़े ऐरे को सीधे onCreate में संसाधित करना पहले फ्रेम के रेंडरिंग को अवरुद्ध करता है. यूजर को onCreate पूरा होने तक काली स्क्रीन दिखाई देती है, जो एप्लिकेशन की गति की धारणा को खराब करता है। हल: असंचालक संचालनों के लिए lifecycleScope.launch का उपयोग करें, लोडिंग पूरा होने तक एक कंकाल (UI placeholder) प्रदर्शित करें।

savedInstanceState की उपेक्षा करना

यदि आप स्क्रीन रोटेशन पर Bundle से स्थिति पुनर्स्थापित नहीं करते, तो यूजर सभी असंग्रहीत इनपुट खो देता है: फ़ॉर्म फ़ील्ड में टेक्स्ट, स्क्रोल स्थिति, चयनित आइटम्स। हल: डेटा पुनर्स्थापित करने के लिए हमेशा onCreate में savedInstanceState != null की जाँच करें, भले ही स्थिति हानि की संभावना कम लगती हो।

अनाम क्लासों के माध्यम से मेमोरी लीक

onCreate में अनाम क्लास और लैंब्डा अपने नष्ट होने के बाद भी Activity का संदर्भ अप्रत्यक्ष रूप से धारण कर सकते हैं. उदाहरण के लिए, onCreate में बनाया गया Handler Activity नष्ट होने के बाद भी विलंबित कार्यों को निष्पादित करता रहता है। हल: LifecycleObserver, ViewModel और lifecycleScope का उपयोग करें, जो नष्ट होने पर कार्यों को स्वचालित रूप से रद्द करते हैं।

Fragment onCreate में अत्यधिक आरंभ

Fragment onCreate में View को आरंभ करना एक तार्किक त्रुटि है, क्योंकि View को onCreate को बुलाए बिना पुनर्निर्मित किया जा सकता है। यदि आप onCreate में एक लिसनर सेट करते हैं लेकिन View को onCreateView में बाँधते हैं, तो पुनर्निर्माण पर लिसनर पुरानी View पर बना रहेगा। हल: सभी View-संबंधित कार्य onViewCreated में करें, onCreate को केवल डेटा लेयर आरंभ के लिए छोड़ दें।