गतिविधि की लाइफ़साइकल

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

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

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

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

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

इसके बाद, यह गतिविधि के बीच के संबंध के बारे में जानकारी देता है और किसी प्रोसेस की वजह से सिस्टम की ओर से खत्म हो जाने की जोखिम की आशंका है. आख़िर में, इसमें बातचीत के दौरान हुए ट्रांज़िशन से जुड़े कई विषयों पर चर्चा की गई है गतिविधि की स्थितियां.

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

ऐक्टिविटी-लाइफ़साइकल के सिद्धांत

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

इमेज 1 में यह मॉडल दिखाया गया है.

पहला डायग्राम. एक सरल गतिविधि की लाइफ़साइकल की इमेज.

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

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

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

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

लाइफ़साइकल कॉलबैक

इस सेक्शन में, गतिविधि की लाइफ़साइकल के दौरान इस्तेमाल किए गए कॉलबैक के तरीके.

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

onCreate()

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

उदाहरण के लिए, आपके onCreate() को लागू करने की प्रोसेस में, डेटा को सूचियों से बाइंड किया जा सकता है. साथ ही, गतिविधि को ViewModel, और कुछ क्लास-स्कोप वैरिएबल को इंस्टैंशिएट करें. इस तरीके से पैरामीटर savedInstanceState, जो कि एक Bundle है ऑब्जेक्ट जिसमें गतिविधि की पहले से सेव की गई स्थिति है. अगर गतिविधि में पहले कभी मौजूद नहीं थी, इसलिए Bundle ऑब्जेक्ट की वैल्यू शून्य होती है.

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

onCreate() तरीके का यह उदाहरण ऐक्टिविटी के लिए बुनियादी सेटअप की जानकारी देता है. जैसे, यूज़र इंटरफ़ेस का एलान करना (एक्सएमएल लेआउट फ़ाइल में तय किया गया है), मेंबर वैरिएबल तय करना, और कॉन्फ़िगर करना कुछ यूज़र इंटरफ़ेस (यूआई) है. इस उदाहरण में, एक्सएमएल लेआउट फ़ाइल फ़ाइल का संसाधन आईडी R.layout.main_activity, setContentView().

lateinit var textView: TextView

// Some transient state for the activity instance.
var gameState: String? = null

override fun onCreate(savedInstanceState: Bundle?) {
    // Call the superclass onCreate to complete the creation of
    // the activity, like the view hierarchy.
    super.onCreate(savedInstanceState)

    // Recover the instance state.
    gameState = savedInstanceState?.getString(GAME_STATE_KEY)

    // Set the user interface layout for this activity.
    // The layout is defined in the project res/layout/main_activity.xml file.
    setContentView(R.layout.main_activity)

    // Initialize member TextView so it is available later.
    textView = findViewById(R.id.text_view)
}

// This callback is called only when there is a saved instance previously saved using
// onSaveInstanceState(). Some state is restored in onCreate(). Other state can optionally
// be restored here, possibly usable after onStart() has completed.
// The savedInstanceState Bundle is same as the one used in onCreate().
override fun onRestoreInstanceState(savedInstanceState: Bundle?) {
    textView.text = savedInstanceState?.getString(TEXT_VIEW_KEY)
}

// Invoked when the activity might be temporarily destroyed; save the instance state here.
override fun onSaveInstanceState(outState: Bundle?) {
    outState?.run {
        putString(GAME_STATE_KEY, gameState)
        putString(TEXT_VIEW_KEY, textView.text.toString())
    }
    // Call superclass to save any view hierarchy.
    super.onSaveInstanceState(outState)
}

TextView textView;

// Some transient state for the activity instance.
String gameState;

@Override
public void onCreate(Bundle savedInstanceState) {
    // Call the superclass onCreate to complete the creation of
    // the activity, like the view hierarchy.
    super.onCreate(savedInstanceState);

    // Recover the instance state.
    if (savedInstanceState != null) {
        gameState = savedInstanceState.getString(GAME_STATE_KEY);
    }

    // Set the user interface layout for this activity.
    // The layout is defined in the project res/layout/main_activity.xml file.
    setContentView(R.layout.main_activity);

    // Initialize member TextView so it is available later.
    textView = (TextView) findViewById(R.id.text_view);
}

