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

1. नई स्मार्टवॉच में

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

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

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

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

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

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

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

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

इसके लिए, आपको ये काम करने होंगे:

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

आपको क्या सीखने को मिलेगा

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

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

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

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

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

3. 3. टास्क 1: GiveActivity के लिए लाइफ़साइकल कॉलबैक जोड़ना

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

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

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

1.2 मुख्य गतिविधि में कॉलबैक लागू करना

1. Android Studio में दो गतिविधियां प्रोजेक्ट खोलें. इसके बाद, प्रोजेक्ट > Android पैनल में जाकर मुख्य गतिविधि खोलें.
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(), onStart(), onCancel(), onStop(), और onDestroy() लाइफ़साइकल कॉलबैक लागू करने के लिए, टेंप्लेट के तौर पर onStart() तरीके का इस्तेमाल करें

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

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

D/MainActivity: -------
D/MainActivity: onCreate
D/MainActivity: onStart
D/MainActivity: onResume

1.3 सेकंड ऐक्टिविटी में लाइफ़साइकल कॉलबैक लागू करें

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

1. सेकंड ऐक्टिविटी खोलें.
2. क्लास में सबसे ऊपर, LOG_TAG वैरिएबल के लिए एक कॉन्सटेंट जोड़ें:

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

1. दूसरी ऐक्टिविटी में, लाइफ़साइकल कॉलबैक जोड़ें और स्टेटमेंट को लॉग करें. (मुख्य गतिविधि के कॉलबैक के तरीकों को कॉपी किया जा सकता है और चिपकाया जा सकता है.)
2. default() मेथड से ठीक पहले, ReturnResponse() तरीके में लॉग स्टेटमेंट जोड़ें:

Log.d(LOG_TAG, "End SecondActivity");

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

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

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

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

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

टास्क 1 का सलूशन कोड

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

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

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

सेकंड ऐक्टिविटी क्लास में सबसे ऊपर:

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

वापसीResponse() तरीका:

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();
}

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

ऊपर बताई गई, मुख्य गतिविधि की तरह ही.

4. 4. टास्क 2: गतिविधि के इंस्टेंस की स्थिति को सेव करना और पहले जैसा करना

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

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

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

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

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

2.1 onSaveEnterpriseState() का इस्तेमाल करके ऐक्टिविटी के इंस्टेंस की स्थिति को सेव करना

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

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

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

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

1. मुख्य गतिविधि खोलें.
2. गतिविधि में onSaveEventState() को लागू करने के इस स्केलिंग को जोड़ें या कोई स्केलेटन ओवरराइड डालने के लिए, कोड > ओवरराइड के तरीकों का इस्तेमाल करें.

@Override
public void onSaveInstanceState(Bundle outState) {
          super.onSaveInstanceState(outState);
}

1. यह देखने के लिए जांच करें कि क्या हेडर अभी दिख रहा है. अगर ऐसा है, तो उस दिखने की स्थिति को getBoolean() तरीके और कुंजी "reply_visible" का इस्तेमाल करके, स्थिति बंडल में डालें.

 if (mReplyHeadTextView.getVisibility() == View.VISIBLE) {
        outState.putBoolean("reply_visible", true);
    }

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

1. उसी चेक के अंदर, बंडल में जवाब देने वाला टेक्स्ट जोड़ें.

outState.putString("reply_text",mReplyTextView.getText().toString());

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

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

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

2.2 onCreate() में गतिविधि इंस्टेंस की स्थिति को पहले जैसा करें

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

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

1. onCreate() मेथड में, व्यू वैरिएबल को FindViewById() के साथ शुरू करने के बाद, एक टेस्ट जोड़कर यह पक्का करें कि send7State की वैल्यू शून्य नहीं है.

// 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() के बाद किए जाने वाले कॉल में एक बंडल होता है, जिसमें उस डेटा को पॉप्यूलेट किया जाता है जिसे आपने onSaveEventState() में सेव किया है.

1. उस जांच के अंदर, "reply_visible" कुंजी से बंडल से मौजूदा विज़िबिलिटी (सही या गलत) पाएं.

if (savedInstanceState != null) {
    boolean isVisible = 
                     savedInstanceState.getBoolean("reply_visible");
}

1. दिखने वाले वैरिएबल के लिए, पिछली लाइन के नीचे टेस्ट जोड़ें.

if (isVisible) {
}

अगर बंडल की स्थिति में request_visible कुंजी मौजूद है (और इसलिए is visibility सही पर सेट है), तो आपको इस स्थिति को पहले जैसा करना होगा.

1. दिखाए जाने वाले टेस्ट के अंदर, हेडर को दिखने लायक बनाएं.

mReplyHeadTextView.setVisibility(View.VISIBLE);

1. "REPLY_text" कुंजी के साथ, बंडल से टेक्स्ट का जवाब देने वाला मैसेज पाएं और उस स्ट्रिंग को दिखाने के लिए, जवाब देने वाले TextView को सेट करें.

mReplyTextView.setText(savedInstanceState.getString("reply_text"));

1. जवाब के TextView को भी दिखने वाला बनाएं:

mReplyTextView.setVisibility(View.VISIBLE);

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

टास्क 2 का सलूशन कोड

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

MainActivity

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

onSaveEventState() तरीका:

@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. कोडिंग

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

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

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

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

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