गतिविधि की लाइफ़साइकल और स्थिति को इस्तेमाल करने का तरीका

1. आपका स्वागत है

यह प्रैक्टिकल कोडलैब, 'Android डेवलपर फ़ंडामेंटल्स (वर्शन 2)' कोर्स के यूनिट 1: शुरू करें का हिस्सा है. इस कोर्स का ज़्यादा से ज़्यादा फ़ायदा पाने के लिए, कोडलैब को क्रम से पूरा करें:

  • कोर्स में मौजूद कोडलैब की पूरी सूची देखने के लिए, Android डेवलपर फ़ंडामेंटल्स (V2) के लिए कोडलैब देखें.
  • कोर्स के बारे में ज़्यादा जानने के लिए, Android Developer Fundamentals (Version 2) देखें. इसमें कॉन्सेप्ट के सभी चैप्टर, ऐप्लिकेशन, और स्लाइड के लिंक भी शामिल हैं.

परिचय

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

IDouble trouble

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

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

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

ज़रूरी शर्तें

आपके पास ये काम करने की अनुमति होगी:

  • Android Studio में ऐप्लिकेशन प्रोजेक्ट बनाएं और चलाएं.
  • अपने ऐप्लिकेशन में लॉग स्टेटमेंट जोड़ें और उन लॉग को Logcat पैनल में देखें.
  • गतिविधि और इंटेंट को समझना और उनसे काम करना. साथ ही, उनसे आसानी से इंटरैक्ट करना.

आपको क्या जानकारी मिलेगी

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

आपको क्या करना होगा

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

2. ऐप्लिकेशन की खास जानकारी

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

3. 3. पहला टास्क: TwoActivities में लाइफ़साइकल कॉलबैक जोड़ना

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

1.1 (ज़रूरी नहीं) TwoActivities प्रोजेक्ट कॉपी करना

इस प्रैक्टिकल में दिए गए टास्क के लिए, आपको पिछले प्रैक्टिकल में बनाए गए मौजूदा TwoActivities प्रोजेक्ट में बदलाव करना होगा. अगर आपको TwoActivities का पिछला प्रोजेक्ट पहले जैसा ही रखना है, तो प्रोजेक्ट की कॉपी बनाने के लिए, अनुबंध: उपयोगिता में दिया गया तरीका अपनाएं.

1.2 MainActivity में कॉलबैक लागू करना

  1. Android Studio में TwoActivities प्रोजेक्ट खोलें. इसके बाद, प्रोजेक्ट > Android पैनल में MainActivity खोलें.
  2. onCreate() तरीके में, ये लॉग स्टेटमेंट जोड़ें:
Log.d(LOG_TAG, "-------");
Log.d(LOG_TAG, "onCreate");
  1. उस इवेंट के लॉग में स्टेटमेंट के साथ, onStart() कॉलबैक के लिए बदलाव जोड़ें:
@Override
public void onStart(){
    super.onStart();
    Log.d(LOG_TAG, "onStart");
}

शॉर्टकट के लिए, Android Studio में कोड > ओवरराइड करने के तरीके चुनें. इसके बाद, एक डायलॉग बॉक्स दिखेगा. इसमें वे सभी तरीके दिखेंगे जिन्हें अपनी क्लास में बदला जा सकता है. सूची से एक या उससे ज़्यादा कॉलबैक तरीके चुनने पर, उन तरीकों के लिए पूरा टेंप्लेट डाला जाता है. इसमें सुपरक्लास के लिए ज़रूरी कॉल भी शामिल होता है.

  1. onPause(), onRestart(), onResume(), onStop(), और onDestroy() लाइफ़साइकल कॉलबैक को लागू करने के लिए, onStart() तरीके को टेंप्लेट के तौर पर इस्तेमाल करें

सभी कॉलबैक तरीकों के सिग्नेचर एक जैसे होते हैं (नाम को छोड़कर). अगर इन दूसरे कॉलबैक तरीकों को बनाने के लिए, onStart() को कॉपी करके चिपकाया जाता है, तो सुपरक्लास में सही तरीके को कॉल करने और सही तरीके को लॉग करने के लिए, कॉन्टेंट को अपडेट करना न भूलें.

  1. अपना ऐप्लिकेशन चलाएं.
  2. Logcat पैनल दिखाने के लिए, Android Studio में सबसे नीचे मौजूद Logcat टैब पर क्लिक करें. आपको तीन लॉग मैसेज दिखेंगे. इनमें, गतिविधि शुरू होने के बाद, लाइफ़साइकल की तीन स्थितियों के बारे में जानकारी होगी:
