iOS में ViewController Lifecycle: मुख्य अवधारणाएँ, चरण और विधियाँ

ViewController Lifecycle क्या है

ViewController Lifecycle उन विधियों का एक सेट है जो UIViewController अपने अस्तित्व के दौरान UIKit से प्राप्त करता है। iOS ऐप में प्रत्येक स्क्रीन क्रमिक रूप से निर्माण, View लोडिंग, स्क्रीन पर प्रकट होने, छिपने और मेमोरी मुक्त करने के चरणों से गुज़रती है। UIKit प्रत्येक चरण में संबंधित विधियों को स्वचालित रूप से कॉल करता है, और डेवलपर अपना तर्क जोड़ने के लिए उन्हें ओवरराइड करता है।

UIViewController आर्किटेक्चर UIKit की नींव है और SwiftUI युग में भी प्रासंगिक बना हुआ है — कई प्रोजेक्ट अभी भी क्लासिक दृष्टिकोण या हाइब्रिड आर्किटेक्चर का उपयोग करते हैं। Lifecycle को समझने से आप भविष्यवाणी कर सकते हैं कि subviews कब उपलब्ध हैं, लेआउट को संशोधित करना कब सुरक्षित है, और स्क्रीन प्रकट या छिपने पर कौन से संचालन करने चाहिए।

जीवन चक्र की प्रत्येक विधि का विशिष्ट उद्देश्य होता है: कुछ नियंत्रक के पूरे जीवनकाल में एक बार कॉल होती हैं, अन्य — हर प्रकट होने या छिपने पर। विधियों के बीच तर्क मिलाने से दुर्लभ बग होते हैं: मेमोरी लीक, गलत डेटा अपडेट और अनावश्यक नेटवर्क अनुरोध।

UIViewController विधियों का पूर्ण चक्र

छह विधियाँ UIViewController का पूर्ण जीवन चक्र बनाती हैं। कॉल क्रम निश्चित है और नेविगेशन विधि पर निर्भर नहीं करता — push, present या unwind segue सभी एक ही कार्यक्रम का पालन करते हैं।

loadView — मूल View बनाना

loadView चक्र की पहली विधि है, जो तब कॉल होती है जब नियंत्रक की View अभी तक मौजूद नहीं है। यदि आप Storyboard का उपयोग करते हैं, तो UIKit स्वचालित रूप से xib फ़ाइल से View लोड करता है। प्रोग्रामेटिक रूप से इंटरफ़ेस बनाते समय, आप इस विधि को ओवरराइड करके मैन्युअल रूप से मूल View निर्दिष्ट करते हैं। अधिकांश प्रोजेक्ट्स में, loadView को नहीं छुआ जाता — काम viewDidLoad में किया जाता है।

loadView को ओवरराइड करना केवल विशिष्ट मामलों में आवश्यक है: जब पूरा इंटरफ़ेस Storyboard के बिना कोड में बनाया गया हो, या जब मूल View को गैर-मानक वर्ग का होना आवश्यक हो। Apple ओवरराइड करते समय super.loadView को न कॉल करने की सलाह देता है — आप View बनाने की पूरी जिम्मेदारी लेते हैं।

override func loadView() {
    view = UIView()
    view.backgroundColor = .white
}

viewDidLoad — एक बार की आरंभीकरण

viewDidLoad चक्र की सबसे अधिक उपयोग की जाने वाली विधि है। यह View के मेमोरी में लोड होने के बाद एक बार कॉल होती है, लेकिन अभी तक स्क्रीन पर प्रदर्शित नहीं होती। यहाँ subviews कॉन्फ़िगर किए जाते हैं, तालिकाएँ डेटा से भरी जाती हैं, कोशिकाएँ पंजीकृत की जाती हैं, और सूचनाओं की सदस्यता ली जाती है जो नियंत्रक के पूरे जीवनकाल तक चलती हैं।

