Android Kotlin की बुनियादी बातें 04.2: लाइफ़साइकल की मुश्किल स्थितियां

यह कोडलैब Android Kotlin के बुनियादी कोर्स में शामिल है. अगर आप कोडलैब के क्रम में काम करते हैं, तो आपको इस कोर्स का ज़्यादा से ज़्यादा फ़ायदा मिलेगा. सभी कोर्स कोडलैब Android Kotlin से जुड़े बेसिक कोडलैब के लैंडिंग पेज पर दिए गए हैं.

शुरुआती जानकारी

पिछले कोडलैब में, आपने Activity और Fragment के लाइफ़साइकल के बारे में जाना. साथ ही, उन तरीकों के बारे में भी जाना जिन्हें लाइफ़साइकल की स्थिति, फ़्रैगमेंट और गतिविधियों में बदलाव होने पर कॉल किया जाता है. इस कोडलैब में आप गतिविधि की लाइफ़साइकल के बारे में बेहतर तरीके से जान सकते हैं. आप Android Jetpack' की लाइफ़साइकल लाइब्रेरी के बारे में भी जानते हैं. इसकी मदद से, आप लाइफ़साइकल इवेंट को उस कोड से मैनेज कर सकते हैं जो #39; बेहतर तरीके से व्यवस्थित किया गया है और बनाए रखने में आसान है.

आपको पहले से क्या पता होना चाहिए

• कोई गतिविधि क्या होती है और इसे अपने ऐप्लिकेशन में कैसे बनाया जाए.
• Activity और Fragment लाइफ़साइकल की बुनियादी बातें. साथ ही, किसी गतिविधि के अलग-अलग स्टेटस के बीच शुरू होने वाले कॉलबैक.
• ऐक्टिविटी या फ़्रैगमेंट लाइफ़साइकल में अलग-अलग समय पर कार्रवाइयां करने के लिए, onCreate() और onStop() लाइफ़साइकल कॉलबैक मैथड को कैसे बदलें.

आप क्या #39;जानेंगे

• लाइफ़साइकल कॉलबैक में, अपने ऐप्लिकेशन के हिस्सों को सेट अप, शुरू, और बंद करने का तरीका.
• लाइफ़साइकल ऑब्ज़र्वर बनाने और ऐक्टिविटी और फ़्रैगमेंट लाइफ़साइकल को आसानी से मैनेज करने के लिए, Android लाइफ़साइकल लाइब्रेरी का इस्तेमाल कैसे करें.
• Android ऐप्लिकेशन के बंद होने की वजह से आपके ऐप्लिकेशन के डेटा पर क्या असर होता है. साथ ही, Android का ऐप्लिकेशन बंद होने पर, इस डेटा के सेव होने और उसे वापस लाने का तरीका भी बताया गया है.
• डिवाइस को घुमाने और कॉन्फ़िगरेशन के अन्य बदलावों की वजह से, लाइफ़साइकल की स्थिति में क्या बदलाव होता है. यह आपके ऐप्लिकेशन की स्थिति पर कैसे असर डालता है.

आप क्या कर सकते हैं

• टाइमर फ़ंक्शन को शामिल करने के लिए, DesertClicker ऐप्लिकेशन में बदलाव करें. इसके बाद, गतिविधि की लाइफ़साइकल में कई बार उस टाइमर को चालू या बंद करें.
• Android लाइफ़साइकल लाइब्रेरी का इस्तेमाल करने के लिए, ऐप्लिकेशन में बदलाव करें और DessertTimer क्लास को लाइफ़साइकल ऑब्ज़र्वर में बदलें.
• अपने ऐप्लिकेशन को बंद करने और लाइफ़साइकल कॉलबैक की प्रोसेस करने के लिए, Android डीबग ब्रिज (adb) का इस्तेमाल करें और उसका इस्तेमाल करें.
• onSaveInstanceState() का तरीका लागू करके, ऐप्लिकेशन के ऐसे डेटा को बनाए रखें जो अचानक बंद हो जाने पर ऐप्लिकेशन का डेटा खो सकता है. ऐप्लिकेशन के फिर से शुरू होने पर डेटा को बहाल करने के लिए कोड जोड़ें.

इस कोडलैब में आप पिछले कोडलैब से DessttClicker ऐप्लिकेशन को बड़ा करते हैं. आप बैकग्राउंड में टाइमर सेट करते हैं. इसके बाद, Android लाइफ़साइकल लाइब्रेरी का इस्तेमाल करने के लिए, ऐप्लिकेशन को बदलें.

पिछले कोडलैब में, आप लाइफ़साइकल के अलग-अलग कॉलबैक को बदलकर, गतिविधि और फ़्रैगमेंट के लाइफ़साइकल की निगरानी करने का तरीका सीख चुके हैं. साथ ही, जब सिस्टम उन कॉलबैक को शुरू करता है, तब लॉग इन करते हैं. इस टास्क में, आपको DesertClicker ऐप्लिकेशन में लाइफ़साइकल टास्क को मैनेज करने का एक ज़्यादा मुश्किल उदाहरण मिलता है. आप एक ऐसे टाइमर का इस्तेमाल करते हैं जो हर सेकंड लॉग स्टेटमेंट को प्रिंट करता है और इसे सेकंड तक चला जाता है.

पहला चरण: डिज़र्ट टाइमर सेट अप करना

1. आखिरी कोडलैब (कोड बनाना सीखना) से DesertClicker ऐप्लिकेशन खोलें. (अगर आपके पास ऐप्लिकेशन नहीं है, तो आप DssertClickerLogs यहां डाउनलोड कर सकते हैं.)
2. प्रोजेक्ट व्यू में, javag > com.example.android.डेज़र्टclicker को बड़ा करें और DessertTimer.kt खोलें. ध्यान दें कि इस समय सभी कोड पर टिप्पणी की जाती है. इसलिए, यह ऐप्लिकेशन के हिस्से के तौर पर नहीं चलता.
3. एडिटर विंडो में सभी कोड चुनें. कोड > लाइन टिप्पणी के साथ टिप्पणी चुनें या Control+/ (Mac पर Command+/) दबाएं. इस निर्देश से फ़ाइल के सभी कोड हट जाते हैं. (जब तक आप ऐप्लिकेशन को फिर से नहीं बनाते, तब तक Android Studio में ऐसी गड़बड़ियां दिखाई दे सकती हैं जिन्हें ठीक नहीं किया गया है.)
4. ध्यान दें कि DessertTimer क्लास में startTimer() और stopTimer() शामिल होते हैं, जो टाइमर को शुरू और बंद करते हैं. जब startTimer() चल रहा होता है, तब टाइमर हर सेकंड में लॉग मैसेज प्रिंट करता है. इस दौरान, सेकंड के कुल समय की जानकारी भी मौजूद होती है. ऐसा करने से, stopTimer() तरीका टाइमर और लॉग स्टेटमेंट को रोक देता है.
   

ध्यान दें: DessertTimer क्लास, टाइमर के लिए, बैकग्राउंड थ्रेड का इस्तेमाल करती है. इस थ्रेड में, Runnable और Handler क्लास जुड़ी होती हैं. आपको इस कोडलैब के लिए इन चीज़ों के बारे में जानने की ज़रूरत नहीं है (हालांकि, बाद के कोडलैब में थ्रेड के बारे में ज़्यादा जानें). अगर आपको इसमें दिलचस्पी है, तो ज़्यादा जानकारी के लिए प्रोसेस और थ्रेड देखें.