D/MainActivity: -------
D/MainActivity: onCreate
D/MainActivity: onStart
D/MainActivity: onResume

1.3 SecondActivity में लाइफ़साइकल कॉलबैक लागू करना

MainActivity के लिए लाइफ़साइकल कॉलबैक मैथड लागू करने के बाद, SecondActivity के लिए भी ऐसा ही करें.

  1. SecondActivity खोलें.
  2. क्लास में सबसे ऊपर, LOG_TAG वैरिएबल के लिए एक कॉन्स्टेंट जोड़ें:
private static final String LOG_TAG = SecondActivity.class.getSimpleName();
  1. दूसरी गतिविधि में लाइफ़साइकल कॉलबैक और लॉग स्टेटमेंट जोड़ें. (MainActivity से कॉलबैक मैथड कॉपी करके चिपकाए जा सकते हैं.)
  2. finish() मेथड से ठीक पहले, returnReply() मेथड में लॉग स्टेटमेंट जोड़ें:
Log.d(LOG_TAG, "End SecondActivity");

1.4 ऐप्लिकेशन के चलने के दौरान लॉग देखें**

  1. अपना ऐप्लिकेशन चलाएं.
  2. Logcat पैनल दिखाने के लिए, Android Studio में सबसे नीचे मौजूद Logcat टैब पर क्लिक करें.
  3. खोज बॉक्स में गतिविधि डालें. Android logcat बहुत लंबा और गड़बड़ी से भरा हो सकता है. हर क्लास में LOG_TAG वैरिएबल में MainActivity या SecondActivity शब्द शामिल होते हैं. इस कीवर्ड की मदद से, लॉग को सिर्फ़ अपनी पसंद की चीज़ों के हिसाब से फ़िल्टर किया जा सकता है.

IDouble trouble

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

  • ऐप्लिकेशन का सामान्य तरीके से इस्तेमाल करें (मैसेज भेजें, किसी दूसरे मैसेज का जवाब दें).
  • दूसरी गतिविधि से मुख्य गतिविधि पर वापस जाने के लिए, 'वापस जाएं' बटन का इस्तेमाल करें.
  • दूसरी गतिविधि से मुख्य गतिविधि पर वापस जाने के लिए, ऐप्लिकेशन बार में मौजूद अप ऐरो का इस्तेमाल करें.
  • अपने ऐप्लिकेशन में अलग-अलग समय पर, मुख्य और दूसरी गतिविधि, दोनों पर डिवाइस को घुमाएं और देखें कि * लॉग और स्क्रीन पर क्या होता है.
  • खास जानकारी बटन (होम की दाईं ओर मौजूद स्क्वेयर बटन) दबाएं और ऐप्लिकेशन बंद करें (X पर टैप करें).
  • होम स्क्रीन पर वापस जाएं और अपना ऐप्लिकेशन फिर से शुरू करें.

अहम जानकारी: अगर ऐप्लिकेशन को किसी एमुलेटर में चलाया जा रहा है, तो Control+F11 या Control+Function+F11 का इस्तेमाल करके, ऐप्लिकेशन के घूमने की गतिविधियों को सिम्युलेट किया जा सकता है.

टास्क 1 का समाधान कोड

यहां दिए गए कोड स्निपेट, पहले टास्क के लिए समाधान का कोड दिखाते हैं.

MainActivity

नीचे दिए गए कोड स्निपेट में, MainActivity में जोड़ा गया कोड दिखता है, लेकिन पूरी क्लास नहीं.

onCreate() तरीका:

@Override
protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Log the start of the onCreate() method.
        Log.d(LOG_TAG, "-------");
        Log.d(LOG_TAG, "onCreate");

        // Initialize all the view variables.
        mMessageEditText = findViewById(R.id.editText_main);
        mReplyHeadTextView = findViewById(R.id.text_header_reply);
        mReplyTextView = findViewById(R.id.text_message_reply);
}

लाइफ़साइकल के अन्य तरीके:

@Override
protected void onStart() {
        super.onStart();
        Log.d(LOG_TAG, "onStart");
}

@Override
protected void onPause() {
        super.onPause();
        Log.d(LOG_TAG, "onPause");
}