// This callback is called only when there is a saved instance previously saved using
// onSaveInstanceState(). Some state is restored in onCreate(). Other state can optionally
// be restored here, possibly usable after onStart() has completed.
// The savedInstanceState Bundle is same as the one used in onCreate().
@Override
public void onRestoreInstanceState(Bundle savedInstanceState) {
    textView.setText(savedInstanceState.getString(TEXT_VIEW_KEY));
}

// Invoked when the activity might be temporarily destroyed; save the instance state here.
@Override
public void onSaveInstanceState(Bundle outState) {
    outState.putString(GAME_STATE_KEY, gameState);
    outState.putString(TEXT_VIEW_KEY, textView.getText());

    // Call superclass to save any view hierarchy.
    super.onSaveInstanceState(outState);
}

एक्सएमएल फ़ाइल तय करने और उसे setContentView() को पास करने के बजाय, आप आपके गतिविधि कोड में नए View ऑब्जेक्ट बना सकता है और नए View ऑब्जेक्ट जोड़कर ViewGroup. इसके बाद आप ViewGroup को setContentView() से रूट करें. यूज़र इंटरफ़ेस बनाने के बारे में ज़्यादा जानने के लिए, यूज़र इंटरफ़ेस से जुड़ा दस्तावेज़ सबमिट करें.

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

onStart()

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

जब गतिविधि 'शुरू किया गया' स्थिति में जाती है, तो लाइफ़साइकल की जानकारी वाला कोई भी कॉम्पोनेंट जुड़ा होता है गतिविधि के लाइफ़साइकल में होता है, ON_START इवेंट.

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

onResume()

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

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

जब कोई रुकावट डालने वाला इवेंट होता है, तो गतिविधि रोकी गई स्थिति में चली जाती है होने की स्थिति में होती है और सिस्टम onPause() कॉलबैक.

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

यहां लाइफ़साइकल की जानकारी देने वाले ऐसे कॉम्पोनेंट का उदाहरण दिया गया है जो कैमरा तब ऐक्सेस करता है, जब कॉम्पोनेंट को ON_RESUME इवेंट मिलता है:

class CameraComponent : LifecycleObserver {
    ...
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun initializeCamera() {
        if (camera == null) {
            getCamera()
        }
    }
    ...
}

public class CameraComponent implements LifecycleObserver {

    ...

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void initializeCamera() {
        if (camera == null) {
            getCamera();
        }
    }
    ...
}

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

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

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

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

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

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

onPause()

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

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

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

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

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

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

LifecycleObserver का यह उदाहरण ON_PAUSE इवेंट पर प्रतिक्रिया देना, पिछले इवेंट जैसा ही होता है ON_RESUME इवेंट का उदाहरण, कैमरे को रिलीज़ करना जो इसके बाद शुरू होता है ON_RESUME इवेंट मिल गया है:

class CameraComponent : LifecycleObserver {
    ...
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun releaseCamera() {
        camera?.release()
        camera = null
    }
    ...
}

public class JavaCameraComponent implements LifecycleObserver {
    ...
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void releaseCamera() {
        if (camera != null) {
            camera.release();
            camera = null;
        }
    }
    ...
}

इस उदाहरण में कैमरा रिलीज़ कोड को LifecycleObserver को ON_PAUSE इवेंट मिला है.

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

इसके बजाय, इस दौरान हेवी-लोड शटडाउन ऑपरेशन शुरू करें onStop(). Reader Revenue Manager को सेट अप करने के बारे में के दौरान किए जाने वाले सही कामों के बारे में जानकारी onStop(), अगला सेक्शन देखें. सेव करने के बारे में ज़्यादा जानकारी डेटा के लिए, स्टेटस सेव करने और वापस लाने के बारे में सेक्शन देखें.

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