5. MainActivity.kt खोलें. क्लास के सबसे ऊपर, dessertsSold वैरिएबल के ठीक नीचे, टाइमर के लिए वैरिएबल जोड़ें:
   

private lateinit var dessertTimer : DessertTimer;

6. setOnClickListener() तक कॉल करने के तुरंत बाद, नीचे की ओर स्क्रोल करके onCreate() नया DessertTimer ऑब्जेक्ट बनाएं:

dessertTimer = DessertTimer()

अब जब आपके पास मिठाई के टाइमर की सुविधा है, तो इस बात का ध्यान रखें कि आप टाइमर को कहां से शुरू करें और बंद करें, ताकि इस गतिविधि के स्क्रीन पर दिखने पर, सिर्फ़ चल सके. अगले चरणों में आप कुछ विकल्पों को देखते हैं.

दूसरा चरण: टाइमर शुरू और बंद करना

onStart() मेथड को कॉल करने से ठीक पहले कॉल किया जाता है. गतिविधि के दिखना बंद होने पर, onStop() तरीके को कॉल किया जाता है. ये कॉलबैक, टाइमर को शुरू और बंद करने के लिए सही उम्मीदवार लगते हैं.

1. MainActivity क्लास में, onStart() कॉलबैक में टाइमर शुरू करें:
   

override fun onStart() {
   super.onStart()
   dessertTimer.startTimer()

   Timber.i("onStart called")
}

2. onStop() में टाइमर बंद करें:
   

override fun onStop() {
   super.onStop()
   dessertTimer.stopTimer()

   Timber.i("onStop Called")
}

3. ऐप्लिकेशन को कंपाइल करें और चलाएं. Android Studio में, लॉगकैट पैनल पर क्लिक करें. लॉगकैट खोज बॉक्स में, dessertclicker डालें. यह MainActivity और DessertTimer, दोनों क्लास के हिसाब से फ़िल्टर होगा. ध्यान दें कि ऐप्लिकेशन शुरू होते ही, टाइमर भी तुरंत चालू हो जाता है.
   
4. वापस जाएं बटन पर क्लिक करें और देखें कि टाइमर फिर से रुक जाता है. टाइमर बंद हो जाता है, क्योंकि गतिविधि और कंट्रोल किए गए टाइमर, दोनों बंद कर दिए जाते हैं.
5. ऐप्लिकेशन पर वापस जाने के लिए हाल ही की स्क्रीन का इस्तेमाल करें. लॉगकैट में देखें कि टाइमर 0 से रीस्टार्ट होता है.
6. शेयर करें बटन पर क्लिक करें. लॉगकैट में देखें कि टाइमर अब भी चल रहा है.
   
   
7. होम बटन पर क्लिक करें. लॉगकैट में देखें कि टाइमर चालू नहीं हो रहा है.
8. ऐप्लिकेशन पर वापस लौटने के लिए हाल ही की स्क्रीन का इस्तेमाल करें. लॉगकैट में देखें कि टाइमर वहीं से शुरू हो जहां वह छोड़ा गया था.
9. MainActivity में, onStop() वाले तरीके में, stopTimer() को किए गए कॉल के बारे में टिप्पणी करें. stopTimer() पर टिप्पणी करने से यह पता चलता है कि आप onStart() में कार्रवाई कहां से शुरू करते हैं, लेकिन उसे onStop() में फिर से रोकना न भूलें.
10. ऐप्लिकेशन को कंपाइल करें और चलाएं. साथ ही, टाइमर शुरू होने के बाद होम बटन पर क्लिक करें. ऐप्लिकेशन के बैकग्राउंड में होने के बावजूद, टाइमर चल रहा है और सिस्टम के संसाधनों का लगातार इस्तेमाल कर रहा है. टाइमर को चालू रखने से आपके ऐप्लिकेशन के लिए मेमोरी लीक होती है. शायद आप ऐसा व्यवहार न कर पाएं जो आप चाहते हैं.
    
    सामान्य पैटर्न यह है कि जब आप कॉलबैक में कुछ सेट अप या शुरू करते हैं, तो आप उस कॉलबैक में जाकर उस चीज़ को रोक या हटा सकते हैं. इस तरह, जब आपको इसकी ज़रूरत न हो, तो इसे चलाने से बचें.

ध्यान दें: कुछ मामलों में, जैसे कि संगीत चलाना, आप वीडियो को चालू रखना चाहते हैं. किसी चीज़ को चालू रखने के सही और कारगर तरीके हैं, लेकिन वे इस लेसन के दायरे से बाहर हैं.

11. onStop() में लाइन को बंद करें, जहां आप टाइमर बंद करते हैं.
12. startTimer() के कॉल को काटकर, onStart() से onCreate() में चिपकाएं. इस बदलाव से पता चलता है कि onCreate() में onCreate() को शुरू करने और उसे चालू करने के बजाय, onCreate() में संसाधन को शुरू और चालू करते हैं या नहीं.
13. ऐप्लिकेशन को कंपाइल करें और चलाएं. ध्यान दें कि टाइमर ठीक वैसा ही चल रहा है जैसा आप चाहते हैं.
14. ऐप्लिकेशन बंद करने के लिए, 'होम' पर क्लिक करें. टाइमर वैसा ही चलना बंद कर देगा जैसा आप चाहते हैं.
15. ऐप्लिकेशन पर वापस लौटने के लिए हाल ही की स्क्रीन का इस्तेमाल करें. ध्यान दें कि इस स्थिति में टाइमर फिर से नहीं शुरू होता है, क्योंकि onCreate() सिर्फ़ तब शुरू होता है, जब ऐप्लिकेशन शुरू होता है—यह तब कॉल नहीं किया जाता, जब ऐप्लिकेशन फ़ोरग्राउंड में वापस आता है.

याद रखने वाली ज़रूरी बातें:

• जब आप किसी लाइफ़साइकल कॉलबैक में किसी संसाधन को सेट अप करते हैं, तो संसाधन को नीचे की ओर भी फाड़ दें.
• संबंधित तरीकों से सेट अप और टर्डडाउन करें.
• अगर आप onStart() में कोई चीज़ सेट अप करते हैं, तो onStop() में उसे बंद करें या फिर से चालू करें.
  
  

डिज़र्टक्लिकर ऐप्लिकेशन में, यह देखना काफ़ी आसान है कि अगर आपने onStart() में टाइमर शुरू किया था, तो आपको onStop() में टाइमर को बंद करना होगा. यह सिर्फ़ एक टाइमर है, इसलिए टाइमर को याद रखना मुश्किल नहीं है.

Android के ज़्यादा मुश्किल ऐप्लिकेशन में, आप onStart() या onCreate() में कई चीज़ें सेट अप कर सकते हैं. इसके बाद, आप उन्हें onStop() या onDestroy() में मिटा सकते हैं. उदाहरण के लिए, आपके पास ऐनिमेशन, संगीत, सेंसर या टाइमर हो सकते हैं, जिन्हें सेट अप करके नीचे लाने के लिए, उन्हें चालू और बंद करना ज़रूरी है. अगर आप एक भूल जाते हैं, तो इससे बग और सिरदर्द हो जाते हैं.