एक महत्वपूर्ण विशेषता: स्क्रीन के फिर से दिखने पर viewDidLoad फिर से कॉल नहीं होता। यदि आपको हर बार स्क्रीन प्रकट होने पर डेटा अपडेट करने की आवश्यकता है — viewWillAppear का उपयोग करें। viewDidLoad में केवल एक बार के संचालन रखें जो मूल कॉन्फ़िगरेशन के लिए आवश्यक हों।

viewWillAppear — प्रदर्शन से पहले तैयारी

viewWillAppear हर बार View के उपयोगकर्ता को दिखाई देने से ठीक पहले कॉल होता है। यह विधि एक animated पैरामीटर प्राप्त करती है जो इंगित करता है कि प्रकटन एनिमेटेड है या नहीं। यहाँ डेटा अपडेट किया जाता है, तालिकाएँ रीलोड की जाती हैं, NavigationBar कॉन्फ़िगर किया जाता है, और एप्लिकेशन की स्थिति के अनुसार तत्वों को छिपाया या दिखाया जाता है।

स्क्रीन के बीच स्थिति सिंक्रनाइज़ेशन के लिए viewWillAppear का उपयोग करें: यदि उपयोगकर्ता पिछली स्क्रीन पर डेटा बदल सकता था, तो यह विधि इंटरफ़ेस अपडेट करने का सही स्थान है। viewWillAppear का प्रत्येक कॉल स्क्रीन प्रकटन से पहले होता है, चाइल्ड नियंत्रक से लौटने पर भी।

viewDidAppear — स्क्रीन पूरी तरह दिखाई देती है

viewDidAppear सूचित करता है कि View स्क्रीन पर पूरी तरह प्रकट हो गई है और सभी संक्रमण एनिमेशन पूरे हो गए हैं। इस बिंदु पर, स्क्रीन इंटरैक्शन के लिए तैयार है — उपयोगकर्ता पूरा इंटरफ़ेस देखता है और उसके साथ बातचीत कर सकता है। यह विधि उन एनिमेशन को शुरू करने के लिए उपयुक्त है जो प्रकटन के बाद शुरू होने चाहिए, टाइमर शुरू करने और एनालिटिक्स इंप्रेशन ट्रैक करने के लिए।

viewWillAppear के विपरीत, viewDidAppear गारंटी देता है कि स्क्रीन न केवल दिखाई दे रही है बल्कि पूरी तरह रेंडर भी हो चुकी है। यदि आप viewWillAppear में एनिमेशन शुरू करते हैं, तो कुछ फ्रेम छूट सकते हैं क्योंकि UIKit ने अभी तक संक्रमण पूरा नहीं किया है। स्मूथ एनिमेशन के लिए, viewDidAppear का उपयोग करें।

viewWillDisappear — छिपाने की तैयारी

viewWillDisappear स्क्रीन से View के छिपने से पहले कॉल होता है — किसी अन्य नियंत्रक पर जाने, मोडल विंडो बंद करने या ऐप को सस्पेंड करने पर। यह स्थिति सहेजने, सूचनाओं से सदस्यता रद्द करने, सक्रिय प्रक्रियाओं को रोकने और उन संसाधनों को मुक्त करने का सही स्थान है जिनकी स्क्रीन के दिखाई न होने पर आवश्यकता नहीं है।

याद रखना महत्वपूर्ण है: viewWillDisappear गारंटी नहीं देता कि View अंततः छिप जाएगी — इशारा रद्द किया जा सकता है। इसलिए, महत्वपूर्ण डेटा को viewDidDisappear में भी सहेजें, जो वास्तविक छिपने के बाद ही कॉल होती है।

viewDidDisappear — स्क्रीन छिपी हुई है

viewDidDisappear प्रकटन और छिपने के चक्र को पूरा करती है। यह View के स्क्रीन से छिप जाने के बाद कॉल होती है। इस विधि में, एनिमेशन अंततः रोके जाते हैं, अस्थायी ऑब्जेक्ट हटाए जाते हैं, और viewWillDisappear में शुरू किया गया डेटा सहेजना पुष्टि किया जाता है।