अगर गतिविधि 'रोकी गई' स्थिति से वापस 'फिर से शुरू की गई' स्थिति में वापस आ जाती है, तो सिस्टम मेमोरी में मौजूद Activity इंस्टेंस, रीकॉल कर रहा है जब सिस्टम onResume() को शुरू करता है. इस स्थिति में, आपको किसी भी इवेंट के दौरान बनाए गए कॉम्पोनेंट को फिर से शुरू करने की ज़रूरत नहीं है 'फिर से शुरू की गई' स्थिति तक ले जाने वाले कॉलबैक मेथड. अगर गतिविधि पूरी तरह से दिखाई नहीं देता, इसलिए सिस्टम onStop().

onStop()

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

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

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

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

override fun onStop() {
    // Call the superclass method first.
    super.onStop()

    // Save the note's current draft, because the activity is stopping
    // and we want to be sure the current note progress isn't lost.
    val values = ContentValues().apply {
        put(NotePad.Notes.COLUMN_NAME_NOTE, getCurrentNoteText())
        put(NotePad.Notes.COLUMN_NAME_TITLE, getCurrentNoteTitle())
    }

    // Do this update in background on an AsyncQueryHandler or equivalent.
    asyncQueryHandler.startUpdate(
            token,     // int token to correlate calls
            null,      // cookie, not used here
            uri,       // The URI for the note to update.
            values,    // The map of column names and new values to apply to them.
            null,      // No SELECT criteria are used.
            null       // No WHERE columns are used.
    )
}

@Override
protected void onStop() {
    // Call the superclass method first.
    super.onStop();

    // Save the note's current draft, because the activity is stopping
    // and we want to be sure the current note progress isn't lost.
    ContentValues values = new ContentValues();
    values.put(NotePad.Notes.COLUMN_NAME_NOTE, getCurrentNoteText());
    values.put(NotePad.Notes.COLUMN_NAME_TITLE, getCurrentNoteTitle());

    // Do this update in background on an AsyncQueryHandler or equivalent.
    asyncQueryHandler.startUpdate (
            mToken,  // int token to correlate calls
            null,    // cookie, not used here
            uri,    // The URI for the note to update.
            values,  // The map of column names and new values to apply to them.
            null,    // No SELECT criteria are used.
            null     // No WHERE columns are used.
    );
}

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

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

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

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

रुकी हुई स्थिति से, गतिविधि या तो वापस आकर या गतिविधि पूरी होने के बाद बंद हो जाती है. अगर गतिविधि वापस, सिस्टम onRestart() को शुरू करता है. अगर Activity पूरा हो जाता है, तो सिस्टम, onDestroy().

onDestroy()

onDestroy() को गतिविधि खत्म हो जाती है. सिस्टम इस कॉलबैक को इन दो में से किसी एक वजह से शुरू करता है:

1. गतिविधि पूरी हो रही है, क्योंकि उपयोगकर्ता ने इसे पूरी तरह से खारिज कर दिया है गतिविधि या इस वजह से finish() का मतलब है गतिविधि के लिए कॉल किया.
2. कॉन्फ़िगरेशन की वजह से, सिस्टम कुछ समय के लिए गतिविधि बंद कर रहा है बदलाव, जैसे कि डिवाइस घुमाना या मल्टी-विंडो मोड में जाना.

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

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

अगर Activity को फिर से नहीं बनाया जाता है, तो ViewModel में onCleared() तरीका कॉल किया गया, जहां मिटाए जाने से पहले, यह डेटा खाली कर सकता है. इन दो स्थितियों के बीच अंतर करने के लिए, isFinishing() तरीका.

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

onDestroy() कॉलबैक, उन सभी संसाधनों को रिलीज़ करता है जिन्हें पहले रिलीज़ नहीं किया गया था कॉलबैक, जैसे कि onStop().

गतिविधि की स्थिति और मेमोरी से उसे हटाया गया

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

टेबल 1. प्रोसेस लाइफ़साइकल और गतिविधि की स्थिति के बीच संबंध.

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

उपयोगकर्ता, ऐप्लिकेशन मैनेजर का उपयोग करके सेटिंग, का इस्तेमाल बंद करने के लिए किया जा सकता है.

प्रोसेस के बारे में ज़्यादा जानने के लिए, यहां देखें प्रोसेस और थ्रेड खास जानकारी पर टैप करें.