@Override
protected void onRestart() {
        super.onRestart();
        Log.d(LOG_TAG, "onRestart");
}

@Override
protected void onResume() {
        super.onResume();
        Log.d(LOG_TAG, "onResume");
}

@Override
protected void onStop() {
        super.onStop();
        Log.d(LOG_TAG, "onStop");
}

@Override
protected void onDestroy() {
        super.onDestroy();
        Log.d(LOG_TAG, "onDestroy");
}

SecondActivity

नीचे दिए गए कोड स्निपेट में, SecondActivity में जोड़ा गया कोड दिखता है, लेकिन पूरी क्लास नहीं.

SecondActivity क्लास में सबसे ऊपर:

private static final String LOG_TAG = SecondActivity.class.getSimpleName();

returnReply() तरीका:

public void returnReply(View view) {
        String reply = mReply.getText().toString();
        Intent replyIntent = new Intent();
        replyIntent.putExtra(EXTRA_REPLY, reply);
        setResult(RESULT_OK, replyIntent);
        Log.d(LOG_TAG, "End SecondActivity");
        finish();
}

लाइफ़साइकल के अन्य तरीके:

यह वही है जो ऊपर MainActivity के लिए बताया गया है.

4. 4. दूसरा टास्क: गतिविधि के इंस्टेंस की स्थिति सेव करना और उसे वापस लाना

सिस्टम के संसाधनों और उपयोगकर्ता के व्यवहार के आधार पर, आपके ऐप्लिकेशन में मौजूद हर गतिविधि को आपकी सोच से ज़्यादा बार मिटाया और फिर से बनाया जा सकता है.

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

हर गतिविधि की स्थिति, कीवर्ड/वैल्यू पेयर के सेट के तौर पर स्टोर की जाती है. इसे बंडल ऑब्जेक्ट में स्टोर किया जाता है, जिसे गतिविधि का इंस्टेंस स्टेटस कहा जाता है. सिस्टम, गतिविधि के बंद होने से ठीक पहले, इंस्टेंस स्टेटस बंडल में डिफ़ॉल्ट स्टेटस की जानकारी सेव करता है. साथ ही, उस बंडल को नए गतिविधि इंस्टेंस में पास करता है, ताकि उसे वापस लाया जा सके.

अगर किसी गतिविधि को अचानक से मिटा दिया जाता है और फिर से बनाया जाता है, तो उसमें मौजूद डेटा को सुरक्षित रखने के लिए, आपको onSaveInstanceState() मेथड लागू करना होगा. सिस्टम आपकी गतिविधि पर इस तरीके को कॉल करता है (onPause() और onStop() के बीच), जब गतिविधि को मिटाकर फिर से बनाया जा सकता है.

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

2.1 onSaveInstanceState() की मदद से, गतिविधि के इंस्टेंस की स्थिति सेव करना

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

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

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

इस टास्क में, आपको onSaveInstanceState() का इस्तेमाल करके, इन दो TextView एलिमेंट के इंस्टेंस स्टेट को सेव करने के लिए कोड जोड़ना है.

  1. MainActivity खोलें.
  2. गतिविधि में, onSaveInstanceState() के इस स्केलेटन को जोड़ें या स्केलेटन बदलने के लिए, कोड > बदलने के तरीके का इस्तेमाल करें.
@Override
public void onSaveInstanceState(Bundle outState) {
          super.onSaveInstanceState(outState);
}
  1. देखें कि हेडर फ़िलहाल दिख रहा है या नहीं. अगर दिख रहा है, तो putBoolean() तरीके और "reply_visible" बटन की मदद से, हेडर के दिखने की स्थिति को स्टेटस बंडल में डालें.
 if (mReplyHeadTextView.getVisibility() == View.VISIBLE) {
        outState.putBoolean("reply_visible", true);
    }

ध्यान रखें कि जब तक दूसरी गतिविधि से जवाब नहीं मिलता, तब तक जवाब का हेडर और टेक्स्ट, 'नहीं दिख रहा' के तौर पर मार्क रहता है. अगर हेडर दिख रहा है, तो इसका मतलब है कि जवाब का डेटा है, जिसे सेव करना होगा. ध्यान दें कि हमें सिर्फ़ हेडर के दिखने की स्थिति में दिलचस्पी है — हेडर के असली टेक्स्ट को सेव करने की ज़रूरत नहीं है, क्योंकि वह टेक्स्ट कभी नहीं बदलता.

  1. उसी चेक में, जवाब का टेक्स्ट बंडल में जोड़ें.