यह विधि नियंत्रक के deinit से पहले भी आती है — यदि आपका UIViewController नष्ट हो रहा है, तो deinit कॉल होने से पहले viewDidDisappear Lifecycle की अंतिम विधि होगी। इसका उपयोग ऑब्जेक्ट के नष्ट होने से पहले अंतिम सफाई के लिए करें।

प्रत्येक विधि कब कॉल होती है

कॉल का क्रम इस बात पर निर्भर करता है कि स्क्रीन कैसे प्रकट होती है: पहली बार, वापस जाने पर, या मोडली प्रस्तुत करने पर। आइए UIKit के परिप्रेक्ष्य से तीन मुख्य परिदृश्यों पर विचार करें।

पहली बार खोलने पर क्रम

जब स्क्रीन पहली बार प्रकट होती है, UIKit पूर्ण निर्माण चक्र से गुज़रता है: loadView कॉल होता है, फिर viewDidLoad, जिसके बाद प्रकटन एनिमेशन शुरू होता है। एनिमेशन के दौरान, viewWillAppear कॉल होता है, और पूरा होने के बाद — viewDidAppear। यह एकमात्र परिदृश्य है जहाँ loadView से viewDidAppear तक सभी विधियाँ क्रमिक रूप से सक्रिय होती हैं।

override func viewDidLoad() {
    super.viewDidLoad()
    print("viewDidLoad — View मेमोरी में लोड हुआ")
}

override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)
    print("viewWillAppear — जल्द ही दिखाई देगा")
}

override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)
    print("viewDidAppear — स्क्रीन पूरी तरह दिखाई दे रही है")
}

वापस जाने पर क्रम

जब उपयोगकर्ता पिछली स्क्रीन पर वापस जाता है, UIKit फिर से viewDidLoad कॉल नहीं करता — View पहले से मेमोरी में लोड है। इसके बजाय, वापस लौटने वाली स्क्रीन पर केवल viewWillAppear और viewDidAppear कॉल होते हैं, और वर्तमान स्क्रीन पर — viewWillDisappear और viewDidDisappear। loadView और viewDidLoad को छोड़ दिया जाता है क्योंकि स्क्रीन पहले से नेविगेशन स्टैक में मौजूद है।

Present और Dismiss के विशेष मामले

मोडल प्रस्तुति समान नियमों का पालन करती है: नया नियंत्रक पहली प्रस्तुति पर पूर्ण चक्र से गुज़रता है, जबकि वर्तमान को viewWillDisappear और viewDidDisappear प्राप्त होते हैं। Dismiss पर, क्रम उल्टा हो जाता है: लौटने वाले नियंत्रक को फिर से viewWillAppear और viewDidAppear मिलते हैं, जबकि हटाए गए को अंतिम विधियाँ मिलती हैं। यह व्यवहार UIKit में सभी संक्रमण प्रकारों के लिए एकसमान है।

व्यावहारिक उपयोग परिदृश्य

आइए चार प्रमुख परिदृश्यों को देखें जहाँ Lifecycle को समझना सीधे कोड गुणवत्ता और उपयोगकर्ता अनुभव को प्रभावित करता है। प्रत्येक परिदृश्य के लिए, हम सिफारिशों के साथ एक उदाहरण प्रदान करते हैं।

viewDidLoad में डेटा आरंभीकरण

viewDidLoad प्रारंभिक सेटअप के लिए स्थान है जो स्क्रीन दृश्यता पर निर्भर नहीं करता। यहाँ collectionView कॉन्फ़िगर किया जाता है, कोशिकाओं के लिए nib फ़ाइलें पंजीकृत की जाती हैं, डेटा स्रोत और लेआउट बनाए जाते हैं। यदि आप नेटवर्क से डेटा लोड कर रहे हैं, तो viewDidLoad में केवल अनुरोध शुरू करना बेहतर है, और UI को viewWillAppear में अपडेट करें जब स्क्रीन प्रदर्शन के लिए तैयार हो।

override func viewDidLoad() {
    super.viewDidLoad()
    tableView.register(
        MyCell.self,
        forCellReuseIdentifier: MyCell.identifier
    )
    viewModel.loadInitialData()
}