कुछ समय के लिए दिखने वाले यूज़र इंटरफ़ेस (यूआई) की स्थिति को सेव और पहले जैसा करना

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

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

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

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

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

इंस्टेंस की स्थिति

कुछ ऐसे मामले हैं जिनमें सामान्य ऐप्लिकेशन की वजह से आपकी गतिविधि खत्म हो जाती है व्यवहार, जैसे कि जब कोई व्यक्ति 'वापस जाएं' बटन दबाता है या आपकी गतिविधि खुद के विनाश का संकेत देता है finish() तरीका.

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

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

सेव किया गया वह डेटा जिसे सिस्टम, पिछली स्थिति को इंस्टेंस स्टेट कहा जाता है. यह किसी Bundle ऑब्जेक्ट में स्टोर किए गए की-वैल्यू पेयर. डिफ़ॉल्ट रूप से, सिस्टम, जानकारी सेव करने के लिए Bundle इंस्टेंस स्थिति का इस्तेमाल करता है आपकी गतिविधि के लेआउट में, हर View ऑब्जेक्ट के बारे में जानकारी, जैसे कि डाला गया टेक्स्ट मान EditText विजेट.

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

ध्यान दें: Android सिस्टम को आपकी गतिविधि में दृश्य, प्रत्येक व्यू में एक अनन्य आईडी होनी चाहिए, जो android:id एट्रिब्यूट.

Bundle ऑब्जेक्ट, एक से ज़्यादा वैल्यू सुरक्षित रखने के लिए सही नहीं है बहुत मामूली डेटा की ज़रूरत होती है, क्योंकि इसके लिए मुख्य थ्रेड पर सीरियलाइज़ेशन की ज़रूरत होती है और यह इस्तेमाल करता है सिस्टम प्रोसेस मेमोरी. बहुत कम डेटा से भी ज़्यादा डेटा को सुरक्षित रखने के लिए, डेटा के संरक्षण के लिए, एक साथ काम करने वाले स्थानीय तरीकों का इस्तेमाल करते हैं. स्टोरेज, onSaveInstanceState() तरीका, और ViewModel क्लास, जैसा कि में बताया गया है यूज़र इंटरफ़ेस (यूआई) की स्थितियां सेव करें.

onSaveInsertState() का इस्तेमाल करके, आसान और लाइटवेट यूज़र इंटरफ़ेस (यूआई) स्थिति सेव करें

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

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

override fun onSaveInstanceState(outState: Bundle?) {
    // Save the user's current game state.
    outState?.run {
        putInt(STATE_SCORE, currentScore)
        putInt(STATE_LEVEL, currentLevel)
    }

    // Always call the superclass so it can save the view hierarchy state.
    super.onSaveInstanceState(outState)
}

companion object {
    val STATE_SCORE = "playerScore"
    val STATE_LEVEL = "playerLevel"
}

static final String STATE_SCORE = "playerScore";
static final String STATE_LEVEL = "playerLevel";
// ...


@Override
public void onSaveInstanceState(Bundle savedInstanceState) {
    // Save the user's current game state.
    savedInstanceState.putInt(STATE_SCORE, currentScore);
    savedInstanceState.putInt(STATE_LEVEL, currentLevel);

    // Always call the superclass so it can save the view hierarchy state.
    super.onSaveInstanceState(savedInstanceState);
}

ध्यान दें: onSaveInstanceState() नहीं है यह तब कॉल किया जाता है जब उपयोगकर्ता साफ़ तौर पर गतिविधि को बंद करता है या ऐसे अन्य मामलों में कॉल करता है जब finish() पर कॉल किया गया है.

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

सेव की गई इंस्टेंस स्थिति का इस्तेमाल करके गतिविधि यूज़र इंटरफ़ेस (यूआई) स्थिति को पहले जैसा करें

जब आपकी गतिविधि को खत्म करने के बाद उसे फिर से बनाया जाता है, तो आपको आपकी सेव की गई इंस्टेंस स्थिति को Bundle से वापस पा सकता है, आपकी गतिविधि को सेव करता है. दोनों onCreate() और onRestoreInstanceState() कॉलबैक मेथड को वही Bundle मिलता है जिसमें इंस्टेंस की स्थिति की जानकारी.

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