लाइफ़साइकल लाइब्रेरी, जो Android Jetpack का हिस्सा है, इस टास्क को आसान बना देती है. लाइब्रेरी खास तौर पर उन मामलों में काम की होती है जहां आपको कई हिलने-डुलने वाले हिस्सों को ट्रैक करना पड़ता है. इनमें से कुछ हिस्से अलग-अलग लाइफ़साइकल स्थितियों में हैं. लाइब्रेरी, लाइफ़साइकल के काम करने के तरीके में फ़्लिप होती है: आम तौर पर, ऐक्टिविटी या फ़्रैगमेंट एक कॉम्पोनेंट (जैसे, DessertTimer) को बताते हैं कि लाइफ़साइकल कॉलबैक होने पर क्या करना चाहिए. हालांकि, जब आप लाइफ़साइकल लाइब्रेरी का इस्तेमाल करते हैं, तो कॉम्पोनेंट खुद लाइफ़साइकल के बदलावों पर नज़र रखता है. इसके बाद, जब ये बदलाव होते हैं, तो कॉम्पोनेंट क्या करता है इसकी ज़रूरत होती है.

लाइफ़साइकल लाइब्रेरी के तीन मुख्य हिस्से हैं:

• लाइफ़साइकल के मालिक, वे कॉम्पोनेंट होते हैं जिनके पास लाइफ़साइकल होता है. Activity और Fragment लाइफ़साइकल के मालिक हैं. लाइफ़साइकल के मालिक, LifecycleOwner इंटरफ़ेस को लागू करते हैं.
• Lifecycle क्लास, जिसमें लाइफ़साइकल के मालिक का असल स्टेटस होता है. यह लाइफ़साइकल में बदलाव होने पर इवेंट को ट्रिगर करती है.
• लाइफ़साइकल ऑब्ज़र्वर, जो लाइफ़साइकल की स्थिति पर नज़र रखते हैं और लाइफ़साइकल बदलने पर टास्क करते हैं. लाइफ़साइकल ऑब्ज़र्वर LifecycleObserver इंटरफ़ेस को लागू करते हैं.

इस टास्क में, आप DessttClicker ऐप्लिकेशन को Android की लाइफ़साइकल लाइब्रेरी का इस्तेमाल करने के लिए बदल देते हैं. साथ ही, आप यह भी जान सकते हैं कि लाइब्रेरी, Android गतिविधि और फ़्रैगमेंट लाइफ़साइकल के साथ कैसे काम करती है.

पहला चरण: डिज़र्टटाइमर को लाइफ़साइकल ऑब्ज़र्वर में बदलना

लाइफ़साइकल लाइब्रेरी का एक अहम हिस्सा लाइफ़साइकल ऑब्ज़र्वेशन है. निगरानी की सुविधा, क्लास (जैसे कि DessertTimer) को गतिविधि या फ़्रैगमेंट लाइफ़साइकल के बारे में जानने की सुविधा देती है. साथ ही, यह लाइफ़साइकल की स्थिति में हुए बदलावों की वजह से खुद को शुरू या बंद करती है. लाइफ़साइकल ऑब्ज़र्वर के साथ, ऐक्टिविटी और फ़्रैगमेंट मेथड से ऑब्जेक्ट को शुरू और रोकने की ज़िम्मेदारी हटाई जा सकती है.

1. DesertTimer.kt कक्षा खोलें.
2. DessertTimer क्लास का क्लास सिग्नेचर बदलें, ताकि यह कुछ ऐसा दिखे:
   

class DessertTimer(lifecycle: Lifecycle) : LifecycleObserver {

इस नई क्लास की परिभाषा दो काम करती है:

• कंस्ट्रक्टर, Lifecycle ऑब्जेक्ट को लेता है, जो कि लाइफ़साइकल है जिसे टाइमर देख रहा है.
• क्लास की परिभाषा में LifecycleObserver इंटरफ़ेस लागू होता है.

3. runnable वैरिएबल के नीचे, क्लास की परिभाषा में init ब्लॉक जोड़ें. init ब्लॉक में, मालिक (गतिविधि) से पास की गई लाइफ़साइकल ऑब्जेक्ट को इस क्लास (ऑब्ज़र्वर) से कनेक्ट करने के लिए, addObserver() तरीके का इस्तेमाल करें.
   