viewWillAppear में सामग्री अपडेट

हर बार स्क्रीन प्रकट होने पर डेटा सिंक्रनाइज़ेशन के लिए viewWillAppear का उपयोग करें। उदाहरण के लिए, यदि उपयोगकर्ता पिछली स्क्रीन पर सेटिंग्स बदल सकता था, तो यहाँ प्रदर्शित मान अपडेट किए जाते हैं, तालिका रीलोड की जाती है, और NavigationBar स्थिति समायोजित की जाती है। यह गारंटी देता है कि स्क्रीन किसी भी नेविगेशन परिदृश्य में हमेशा अद्यतित डेटा दिखाती है।

override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)
    tableView.reloadData()
    navigationController?.setNavigationBarHidden(false, animated: animated)
}

viewDidAppear में एनालिटिक्स और एनिमेशन

viewDidAppear उन एनिमेशन को शुरू करने के लिए आदर्श है जो उपयोगकर्ता द्वारा स्क्रीन देखने के बाद शुरू होने चाहिए। यहाँ आप एनालिटिक्स इवेंट भी भेजते हैं: स्क्रीन व्यू, ऑनबोर्डिंग प्रारंभ, या वीडियो प्लेबैक शुरू करना। संक्रमण पूरा होने से पहले एनिमेशन शुरू करने से अटकी हुई इंटरफ़ेस होती है — UIKit के पास पर्याप्त फ्रेम तैयार करने का समय नहीं होता।

viewWillDisappear में स्थिति सहेजना

viewWillDisappear में, ड्राफ्ट सहेजे जाते हैं, टाइमर रोके जाते हैं, और NotificationCenter से सदस्यता रद्द की जाती है। यह अंतिम क्षण है जब स्क्रीन अभी भी दिखाई दे रही है और उपयोगकर्ता संदर्भ की आवश्यकता वाले संचालन के लिए सुलभ है। महत्वपूर्ण डेटा के लिए, रद्द किए गए इशारों से सुरक्षा के रूप में अतिरिक्त रूप से viewDidDisappear का उपयोग करें।

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

जीवन चक्र विधियों का गलत उपयोग iOS ऐप्स में बग के सबसे सामान्य स्रोतों में से एक है। आइए UIViewController के साथ काम करने के विभिन्न चरणों में डेवलपर्स द्वारा की जाने वाली मुख्य गलतियों को देखें।

पहली गलती — Storyboard का उपयोग करते समय init या loadView में subviews बनाना। यदि आप Interface Builder का उपयोग कर रहे हैं, तो बिना आवश्यकता के loadView को ओवरराइड न करें। Storyboard होने पर loadView में View बनाने से xib फ़ाइल अनदेखी होती है और खाली स्क्रीन मिलती है।

दूसरी गलती — बिना सदस्यता रद्द किए viewDidLoad में कीबोर्ड सूचनाओं की सदस्यता लेना। यदि आपने UIResponder.keyboardWillShowNotification की सदस्यता ली लेकिन स्क्रीन छिपने पर सदस्यता रद्द नहीं की, तो ब्लॉक नियंत्रक के deinit के बाद भी कॉल होता रहेगा — यह मेमोरी लीक है जिसमें ऐप क्रैश होने की संभावना है।

तीसरी गलती — स्क्रीन प्रकट होने से पहले शुरू किए गए टाइमर और नेटवर्क अनुरोध। जब View अभी तक दिखाई नहीं दे रही है तब इमेज लोड करना या एनिमेशन करना संसाधनों की बर्बादी है। विज़ुअल अपडेट को viewWillAppear या viewDidAppear में ले जाएँ।

चौथी गलती — केवल viewWillDisappear में डेटा सहेजना। इंटरैक्टिव पॉप इशारे के साथ, उपयोगकर्ता स्वाइप शुरू कर सकता है और इसे रद्द कर सकता है — विधि कॉल हुई लेकिन स्क्रीन छिपी नहीं। महत्वपूर्ण सहेजने को viewDidDisappear या applicationDidEnterBackground हैंडलर में डुप्लिकेट करें।