नीचे दिया गया कोड स्निपेट दिखाता है कि आप onCreate() में राज्य का डेटा:

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState) // Always call the superclass first

    // Check whether we're recreating a previously destroyed instance.
    if (savedInstanceState != null) {
        with(savedInstanceState) {
            // Restore value of members from saved state.
            currentScore = getInt(STATE_SCORE)
            currentLevel = getInt(STATE_LEVEL)
        }
    } else {
        // Probably initialize members with default values for a new instance.
    }
    // ...
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState); // Always call the superclass first

    // Check whether we're recreating a previously destroyed instance.
    if (savedInstanceState != null) {
        // Restore value of members from saved state.
        currentScore = savedInstanceState.getInt(STATE_SCORE);
        currentLevel = savedInstanceState.getInt(STATE_LEVEL);
    } else {
        // Probably initialize members with default values for a new instance.
    }
    // ...
}

के दौरान स्थिति को पुनर्स्थापित करने के बजाय onCreate(), आपके पास इसे लागू करने का विकल्प है onRestoreInstanceState(), जिसे सिस्टम onStart() तरीका. सिस्टम, onRestoreInstanceState() अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है यदि पुनर्स्थापित करने के लिए कोई सहेजी गई स्थिति है, तो आपको को यह जांचने की ज़रूरत नहीं है कि Bundle शून्य है या नहीं.

override fun onRestoreInstanceState(savedInstanceState: Bundle?) {
    // Always call the superclass so it can restore the view hierarchy.
    super.onRestoreInstanceState(savedInstanceState)

    // Restore state members from saved instance.
    savedInstanceState?.run {
        currentScore = getInt(STATE_SCORE)
        currentLevel = getInt(STATE_LEVEL)
    }
}

public void onRestoreInstanceState(Bundle savedInstanceState) {
    // Always call the superclass so it can restore the view hierarchy.
    super.onRestoreInstanceState(savedInstanceState);

    // Restore state members from saved instance.
    currentScore = savedInstanceState.getInt(STATE_SCORE);
    currentLevel = savedInstanceState.getInt(STATE_LEVEL);
}

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

गतिविधियों के बीच नेविगेट करना

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

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

किसी अन्य गतिविधि से एक गतिविधि शुरू करना

किसी गतिविधि के लिए अक्सर किसी समय पर दूसरी गतिविधि शुरू करने की ज़रूरत होती है. यह ज़रूरत उदाहरण के लिए, किसी ऐप्लिकेशन को मौजूदा स्क्रीन से नया सवाल.

आपकी गतिविधि नई गतिविधि से नतीजा पाना चाहती है या नहीं, इसके आधार पर शुरू होने वाला है, तो आपको इनमें से किसी एक बटन का इस्तेमाल करके नई गतिविधि startActivity() अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है तरीका या startActivityForResult() तरीका. दोनों ही मामलों में, आप Intent ऑब्जेक्ट पास करते हैं.

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

startActivity()

अगर हाल ही में शुरू की गई गतिविधि के लिए कोई नतीजा देने की ज़रूरत नहीं है, तो मौजूदा गतिविधि इसे शुरू कर सकती है इसके लिए, startActivity() अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है तरीका.

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

val intent = Intent(this, SignInActivity::class.java)
startActivity(intent)

Intent intent = new Intent(this, SignInActivity.class);
startActivity(intent);

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

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

val intent = Intent(Intent.ACTION_SEND).apply {
    putExtra(Intent.EXTRA_EMAIL, recipientArray)
}
startActivity(intent)

Intent intent = new Intent(Intent.ACTION_SEND);
intent.putExtra(Intent.EXTRA_EMAIL, recipientArray);
startActivity(intent);

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

startActivityForresults()

कभी-कभी आप किसी गतिविधि के खत्म होने पर उससे कोई नतीजा पाना चाहते हैं. उदाहरण के लिए, ऐसी गतिविधि जिससे उपयोगकर्ता, संपर्कों की सूची में से किसी व्यक्ति को चुन सकता है. खत्म होने पर, यह एक व्यक्ति को चुना गया. ऐसा करने के लिए, आप startActivityForResult(Intent, int) अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है तरीका है, जहां इंटीजर पैरामीटर से कॉल की पहचान होती है.

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