 init {
   lifecycle.addObserver(this)
}

4. startTimer() के साथ @OnLifecycleEvent annotation की व्याख्या करें और ON_START लाइफ़साइकल इवेंट का इस्तेमाल करें. लाइफ़साइकल पर निगरानी करने वाले सभी इवेंट, Lifecycle.Event क्लास में देखे जा सकते हैं.

@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun startTimer() {

5. ON_STOP इवेंट का इस्तेमाल करके, stopTimer() के लिए वही काम करें:

@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun stopTimer()

दूसरा चरण: MainActivity में बदलाव करना

MainActivity की आपकी क्लास, इनहेरिटेंस के ज़रिए पहले से ही लाइफ़साइकल के मालिक हैं, क्योंकि FragmentActivity सुपर क्लास LifecycleOwner लागू करती है. इसलिए, अपनी गतिविधि की लाइफ़साइकल के बारे में बताने के लिए, आपको कुछ नहीं करना है. आपको बस एक गतिविधि और #39; का लाइफ़साइकल ऑब्जेक्ट DessertTimer कंस्ट्रक्टर में पास करना है.

1. MainActivity खोलें. onCreate() वाले तरीके में, DessertTimer को शुरू करने के तरीके में बदलाव करें, ताकि this.lifecycle शामिल किया जा सके:

dessertTimer = DessertTimer(this.lifecycle)

गतिविधि की lifecycle प्रॉपर्टी में, इस गतिविधि के Lifecycle ऑब्जेक्ट को रखा गया है.

2. onCreate() में मौजूद startTimer() कॉल और onStop() में stopTimer() नंबर पर किया गया कॉल हटाएं. आपको DessertTimer को यह बताने की ज़रूरत नहीं है कि अब गतिविधि में क्या करना है, क्योंकि DessertTimer अब लाइफ़साइकल के बारे में पता लगा रहा है. लाइफ़साइकल की स्थिति बदलने पर, उसे अपने-आप सूचना दी जाती है. इन कॉलबैक में आपको बस एक मैसेज लॉग होता है.
3. ऐप्लिकेशन को कंपाइल करें और चलाएं. साथ ही, लॉगकैट खोलें. ध्यान दें कि टाइमर उम्मीद के मुताबिक चलना शुरू हो गया है.
4. ऐप्लिकेशन को बैकग्राउंड में लाने के लिए होम बटन पर क्लिक करें. ध्यान दें कि टाइमर उम्मीद के मुताबिक चलना बंद हो गया है.

अगर Android, ऐप्लिकेशन के बैकग्राउंड में रहने के दौरान उसे बंद कर देता है, तो आपके ऐप्लिकेशन और उसके डेटा का क्या होता है? यह मुश्किल एज केस को समझना ज़रूरी है.

जब आपका ऐप्लिकेशन बैकग्राउंड में जाता है, तो वह खत्म हो जाता है. तब तक यह रुक जाता है और तब तक उपयोगकर्ता के वापस आने का इंतज़ार नहीं करता. हालांकि, Android OS की #_एक समस्या यह है कि हम फ़ोरग्राउंड में होने वाली गतिविधियों को आसानी से पूरे कर रहे हैं. उदाहरण के लिए, अगर आपका उपयोगकर्ता बस पकड़ने में उनकी मदद करने के लिए जीपीएस ऐप्लिकेशन का इस्तेमाल कर रहा है, तो यह ज़रूरी है कि उस जीपीएस ऐप्लिकेशन को जल्दी से रेंडर करें और निर्देश दिखाते रहें. यह DessertClicker ऐप्लिकेशन को बनाए रखना ज़रूरी नहीं है. हो सकता है कि उपयोगकर्ता ने कुछ दिनों तक डिवाइस को न देखा हो. इस वजह से यह बैकग्राउंड में ठीक से चलता है.

Android, बैकग्राउंड ऐप्लिकेशन को कंट्रोल करता है, ताकि फ़ोरग्राउंड ऐप्लिकेशन बिना किसी समस्या के चल सके. उदाहरण के लिए, Android, बैकग्राउंड में चल रहे ऐप्लिकेशन की प्रोसेसिंग की संख्या को सीमित कर देता है.

कभी-कभी Android एक ऐसी पूरी ऐप्लिकेशन प्रोसेस को भी शट डाउन करता है जिसमें ऐप्लिकेशन से जुड़ी हर गतिविधि शामिल होती है. Android इस तरह की रोक तब लगाता है, जब सिस्टम पर दबाव पड़ता है और वह धीरे दिखने लगता है. इसलिए, इस समय कोई अतिरिक्त कॉलबैक या कोड नहीं चलता है. आपके ऐप्लिकेशन की प्रोसेस बैकग्राउंड में आसानी से बंद हो जाती है, बिना आवाज़ के. हालांकि, उपयोगकर्ता को ऐसा लगता है कि ऐप्लिकेशन बंद कर दिया गया है. जब उपयोगकर्ता किसी ऐसे ऐप्लिकेशन पर वापस नेविगेट करता है जो Android OS बंद हो गया था, तो Android उस ऐप्लिकेशन को रीस्टार्ट करता है.

इस टास्क में, आप Android प्रोसेस को बंद करने का सिम्युलेट करते हैं और जांच करते हैं कि जब आपका ऐप्लिकेशन फिर से शुरू होता है, तो क्या होता है.

ध्यान दें: शुरू करने से पहले, पक्का करें कि आप एम्युलेटर या डिवाइस पर एपीआई 28 या उसके बाद के वर्शन का इस्तेमाल करते हैं.

पहला चरण: प्रोसेस बंद होने के बारे में बताने के लिए adb का इस्तेमाल करना

Android डीबग ब्रिज (adb) एक कमांड-लाइन टूल है. इसकी मदद से, आप अपने कंप्यूटर से जुड़े एम्युलेटर और डिवाइसों को निर्देश भेज सकते हैं. इस चरण में आप adb का इस्तेमाल करके, अपने ऐप्लिकेशन की प्रोसेस बंद कर देते हैं. साथ ही, यह भी देखते हैं कि Android का आपके ऐप्लिकेशन को बंद करने पर क्या होता है.

1. अपना ऐप्लिकेशन कंपाइल करें और चलाएं. कपकेक को कुछ बार क्लिक करें.
2. अपने ऐप्लिकेशन को बैकग्राउंड में रखने के लिए, होम बटन दबाएं. अब आपका ऐप्लिकेशन बंद कर दिया गया है. अगर Android को ऐप्लिकेशन के इस्तेमाल के लिए ज़रूरी संसाधनों की ज़रूरत है, तो आपके ऐप्लिकेशन को बंद किया जा सकता है.
3. Android Studio में, कमांड-लाइन टर्मिनल खोलने के लिए, टर्मिनल टैब पर क्लिक करें.
4. adb टाइप करें और 'वापस जाएं' बटन दबाएं.
   
   अगर आपको बहुत ज़्यादा आउटपुट मिलता है, जो Android Debug Bridge version X.XX.X से शुरू होता है और उसके बाद tags to be used by logcat (see logcat —help पर खत्म होता है, तो सब कुछ ठीक है. अगर आपको इसके बजाय adb: command not found दिखता है, तो पक्का करें कि adb कमांड, एक्ज़ीक्यूशन पाथ में उपलब्ध हो. निर्देशों के लिए, उपयोगिताएं चैप्टर में जाकर और &कोटेशन जोड़ें, उसे अपने एक्ज़ीक्यूशन पाथ में जोड़ें.
5. इस टिप्पणी को कॉपी करके कमांड लाइन में चिपकाएं और 'वापस जाएं' बटन दबाएं:
   

adb shell am kill com.example.android.dessertclicker

यह निर्देश, कनेक्ट किए गए सभी डिवाइस या एम्युलेटर को dessertclicker पैकेज के नाम से प्रोसेस बंद करने के लिए कहता है. हालांकि, ऐसा सिर्फ़ तब होता है, जब ऐप्लिकेशन बैकग्राउंड में हो. आपका ऐप्लिकेशन बैकग्राउंड में चल रहा था, इसलिए डिवाइस या एम्युलेटर स्क्रीन पर यह नहीं बताया जा रहा कि आपका प्रोसेस रोक दिया गया है. Android Studio में, चलाएं टैब पर क्लिक करके वह मैसेज देखें जिसमें &कोटेशन को खत्म किया गया है. लॉगकैट टैब पर क्लिक करके देखें कि onDestroy() कॉलबैक को कभी चलाया नहीं गया था—आपकी गतिविधि बस खत्म हो गई है.

6. ऐप्लिकेशन पर वापस जाने के लिए हाल ही की स्क्रीन का इस्तेमाल करें. आपका ऐप्लिकेशन हाल ही के नतीजों में दिखता है, भले ही उसे बैकग्राउंड में रखा गया हो या पूरी तरह से बंद कर दिया गया हो. जब आप ऐप्लिकेशन पर वापस जाने के लिए हाल की स्क्रीन का इस्तेमाल करते हैं, तो गतिविधि फिर से शुरू हो जाती है. यह गतिविधि, स्टार्टअप लाइफ़साइकल कॉलबैक के पूरे सेट से होकर गुज़रती है, जिसमें onCreate() भी शामिल है.
7. ध्यान दें कि जब ऐप्लिकेशन रीस्टार्ट होता है, तब यह आपके "score&कोटेशन; (बेचे गए मिठाई की संख्या और कुल डॉलर, दोनों) को डिफ़ॉल्ट वैल्यू (0) पर रीसेट कर देता है. अगर Android आपके ऐप्लिकेशन को बंद कर देता है, तो क्यों यह आपकी स्थिति सेव नहीं करता?
   
   जब ओएस आपके लिए ऐप्लिकेशन को रीस्टार्ट करता है, तो Android उस ऐप्लिकेशन को उस स्थिति में रीसेट करने की पूरी कोशिश करता है जिसमें वह पहले था. जब आप गतिविधि से बाहर जाते हैं, तो Android आपके कुछ व्यू की स्थिति को एक बंडल में सेव कर लेता है और उसे एक बंडल में सेव कर लेता है. डेटा के कुछ उदाहरण जो ##39 अपने-आप सेव होते हैं, वे TextText में होते हैं (जब तक कि उनका लेआउट में आईडी सेट हो) और आपकी गतिविधि का पिछली ऐक्टिविटी.
   
   हालांकि, कभी-कभी Android OS आपके पूरे डेटा के बारे में नहीं जान पाता.#39; उदाहरण के लिए, अगर आपके पास DessertClicker ऐप्लिकेशन में revenue जैसा कस्टम वैरिएबल है, तो Android OS को इस डेटा या आपकी गतिविधि की अहमियत के बारे में पता नहीं चलता. आपको इस डेटा को बंडल में खुद जोड़ना होगा.

दूसरा चरण: बंडल डेटा सेव करने के लिए onSaveInstanceState() का इस्तेमाल करना

onSaveInstanceState() तरीका वह कॉलबैक है जिसका इस्तेमाल आप ऐसे डेटा को सेव करने के लिए करते हैं जिसकी ज़रूरत Android ओएस के आपके ऐप्लिकेशन को खत्म करने पर होती है. लाइफ़साइकल कॉलबैक डायग्राम में, गतिविधि के बंद होने के बाद, onSaveInstanceState() को कॉल किया जाता है. इसे हर बार तब कॉल किया जाता है, जब आपका ऐप्लिकेशन बैकग्राउंड में जाता है.

onSaveInstanceState() कॉल को सुरक्षा उपाय के तौर पर देखें. इससे आपको बंडल में कुछ जानकारी सेव करने का मौका मिलता है. यह जानकारी तब मिलती है, जब आपका ऐक्टिविटी फ़ोरग्राउंड से बाहर निकल जाता है. सिस्टम इस डेटा को अभी सेव करता है, क्योंकि अगर ऐप्लिकेशन के बंद होने तक इंतज़ार किया जाता है, तो ओएस पर संसाधन का दबाव पड़ सकता है. हर बार डेटा सेव करने से यह पक्का हो जाता है कि बंडल में अपडेट करने के लिए डेटा ज़रूरत के मुताबिक मौजूद है.

1. MainActivity में, onSaveInstanceState() कॉलबैक को बदलें और Timber लॉग स्टेटमेंट जोड़ें.
   

override fun onSaveInstanceState(outState: Bundle) {
   super.onSaveInstanceState(outState)

   Timber.i("onSaveInstanceState Called")
}

ध्यान दें: onSaveInstanceState() के लिए दो ओवरराइड हैं, एक सिर्फ़ outState पैरामीटर के साथ और एक outState और outPersistentState पैरामीटर के साथ. ऊपर दिए गए कोड में दिखाए गए कोड, outState पैरामीटर के साथ इस्तेमाल करें.

2. ऐप्लिकेशन को कंपाइल करें और चलाएं. इसके बाद, उसे बैकग्राउंड में रखने के लिए होम बटन पर क्लिक करें. ध्यान दें कि onSaveInstanceState() कॉलबैक, onPause() और onStop() के ठीक बाद होता है:
   
3. क्लास की परिभाषा से ठीक पहले, फ़ाइल में सबसे ऊपर, इन कॉन्सटेंट को जोड़ें:

const val KEY_REVENUE = "revenue_key"
const val KEY_DESSERT_SOLD = "dessert_sold_key"
const val KEY_TIMER_SECONDS = "timer_seconds_key"

आप इंस्टेंस कुंजियों के डेटा को सेव करने और उसे फिर से पाने के लिए इन कुंजियों का इस्तेमाल करेंगे.

4. नीचे की ओर स्क्रोल करके onSaveInstanceState() पर जाएं और outState पैरामीटर देखें, जो Bundle टाइप का है.
   
   बंडल, की-वैल्यू पेयर का कलेक्शन होता है, जहां कुंजियां हमेशा स्ट्रिंग के तौर पर होती हैं. आप बंडल में int और boolean वैल्यू जैसे शुरुआती मान डाल सकते हैं.
   सिस्टम इस बंडल को रैम में रखता है, इसलिए बंडल में डेटा को छोटा रखना सबसे सही तरीका है. इस बंडल का साइज़ भी सीमित है. हालांकि, हर डिवाइस के हिसाब से यह साइज़ अलग-अलग हो सकता है. आम तौर पर, आपको 1 लाख से कम स्टोर करना चाहिए. ऐसा न करने पर, TransactionTooLargeException गड़बड़ी की वजह से आपका ऐप्लिकेशन बंद हो सकता है.
   
5. onSaveInstanceState() में, revenue तरीके (एक पूर्णांक) को putInt() तरीके वाले बंडल में रखें:
   

outState.putInt(KEY_REVENUE, revenue)

putInt() तरीका (और Bundle और putFloat() जैसी putString() क्लास से मिलते-जुलते तरीके, दो तर्क लेते हैं: कुंजी के लिए एक स्ट्रिंग (KEY_REVENUE कॉन्सटेंट) और सेव करने के लिए असल वैल्यू.

6. मिठाइयां बेचने की संख्या और टाइमर की स्थिति के साथ यही प्रोसेस दोहराएं:

outState.putInt(KEY_DESSERT_SOLD, dessertsSold)
outState.putInt(KEY_TIMER_SECONDS, dessertTimer.secondsCount)

तीसरा चरण: बंडल डेटा वापस लाने के लिए onCreate() का इस्तेमाल करना

1. onCreate() तक स्क्रोल करें और तरीके के हस्ताक्षर की जांच करें:

override fun onCreate(savedInstanceState: Bundle) {

ध्यान दें कि हर बार कॉल किए जाने पर onCreate() को एक Bundle मिलता है. जब किसी प्रोसेस के बंद होने की वजह से आपकी गतिविधि रीस्टार्ट होती है, तब आपका सेव किया गया बंडल onCreate() को भेज दिया जाता है. अगर आपकी गतिविधि नए सिरे से शुरू हो रही थी, तो onCreate() का यह बंडल null है. इसलिए, अगर बंडल null नहीं है, तो आप यह जान सकते हैं कि आप पहले से मालूम किसी गतिविधि के आधार पर गतिविधि को 're &kot;फिर से बना रहे हैं (कोटेशन) करते हैं.

ध्यान दें: अगर गतिविधि को फिर से बनाया जा रहा है, तो बंडल के साथ, onRestoreInstanceState() कॉलबैक को onStart() के बाद कॉल किया जाता है. ज़्यादातर समय, आप onCreate() में गतिविधि की स्थिति को पहले जैसा करते हैं. हालांकि, onRestoreInstanceState() को onStart() के बाद कॉल किया जाता है. इसलिए, अगर आप onCreate() के कॉल के बाद कुछ स्थितियों को पहले जैसा करना चाहते हैं, तो आप onRestoreInstanceState() का इस्तेमाल कर सकते हैं.

2. DessertTimer सेट अप के बाद, इस कोड को onCreate() में जोड़ें:
   

if (savedInstanceState != null) {
   revenue = savedInstanceState.getInt(KEY_REVENUE, 0)
}

null के लिए टेस्ट से यह पता चलता है कि बंडल में डेटा है या नहीं. बंडल के null होने पर यह पता चलता है कि ऐप्लिकेशन को नए सिरे से शुरू किया गया है या नहीं. इसके अलावा, बंडल के बंद होने के बाद उसे फिर से बनाया गया है या नहीं. बंडल से डेटा वापस लाने के लिए, यह टेस्ट एक सामान्य पैटर्न है.

ध्यान दें कि यहां इस्तेमाल की जाने वाली कुंजी, KEY_REVENUE) वही है जिसका इस्तेमाल आपने putInt() के लिए किया था. यह पक्का करने के लिए कि हर बार आप एक ही कुंजी का इस्तेमाल करें, उन कुंजियों को कॉन्सटेंट के तौर पर परिभाषित करना सबसे सही तरीका है. बंडल में डेटा डालने के लिए, आप getInt() का इस्तेमाल करते हैं. ठीक उसी तरह, जैसे कि बंडल में डेटा डालने के लिए putInt() का इस्तेमाल किया गया हो. getInt() तरीके में दो तर्क होते हैं:

• कुंजी के तौर पर काम करने वाली स्ट्रिंग, जैसे कि आय की वैल्यू के लिए "key_revenue".
• बंडल में उस कुंजी के लिए कोई वैल्यू मौजूद न होने पर एक डिफ़ॉल्ट वैल्यू.

इसके बाद, बंडल से मिलने वाला इंटेजर revenue वैरिएबल को असाइन किया जाता है और यूज़र इंटरफ़ेस (यूआई) उस वैल्यू का इस्तेमाल करेगा.

3. बेचे गए मिठाइयों की संख्या और टाइमर के मान को पहले जैसा करने के लिए, getInt() तरीके जोड़ें:

if (savedInstanceState != null) {
   revenue = savedInstanceState.getInt(KEY_REVENUE, 0)dessertsSold = savedInstanceState.getInt(KEY_DESSERT_SOLD, 0)
   dessertTimer.secondsCount =
       savedInstanceState.getInt(KEY_TIMER_SECONDS, 0)
}

4. ऐप्लिकेशन को कंपाइल करें और चलाएं. डोनक पर स्विच होने के बाद, कम से कम पांच बार कपकेक दबाएं. ऐप्लिकेशन को बैकग्राउंड में रखने के लिए होम पर क्लिक करें.
5. Android Studio टर्मिनल टैब में, ऐप्लिकेशन और #39; की प्रोसेस को बंद करने के लिए adb चलाएं.
   

adb shell am kill com.example.android.dessertclicker

6. ऐप्लिकेशन पर वापस लौटने के लिए, स्क्रीन पर हाल ही में इस्तेमाल की गई स्क्रीन का इस्तेमाल करें. ध्यान दें कि इस बार, ऐप्लिकेशन आपके विज्ञापन से होने वाली आय और मिठाई के सही मान के साथ वापस आता है. हालांकि, यह भी ध्यान दें कि मिठाई एक कपकेक में लौट चुकी है. आपको एक और काम करना होगा, ताकि यह पक्का किया जा सके कि ऐप्लिकेशन पूरी तरह बंद होने पर उसी तरह दिखे जिस तरह से उसे छोड़ा गया था.
7. MainActivity में, showCurrentDessert() तरीके की जांच करें. ध्यान दें कि इस तरीके से यह तय होता है कि ऐक्टिविटी में कौनसी मिठाई की इमेज दिखाई जानी चाहिए. यह इमेज, allDesserts वैरिएबल में बेची गई कुल मिठाइयां और मिठाई की सूची के आधार पर तय होती है.
   

for (dessert in allDesserts) {
   if (dessertsSold >= dessert.startProductionAmount) {
       newDessert = dessert
   }
    else break
}

यह तरीका सही इमेज चुनने के लिए बेची जाने वाली मिठाइयों की संख्या पर निर्भर करता है. इसलिए, onSaveInstanceState() में बंडल में मौजूद इमेज की पहचान फ़ाइल को सेव करने के लिए, आपको कुछ भी करने की ज़रूरत नहीं है. इस बंडल में आप कई तरह की मिठाइयां बेच रहे हैं.

8. onCreate() के बंडल में मौजूद स्थिति को वापस लाने वाले ब्लॉक में, showCurrentDessert() पर कॉल करें:
   

 if (savedInstanceState != null) {
   revenue = savedInstanceState.getInt(KEY_REVENUE, 0)
   dessertsSold = savedInstanceState.getInt(KEY_DESSERT_SOLD, 0)
   dessertTimer.secondsCount = 
      savedInstanceState.getInt(KEY_TIMER_SECONDS, 0)
   showCurrentDessert()                   
}

9. ऐप्लिकेशन को कंपाइल करके चलाएं और उसे बैकग्राउंड में रखें. इस प्रोसेस को बंद करने के लिए, adb का इस्तेमाल करें. ऐप्लिकेशन पर वापस जाने के लिए हाल ही की स्क्रीन का इस्तेमाल करें. ध्यान दें कि मिठाइयां के बारे में बताई गई वैल्यू, कुल आय, और मिठाई की इमेज को सही तरीके से वापस लाया गया है.

गतिविधि और फ़्रैगमेंट लाइफ़साइकल को मैनेज करने के लिए, एक आखिरी खास मामला यह है कि इसे समझना ज़रूरी है: कॉन्फ़िगरेशन में होने वाले बदलाव, आपकी गतिविधियों और फ़्रैगमेंट की लाइफ़साइकल पर कैसे असर डालते हैं.

कॉन्फ़िगरेशन बदलाव तब होता है, जब डिवाइस की स्थिति इतने बदल जाती है कि सिस्टम के लिए बदलाव का सबसे आसान तरीका, पूरी तरह से शट डाउन करना और गतिविधि को फिर से बनाना होता है. उदाहरण के लिए, अगर उपयोगकर्ता डिवाइस की भाषा बदलता है, तो अलग-अलग टेक्स्ट निर्देशों को शामिल करने के लिए पूरे लेआउट को बदलना पड़ सकता है. अगर उपयोगकर्ता डिवाइस को डॉक में प्लग करता है या कोई फ़िज़िकल कीबोर्ड जोड़ता है, तो ऐप्लिकेशन के लेआउट को किसी अलग डिसप्ले साइज़ या लेआउट का फ़ायदा लेना पड़ सकता है. अगर डिवाइस की स्क्रीन की दिशा बदलती है, तो डिवाइस के पोर्ट्रेट से लैंडस्केप या दूसरे तरीके से घुमाने पर, लेआउट को स्क्रीन पर नए ओरिएंटेशन के हिसाब से बदलने की ज़रूरत पड़ सकती है.

पहला चरण: डिवाइस को घुमाने और लाइफ़साइकल कॉलबैक के बारे में जानना

1. अपना ऐप्लिकेशन कंपाइल करें और चलाएं. साथ ही, लॉगकैट खोलें.
2. डिवाइस या एम्युलेटर को लैंडस्केप मोड में घुमाएं. आप रोटेशन बटन की मदद से, एम्युलेटर को बाईं या दाईं तरफ़ या Control और तीर के निशान वाली कुंजियों (Command और Mac पर तीर के निशान वाली कुंजियों) का इस्तेमाल करके, बदल सकते हैं.
   
3. लॉगकैट में आउटपुट की जांच करें. आउटपुट को MainActivity पर फ़िल्टर करें.
   ध्यान दें कि जब डिवाइस या एम्युलेटर स्क्रीन को रोटेट करता है, तब सिस्टम, लाइफ़साइकल कॉलबैक को गतिविधि बंद करने के लिए कॉल करता है. फिर, गतिविधि के फिर से बनाए जाने पर, सिस्टम शुरू करने के लिए सिस्टम, लाइफ़साइकल कॉलबैक को कॉल करता है.
4. MainActivity में, onSaveInstanceState() के पूरे तरीके पर टिप्पणी करें.
5. अपना ऐप्लिकेशन दोबारा कंपाइल करें और चलाएं. कपकेक को कुछ बार क्लिक करें और डिवाइस या एम्युलेटर को घुमाएं. जब इस समय, डिवाइस को घुमाया जाता है और गतिविधि बंद करके फिर से बनाई जाती है, तो गतिविधि डिफ़ॉल्ट वैल्यू के साथ शुरू होती है.
   
   कॉन्फ़िगरेशन में बदलाव होने पर, Android उसी इंस्टेंस स्टेट बंडल का इस्तेमाल करता है जिसके बारे में आपने ऐप्लिकेशन की स्थिति को सेव और पहले जैसा करने के लिए, पिछले टास्क में सीखा है. प्रोसेस बंद होने पर, अपने ऐप्लिकेशन का डेटा बंडल में रखने के लिए onSaveInstanceState() का इस्तेमाल करें. इसके बाद, onCreate() में डेटा को बहाल करें, ताकि डिवाइस को घुमाने पर गतिविधि की स्थिति से जुड़ा डेटा खोने से बचा जा सके.
6. MainActivity में, onSaveInstanceState() तरीके को अनटिप्पणी करें, ऐप्लिकेशन चलाएं, कपकेक पर क्लिक करें, और ऐप्लिकेशन या डिवाइस को घुमाएं. ध्यान दें कि इस समय गतिविधि डेटा में डेज़र्ट डेटा का रखरखाव किया जाता है.

Android Studio प्रोजेक्ट: DessertClickerfinal

लाइफ़साइकल के लिए सलाह

• अगर आप लाइफ़साइकल कॉलबैक में कुछ सेट अप या शुरू करते हैं, तो उससे जुड़े कॉलबैक में उस चीज़ को रोकें या हटाएं. चीज़ को रोककर, आप यह पक्का करते हैं कि जब #33 की ज़रूरत न हो, तो यह लगातार चलता रहे. उदाहरण के लिए, अगर आप onStart() में टाइमर सेट करते हैं, तो आपको onStop() में टाइमर को रोकना या बंद करना होगा.
• onCreate() का इस्तेमाल सिर्फ़ उन हिस्सों को शुरू करने के लिए करें जो आपके ऐप्लिकेशन के पहली बार शुरू होने पर एक बार चलते हैं. अपने ऐप्लिकेशन के उन हिस्सों को शुरू करने के लिए onStart() का इस्तेमाल करें जो ऐप्लिकेशन के शुरू होने और चलने के दौरान दोनों पर चलते हैं.

लाइफ़साइकल लाइब्रेरी

• लाइफ़साइकल कंट्रोल को गतिविधि या फ़्रैगमेंट से लाइफ़साइकल के बारे में जानकारी देने वाले असल कॉम्पोनेंट में बदलने के लिए, Android की लाइफ़साइकल लाइब्रेरी का इस्तेमाल करें.
• लाइफ़साइकल के मालिक वे कॉम्पोनेंट होते हैं जिनमें Activity और Fragment के साथ-साथ, लाइफ़साइकल भी होती है. लाइफ़साइकल के मालिक, LifecycleOwner इंटरफ़ेस को लागू करते हैं.
• लाइफ़साइकल ऑब्ज़र्वर लाइफ़साइकल की मौजूदा स्थिति पर ध्यान देते हैं. लाइफ़साइकल बदलने पर टास्क करते हैं. लाइफ़साइकल ऑब्ज़र्वर LifecycleObserver इंटरफ़ेस को लागू करते हैं.
• Lifecycle ऑब्जेक्ट में असल लाइफ़साइकल की स्थितियां होती हैं और लाइफ़साइकल बदलने पर वे इवेंट ट्रिगर करती हैं.

लाइफ़साइकल की जानकारी वाली क्लास बनाने के लिए:

• उन क्लास में LifecycleObserver इंटरफ़ेस लागू करें जिन्हें लाइफ़साइकल की जानकारी होनी चाहिए.
• ऐक्टिविटी या फ़्रैगमेंट से लाइफ़साइकल ऑब्ज़र्वर क्लास के साथ, लाइफ़साइकल ऑब्ज़र्वर क्लास शुरू करें.
• लाइफ़साइकल ऑब्ज़र्वर क्लास में, लाइफ़साइकल की स्थिति में किए गए बदलाव के साथ लाइफ़साइकल की जानकारी देने के तरीकों के बारे में बताएं.
  
  उदाहरण के लिए, @OnLifecycleEvent(Lifecycle.Event.ON_START)एनोटेशन से पता चलता है कि यह तरीका, onStart की लाइफ़साइकल इवेंट को देख रहा है.

शटडाउन प्रोसेस करना और गतिविधि की स्थिति सेव करना

• Android, बैकग्राउंड में चल रहे ऐप्लिकेशन को कंट्रोल करता है, ताकि फ़ोरग्राउंड ऐप्लिकेशन बिना किसी समस्या के चल सके. इस नियम के तहत, बैकग्राउंड में ऐप्लिकेशन इस तरह की प्रोसेस नहीं कर सकते. साथ ही, कभी-कभी ऐप्लिकेशन प्रोसेस भी बंद हो जाती है.
• उपयोगकर्ता यह नहीं बता सकता कि सिस्टम ने बैकग्राउंड में, किसी ऐप्लिकेशन को बंद किया है या नहीं. ऐप्लिकेशन अब भी हाल ही की स्क्रीन पर दिखता है और उसे उसी स्थिति में रीस्टार्ट होना चाहिए जहां उपयोगकर्ता ने उसे छोड़ा था.
• Android डीबग ब्रिज (adb) एक कमांड-लाइन टूल है. इसकी मदद से, आप अपने कंप्यूटर से जुड़े एम्युलेटर और डिवाइसों को निर्देश भेज सकते हैं. आप अपने ऐप्लिकेशन में प्रोसेस बंद करने के लिए, adb का इस्तेमाल कर सकते हैं.
• जब Android आपके ऐप्लिकेशन को बंद कर देता है, तो लाइफ़साइकल के onDestroy() तरीके को कॉल नहीं किया जाता है. ऐप्लिकेशन बस रुक जाता है.

गतिविधि और फ़्रैगमेंट की स्थिति को बनाए रखना

• जब आपका ऐप्लिकेशन बैकग्राउंड में जाता है, तो onStop() को कॉल करने के तुरंत बाद, ऐप्लिकेशन का डेटा बंडल में सेव हो जाता है. आपके लिए ऐप्लिकेशन का कुछ डेटा अपने-आप सेव हो जाता है, जैसे कि EditText का कॉन्टेंट.
• बंडल, Bundle का एक इंस्टेंस है, जो कुंजियों और वैल्यू का कलेक्शन है. कुंजियां हमेशा स्ट्रिंग होती हैं.
• आप जिस बंडल को बनाए रखना चाहते हैं उस पर दूसरे डेटा को सेव करने के लिए, onSaveInstanceState() कॉलबैक का इस्तेमाल करें. भले ही, ऐप्लिकेशन अपने-आप शट डाउन हो गया हो. बंडल में डेटा रखने के लिए, put से शुरू होने वाले बंडल के तरीकों का इस्तेमाल करें. जैसे, putInt().
• आप onRestoreInstanceState() तरीके में या onCreate() में आम तौर पर, बंडल से डेटा वापस पा सकते हैं. onCreate() तरीके में एक savedInstanceState पैरामीटर है जो बंडल को होल्ड करता है.
• अगर savedInstanceState वैरिएबल में null है, तो गतिविधि एक स्टेट बंडल के बिना शुरू हुई थी. हालांकि, इसे फिर से हासिल करने के लिए कोई राज्य डेटा नहीं है.
• किसी कुंजी का इस्तेमाल करके, बंडल से डेटा पाने के लिए, Bundle में शुरू होने वाले get तरीकों का इस्तेमाल करें. जैसे, getInt().

कॉन्फ़िगरेशन में बदलाव

• कॉन्फ़िगरेशन में बदलाव तब होता है, जब डिवाइस की स्थिति इतने बदल जाती है कि सिस्टम के लिए बदलाव को हल करना सबसे आसान तरीका है, उसे बंद करके फिर से चालू करना.
• कॉन्फ़िगरेशन के बदलाव का सबसे आम उदाहरण है, जब उपयोगकर्ता डिवाइस को पोर्ट्रेट से लैंडस्केप मोड में या लैंडस्केप से पोर्ट्रेट मोड में बदलता है. कॉन्फ़िगरेशन में बदलाव तब भी हो सकता है, जब डिवाइस की भाषा बदल जाती है या हार्डवेयर कीबोर्ड प्लग-इन हो जाता है.
• कॉन्फ़िगरेशन के बदलने पर, Android सभी ऐक्टिविटी की लाइफ़साइकल' शटडाउन कॉलबैक चालू कर देता है. इसके बाद, Android पूरी तरह से लाइफ़साइकल स्टार्टअप कॉलबैक चलाते हुए, गतिविधि को शुरू से फिर से शुरू करता है.
• जब कॉन्फ़िगरेशन में बदलाव की वजह से Android, ऐप्लिकेशन को शट डाउन करता है, तो यह onCreate() के लिए उपलब्ध स्टेट बंडल के साथ गतिविधि को रीस्टार्ट करता है.
• प्रोसेस बंद होने पर, अपने ऐप्लिकेशन की स्थिति को onSaveInstanceState() में बंडल में सेव करें.

Udcity कोर्स:

• Kotlin के साथ Android ऐप्लिकेशन डेवलप करना

Android डेवलपर दस्तावेज़:

• Activities (एपीआई गाइड)
• Activity (एपीआई रेफ़रंस)
• गतिविधि की लाइफ़साइकल के बारे में जानना
• लाइफ़साइकल के कॉम्पोनेंट के साथ लाइफ़साइकल मैनेज करना
• LifecycleOwner
• Lifecycle
• LifecycleObserver
• onSaveInstanceState()
• कॉन्फ़िगरेशन में होने वाले बदलावों को मैनेज करना
• यूज़र इंटरफ़ेस (यूआई) स्थितियां सेव करना

अन्य:

• टिंबर (GitHub)

इस सेक्शन में उन छात्र-छात्राओं के लिए गृहकार्य की असाइनमेंट की सूची दी गई है जो इस कोडलैब के ज़रिए एक शिक्षक की देखरेख में कोर्स में काम कर रहे हैं. यह क्रिएटर का काम #33 पर निर्भर करता है:

• अगर ज़रूरी हो, तो होमवर्क असाइन करें.
• छात्र-छात्राओं को होमवर्क के असाइनमेंट सबमिट करने के तरीके के बारे में बताएं.
• होमवर्क असाइनमेंट को ग्रेड दें.

शिक्षक इन सुझावों का इस्तेमाल जितनी चाहें उतनी कम या ज़्यादा कर सकते हैं. साथ ही, उन्हें अपने हिसाब से कोई भी होमवर्क असाइन करना चाहिए.

अगर आप इस कोडलैब के ज़रिए खुद काम कर रहे हैं, तो बेझिझक इन होमवर्क असाइनमेंट का इस्तेमाल करें.

ऐप्लिकेशन बदलना

लेसन 1 से DiceRoller ऐप्लिकेशन खोलें. (अगर आपके पास ऐप्लिकेशन नहीं है, तो आप यहां ऐप्लिकेशन डाउनलोड कर सकते हैं.) ऐप्लिकेशन को कंपाइल करें और चलाएं और ध्यान दें कि अगर आप डिवाइस को घुमाएंगे, तो पासे की मौजूदा वैल्यू हट जाएगी. बंडल में उस वैल्यू को बनाए रखने और उसे onCreate() में वापस लाने के लिए, onSaveInstanceState() लागू करें.

इन सवालों के जवाब दें

पहला सवाल

आपके ऐप्लिकेशन में भौतिकी का एक सिम्युलेशन है जिसे दिखाने के लिए बहुत ज़्यादा कंप्यूटेशन की ज़रूरत है. इसके बाद, उपयोगकर्ता को फ़ोन कॉल किया जाता है. इस मामले में, इनमें से कौनसी बात सही है?

• फ़ोन कॉल के दौरान, आपको भौतिकी सिम्युलेशन में ऑब्जेक्ट की जगहों की गणना करना जारी रखना चाहिए.
• फ़ोन कॉल के दौरान, आपको भौतिकी सिम्युलेशन में ऑब्जेक्ट की जगहों की गणना करना बंद कर देना चाहिए.

दूसरा सवाल

जब ऐप्लिकेशन स्क्रीन पर न हो, तो सिम्युलेशन रोकने के लिए आपको लाइफ़साइकल का कौनसा तरीका बदलना चाहिए?

• onDestroy()
• onStop()
• onPause()
• onSaveInstanceState()

तीसरा सवाल

Android की लाइफ़साइकल लाइब्रेरी की मदद से, क्लास की लाइफ़साइकल की जानकारी देने के लिए, क्लास को किस इंटरफ़ेस को लागू करना चाहिए?

• Lifecycle
• LifecycleOwner
• Lifecycle.Event
• LifecycleObserver

चौथा सवाल

आपकी गतिविधि में मौजूद onCreate() तरीके को डेटा के साथ Bundle मिलने पर (यानी कि Bundle null नहीं है)? एक से ज़्यादा जवाब लागू हो सकते हैं.

• डिवाइस को घुमाने के बाद, गतिविधि फिर से शुरू हो जाती है.
• गतिविधि, शुरू से शुरू की गई है.
• गतिविधि, बैकग्राउंड से वापस आने पर फिर से शुरू कर दी जाती है.
• डिवाइस को फिर से चालू किया गया है.

अगला लेसन शुरू करें: 5.1: ViewModel और ViewModelFactory

इस कोर्स में दिए गए दूसरे कोडलैब के लिंक के लिए, Android Kotlin की बुनियादी बातें कोडलैब का लैंडिंग पेज देखें.