outState.putString("reply_text",mReplyTextView.getText().toString());

अगर हेडर दिख रहा है, तो इसका मतलब है कि जवाब वाला मैसेज भी दिख रहा है. आपको जवाब वाले मैसेज की मौजूदा स्थिति की जांच करने या उसे सेव करने की ज़रूरत नहीं है. मैसेज का सिर्फ़ असल टेक्स्ट, "reply_text" बटन की मदद से स्टेटस बंडल में जाता है.

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

ध्यान दें कि सिस्टम कुछ व्यू एलिमेंट की स्थिति सेव करेगा, जैसे कि EditText का कॉन्टेंट.

2.2 onCreate() में ऐक्टिविटी इंस्टेंस की स्थिति को वापस लाना

गतिविधि के इंस्टेंस की स्थिति सेव करने के बाद, गतिविधि को फिर से बनाने पर भी आपको उसे वापस लाना होगा. ऐसा करने के लिए, onCreate() या onRestoreInstanceState() कॉलबैक लागू करें. यह कॉलबैक, गतिविधि बनने के बाद onStart() के बाद कॉल किया जाता है.

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

  1. onCreate() मेथड में, findViewById() की मदद से व्यू वैरिएबल को शुरू करने के बाद, यह पक्का करने के लिए एक टेस्ट जोड़ें कि savedInstanceState शून्य न हो.
// Initialize all the view variables.
mMessageEditText = findViewById(R.id.editText_main);
mReplyHeadTextView = findViewById(R.id.text_header_reply);
mReplyTextView = findViewById(R.id.text_message_reply);

// Restore the state.
if (savedInstanceState != null) {
}

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

  1. इस जांच में, "reply_visible" बटन की मदद से, बंडल में मौजूद जवाब की मौजूदा स्थिति (सही या गलत) देखें.
if (savedInstanceState != null) {
    boolean isVisible = 
                     savedInstanceState.getBoolean("reply_visible");
}
  1. isVisible वैरिएबल के लिए, पिछली लाइन के नीचे एक टेस्ट जोड़ें.
if (isVisible) {
}

अगर स्टेटस बंडल में reply_visible बटन मौजूद है और isVisible की वैल्यू 'सही' है, तो आपको स्टेटस को पहले जैसा करना होगा.

  1. isVisible टेस्ट में, हेडर को दिखाएं.
mReplyHeadTextView.setVisibility(View.VISIBLE);
  1. बंडल से "reply_text" बटन का इस्तेमाल करके, मैसेज का जवाब पाने के लिए टेक्स्ट पाएं. साथ ही, उस स्ट्रिंग को दिखाने के लिए, जवाब वाले TextView को सेट करें.
mReplyTextView.setText(savedInstanceState.getString("reply_text"));
  1. जवाब के TextView को भी दिखाएं:
mReplyTextView.setVisibility(View.VISIBLE);
  1. ऐप्लिकेशन चलाएं. डिवाइस या एमुलेटर को घुमाकर देखें कि गतिविधि फिर से शुरू होने के बाद, जवाब का मैसेज (अगर कोई है) स्क्रीन पर दिखता है या नहीं.

टास्क 2 का समाधान कोड

यहां दिए गए कोड स्निपेट में, इस टास्क के लिए समाधान का कोड दिखाया गया है.

MainActivity

नीचे दिए गए कोड स्निपेट में, MainActivity में जोड़ा गया कोड दिखता है, लेकिन पूरी क्लास नहीं.

onSaveInstanceState() तरीका:

@Override
public void onSaveInstanceState(Bundle outState) {
   super.onSaveInstanceState(outState);
   // If the heading is visible, message needs to be saved.
   // Otherwise we're still using default layout.
   if (mReplyHeadTextView.getVisibility() == View.VISIBLE) {
       outState.putBoolean("reply_visible", true);
       outState.putString("reply_text", 
                      mReplyTextView.getText().toString());
   }
}

onCreate() तरीका:

@Override
protected void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   setContentView(R.layout.activity_main);

   Log.d(LOG_TAG, "-------");
   Log.d(LOG_TAG, "onCreate");

   // Initialize all the view variables.
   mMessageEditText = findViewById(R.id.editText_main);
   mReplyHeadTextView = findViewById(R.id.text_header_reply);
   mReplyTextView = findViewById(R.id.text_message_reply);

   // Restore the saved state. 
   // See onSaveInstanceState() for what gets saved.
   if (savedInstanceState != null) {
       boolean isVisible = 
                     savedInstanceState.getBoolean("reply_visible");
       // Show both the header and the message views. If isVisible is
       // false or missing from the bundle, use the default layout.
       if (isVisible) {
           mReplyHeadTextView.setVisibility(View.VISIBLE);
           mReplyTextView.setText(savedInstanceState
                                  .getString("reply_text"));
           mReplyTextView.setVisibility(View.VISIBLE);
       }
   }
}

पूरा प्रोजेक्ट:

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

5. कोडिंग

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

  • मुख्य गतिविधि में, सूची बनाने के लिए 10 खाली TextView एलिमेंट होने चाहिए.
  • मुख्य गतिविधि में मौजूद 'आइटम जोड़ें' बटन से दूसरी गतिविधि शुरू होती है. इसमें, आम तौर पर खरीदे जाने वाले आइटम (पनीर, चावल, सेब वगैरह) की सूची होती है. आइटम दिखाने के लिए, बटन एलिमेंट का इस्तेमाल करें.
  • कोई आइटम चुनने पर, उपयोगकर्ता को मुख्य गतिविधि पर वापस ले जाया जाता है. साथ ही, चुने गए आइटम को शामिल करने के लिए, खाली TextView को अपडेट किया जाता है.

एक ऐक्टिविटी से दूसरी ऐक्टिविटी में जानकारी भेजने के लिए, इंटेंट का इस्तेमाल करें. पक्का करें कि जब उपयोगकर्ता डिवाइस की स्क्रीन घुमाए, तो शॉपिंग की सूची की मौजूदा स्थिति सेव हो जाए.

6. खास जानकारी

  • ऐक्टिविटी का लाइफ़साइकल, उन स्थितियों का एक सेट होता है जिनमें ऐक्टिविटी माइग्रेट करती है. यह लाइफ़साइकल, ऐक्टिविटी के बनने के समय से शुरू होता है और तब खत्म होता है, जब Android सिस्टम उस ऐक्टिविटी के लिए संसाधनों को फिर से दावा कर लेता है.
  • जब उपयोगकर्ता एक ऐक्टिविटी से दूसरी ऐक्टिविटी पर जाता है और आपके ऐप्लिकेशन के अंदर और बाहर जाता है, तो हर ऐक्टिविटी, ऐक्टिविटी लाइफ़साइकल की स्थितियों के बीच चलती है.
  • ऐक्टिविटी लाइफ़साइकल की हर स्थिति के लिए एक कॉलबैक मैथड होता है. इसे अपनी ऐक्टिविटी क्लास में बदला जा सकता है.
  • लाइफ़साइकल के तरीके ये हैं: onCreate(), onStart(), onPause(), onRestart(), onResume(), onStop(), onDestroy().
  • लाइफ़साइकल कॉलबैक मैथड को बदलने पर, आपको उस स्थिति में होने वाली गतिविधि जोड़ने की सुविधा मिलती है.
  • Android Studio में, कोड > बदलें का इस्तेमाल करके अपनी क्लास में स्केलेटन ओवरराइड तरीके जोड़े जा सकते हैं.
  • डिवाइस के कॉन्फ़िगरेशन में होने वाले बदलावों की वजह से, ऐक्टिविटी को खत्म कर दिया जाता है और फिर से बनाया जाता है. जैसे, डिवाइस के रोटेट होने पर.
  • कॉन्फ़िगरेशन में बदलाव होने पर, गतिविधि की स्थिति का एक हिस्सा सुरक्षित रखा जाता है. इसमें EditText एलिमेंट की मौजूदा वैल्यू भी शामिल होती हैं. अन्य सभी डेटा के लिए, आपको खुद ही उस डेटा को सेव करना होगा.
  • onSaveInstanceState() तरीके में गतिविधि इंस्टेंस की स्थिति सेव करें.
  • इंस्टेंस स्टेटस का डेटा, बंडल में आसान की/वैल्यू पेयर के तौर पर सेव किया जाता है. बंडल में डेटा डालने और उसे वापस पाने के लिए, बंडल के तरीकों का इस्तेमाल करें.
  • onCreate() या onRestoreInstanceState() में इंस्टेंस की स्थिति को वापस लाएं. यह पसंदीदा तरीका है. वापस