जब किसी बच्चे की गतिविधि से बाहर निकला जाता है, तो वह setResult(int) को कॉल कर सकता है: मूल डेटा को वापस लौटा देता है. बच्चे की गतिविधि के लिए नतीजे का कोड देना ज़रूरी है, जो कि सामान्य नतीजे हो सकते हैं RESULT_CANCELED, RESULT_OK या कोई कस्टम मान RESULT_FIRST_USER से शुरू.

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

अगर बच्चे की कोई गतिविधि किसी वजह से पूरी नहीं हो पाती है, जैसे कि क्रैश होना, तो गतिविधि को RESULT_CANCELED कोड के साथ एक नतीजा मिलता है.

class MyActivity : Activity() {
    // ...

    override fun onKeyDown(keyCode: Int, event: KeyEvent?): Boolean {
        if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
            // When the user center presses, let them pick a contact.
            startActivityForResult(
                    Intent(Intent.ACTION_PICK,Uri.parse("content://contacts")),
                    PICK_CONTACT_REQUEST)
            return true
        }
        return false
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, intent: Intent?) {
        when (requestCode) {
            PICK_CONTACT_REQUEST ->
                if (resultCode == RESULT_OK) {
                    // A contact was picked. Display it to the user.
                    startActivity(Intent(Intent.ACTION_VIEW, intent?.data))
                }
        }
    }

    companion object {
        internal val PICK_CONTACT_REQUEST = 0
    }
}

public class MyActivity extends Activity {
     // ...

     static final int PICK_CONTACT_REQUEST = 0;

     public boolean onKeyDown(int keyCode, KeyEvent event) {
         if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
             // When the user center presses, let them pick a contact.
             startActivityForResult(
                 new Intent(Intent.ACTION_PICK,
                 new Uri("content://contacts")),
                 PICK_CONTACT_REQUEST);
            return true;
         }
         return false;
     }

     protected void onActivityResult(int requestCode, int resultCode,
             Intent data) {
         if (requestCode == PICK_CONTACT_REQUEST) {
             if (resultCode == RESULT_OK) {
                 // A contact was picked. Display it to the user.
                 startActivity(new Intent(Intent.ACTION_VIEW, data));
             }
         }
     }
 }

गतिविधियों का तालमेल

जब एक गतिविधि दूसरी गतिविधि शुरू होती है, तो दोनों की लाइफ़साइकल ट्रांज़िशन होते हैं. पहली गतिविधि रुक जाती है और 'रोका गया' या 'बंद हो गया' वाली स्थिति में आ जाती है. वहीं, दूसरी गतिविधि गतिविधि बनाई जाती है. इन गतिविधियों के सेव किए गए डेटा को डिस्क में या किसी दूसरी जगह पर शेयर करने पर, यह समझना ज़रूरी है कि पहली गतिविधि दूसरी गतिविधि से पहले पूरी तरह बंद नहीं होती बनाया जाता है. बल्कि, दूसरे विज्ञापन को शुरू करने की प्रोसेस, पहले वाले को रोक रही हूँ.

लाइफ़साइकल कॉलबैक का क्रम अच्छी तरह से तय होता है. खास तौर पर, ऐसा तब होता है, जब दो गतिविधियां उसी प्रक्रिया में—दूसरे शब्दों में, वही ऐप्लिकेशन—और कोई दूसरा शुरू कर रहा है. यहां होने वाली कार्रवाइयों का क्रम यहां दिया गया है जब गतिविधि A, गतिविधि B शुरू करती है:

1. गतिविधि A का onPause() तरीका लागू होता है.
2. गतिविधि B की onCreate(), onStart(), और onResume() तरीके क्रम में लागू होते हैं. गतिविधि B में अब उपयोगकर्ता का फ़ोकस है.
3. अगर अब स्क्रीन पर गतिविधि A नहीं दिख रही है, तो इसका onStop() तरीका लागू होगा.

लाइफ़साइकल कॉलबैक के इस क्रम की मदद से, जानकारी ऐक्सेस कर सकते हैं.