लाइफ़साइकल की जानकारी वाले कॉम्पोनेंट के साथ लाइफ़साइकल मैनेज करना Android Jetpack का हिस्सा है.

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

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

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

Android फ़्रेमवर्क में परिभाषित किए गए ज़्यादातर ऐप्लिकेशन कॉम्पोनेंट में लाइफ़साइकल डेटा से जुड़े हैं. लाइफ़साइकल को ऑपरेटिंग सिस्टम से मैनेज किया जाता है या . ये Android के काम करने के तरीके के लिए खास हैं और आपके ऐप्लिकेशन को इनका सम्मान करना चाहिए. ऐसा न करने पर मेमोरी लीक हो सकती है या यहां तक कि ऐप्लिकेशन क्रैश होने की समस्या भी आती है.

मान लें कि हमारी एक गतिविधि, स्क्रीन पर डिवाइस की जगह की जानकारी दिखा रही है. ऐप्लिकेशन सामान्य तौर पर लागू होने वाला तरीका कुछ ऐसा हो सकता है:

internal class MyLocationListener(
        private val context: Context,
        private val callback: (Location) -> Unit
) {

    fun start() {
        // connect to system location service
    }

    fun stop() {
        // disconnect from system location service
    }
}

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this) { location ->
            // update UI
        }
    }

    public override fun onStart() {
        super.onStart()
        myLocationListener.start()
        // manage other components that need to respond
        // to the activity lifecycle
    }

    public override fun onStop() {
        super.onStop()
        myLocationListener.stop()
        // manage other components that need to respond
        // to the activity lifecycle
    }
}

class MyLocationListener {
    public MyLocationListener(Context context, Callback callback) {
        // ...
    }

    void start() {
        // connect to system location service
    }

    void stop() {
        // disconnect from system location service
    }
}

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    @Override
    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, (location) -> {
            // update UI
        });
    }

    @Override
    public void onStart() {
        super.onStart();
        myLocationListener.start();
        // manage other components that need to respond
        // to the activity lifecycle
    }

    @Override
    public void onStop() {
        super.onStop();
        myLocationListener.stop();
        // manage other components that need to respond
        // to the activity lifecycle
    }
}

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

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

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this) { location ->
            // update UI
        }
    }

    public override fun onStart() {
        super.onStart()
        Util.checkUserStatus { result ->
            // what if this callback is invoked AFTER activity is stopped?
            if (result) {
                myLocationListener.start()
            }
        }
    }

    public override fun onStop() {
        super.onStop()
        myLocationListener.stop()
    }

}

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, location -> {
            // update UI
        });
    }

    @Override
    public void onStart() {
        super.onStart();
        Util.checkUserStatus(result -> {
            // what if this callback is invoked AFTER activity is stopped?
            if (result) {
                myLocationListener.start();
            }
        });
    }

    @Override
    public void onStop() {
        super.onStop();
        myLocationListener.stop();
    }
}

androidx.lifecycle पैकेज ऐसी क्लास और इंटरफ़ेस उपलब्ध कराता है जो ऐप्लिकेशन में इन समस्याओं को हल करने में आपकी मदद करते हैं सुरक्षित और अलग तरीके से काम करते हैं.

लाइफ़साइकल

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

Lifecycle दो मुख्य फ़ॉर्मैट का इस्तेमाल करता है इन्यूमरेशन: इनसे जुड़े कॉम्पोनेंट के लाइफ़साइकल के स्टेटस को ट्रैक किया जा सकता है:

इवेंट

लाइफ़साइकल इवेंट, जिन्हें फ़्रेमवर्क और Lifecycle क्लास. ये इवेंट, गतिविधियों और फ़्रैगमेंट में कॉलबैक इवेंट को मैप करते हैं.

राज्य

इसके ज़रिए ट्रैक किए गए कॉम्पोनेंट की मौजूदा स्थिति Lifecycle ऑब्जेक्ट.

अलग-अलग स्थितियों को ग्राफ़ के नोड और इवेंट के बीच के किनारों के रूप में समझें इन नोड को प्रभावित करता है.

कोई क्लास, लागू करके कॉम्पोनेंट के लाइफ़साइकल स्टेटस को मॉनिटर कर सकती है DefaultLifecycleObserver और मिलते-जुलते तरीकों में बदलाव करना. जैसे, onCreate, onStart वगैरह. इसके बाद, addObserver() Lifecycle का तरीका क्लास पास करना और आपके ऑब्ज़र्वर का इंस्टेंस पास करना, जैसा कि नीचे दिखाया गया है उदाहरण:

class MyObserver : DefaultLifecycleObserver {
    override fun onResume(owner: LifecycleOwner) {
        connect()
    }

    override fun onPause(owner: LifecycleOwner) {
        disconnect()
    }
}

myLifecycleOwner.getLifecycle().addObserver(MyObserver())

public class MyObserver implements DefaultLifecycleObserver {
    @Override
    public void onResume(LifecycleOwner owner) {
        connect()
    }

    @Override
    public void onPause(LifecycleOwner owner) {
        disconnect()
    }
}

myLifecycleOwner.getLifecycle().addObserver(new MyObserver());

ऊपर दिए गए उदाहरण में, myLifecycleOwner ऑब्जेक्ट LifecycleOwner का इंटरफ़ेस देखें, जिसके बारे में नीचे दिए गए सेक्शन में बताया गया है.

LifecycleOwner

LifecycleOwner एक तरीका वाला इंटरफ़ेस जो बताता है कि क्लास में Lifecycle. इसमें एक है तरीका, getLifecycle() जिसे क्लास को लागू करना होता है. अगर पूरे ऐप्लिकेशन की लाइफ़साइकल मैनेज करने की कोशिश की जा रही है इसके बजाय, इसे प्रोसेस करें, ProcessLifecycleOwner.

यह इंटरफ़ेस, व्यक्तिगत खाते से Lifecycle Fragment और AppCompatActivity जैसी क्लास का इस्तेमाल करता है और कॉम्पोनेंट लिखने की अनुमति देता है काम करते हैं. कोई भी कस्टम ऐप्लिकेशन क्लास, LifecycleOwner इंटरफ़ेस पर कॉपी करने की सुविधा मिलती है.

लागू करने वाले कॉम्पोनेंट DefaultLifecycleObserver यह लागू करने वाले कॉम्पोनेंट के साथ, बिना किसी रुकावट के काम करता है LifecycleOwner क्योंकि कोई मालिक एक लाइफ़साइकल दे सकता है, जिसे ऑब्ज़र्वर रजिस्टर कर सकता है वीडियो देखने.

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

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this, lifecycle) { location ->
            // update UI
        }
        Util.checkUserStatus { result ->
            if (result) {
                myLocationListener.enable()
            }
        }
    }
}

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, getLifecycle(), location -> {
            // update UI
        });
        Util.checkUserStatus(result -> {
            if (result) {
                myLocationListener.enable();
            }
        });
  }
}

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

इस इस्तेमाल के उदाहरण को आसान बनाने के लिए, Lifecycle क्लास की अनुमति है अन्य ऑब्जेक्ट सबमिट करें.

internal class MyLocationListener(
        private val context: Context,
        private val lifecycle: Lifecycle,
        private val callback: (Location) -> Unit
): DefaultLifecycleObserver {

    private var enabled = false

    override fun onStart(owner: LifecycleOwner) {
        if (enabled) {
            // connect
        }
    }

    fun enable() {
        enabled = true
        if (lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
            // connect if not connected
        }
    }

    override fun onStop(owner: LifecycleOwner) {
        // disconnect if connected
    }
}

class MyLocationListener implements DefaultLifecycleObserver {
    private boolean enabled = false;
    public MyLocationListener(Context context, Lifecycle lifecycle, Callback callback) {
       ...
    }

    @Override
    public void onStart(LifecycleOwner owner) {
        if (enabled) {
           // connect
        }
    }

    public void enable() {
        enabled = true;
        if (lifecycle.getCurrentState().isAtLeast(STARTED)) {
            // connect if not connected
        }
    }

    @Override
    public void onStop(LifecycleOwner owner) {
        // disconnect if connected
    }
}

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

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

कस्टम LifecycleOwner को लागू करना

सपोर्ट लाइब्रेरी 26.1.0 और इसके बाद के वर्शन में फ़्रैगमेंट और गतिविधियां पहले से लागू हैं LifecycleOwner इंटरफ़ेस पर कॉपी करने की सुविधा मिलती है.

अगर आपके पास कोई कस्टम क्लास है, जिसे LifecycleOwner, आप ऐप्लिकेशन, लाइफ़साइकल रजिस्टर क्लास के लिए इवेंट फ़ॉरवर्ड करना होता है, लेकिन आपको नीचे दिए गए तरीके से उस क्लास में इवेंट फ़ॉरवर्ड करने होंगे कोड का उदाहरण:

class MyActivity : Activity(), LifecycleOwner {

    private lateinit var lifecycleRegistry: LifecycleRegistry

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        lifecycleRegistry = LifecycleRegistry(this)
        lifecycleRegistry.markState(Lifecycle.State.CREATED)
    }

    public override fun onStart() {
        super.onStart()
        lifecycleRegistry.markState(Lifecycle.State.STARTED)
    }

    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }
}

public class MyActivity extends Activity implements LifecycleOwner {
    private LifecycleRegistry lifecycleRegistry;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        lifecycleRegistry = new LifecycleRegistry(this);
        lifecycleRegistry.markState(Lifecycle.State.CREATED);
    }

    @Override
    public void onStart() {
        super.onStart();
        lifecycleRegistry.markState(Lifecycle.State.STARTED);
    }

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return lifecycleRegistry;
    }
}

लाइफ़साइकल की जानकारी वाले कॉम्पोनेंट के लिए सबसे सही तरीके

• अपने यूज़र इंटरफ़ेस (यूआई) कंट्रोलर (ऐक्टिविटी और फ़्रैगमेंट) को जितना हो सके उतना छोटा रखें. वे उन्हें अपना डेटा हासिल करने की कोशिश नहीं करनी चाहिए; इसके बजाय, किसी ऐसा करने के लिए ViewModel, साथ ही, आपको LiveData के बारे में भी जानकारी मिल सकती है ऑब्जेक्ट को दिखाने के लिए किया जा सकता है.
• डेटा पर आधारित यूज़र इंटरफ़ेस (यूआई) लिखने की कोशिश करें, जहां आपके यूज़र इंटरफ़ेस (यूआई) कंट्रोलर की ज़िम्मेदारी डेटा में बदलाव होने पर व्यू को अपडेट करें या उपयोगकर्ता की कार्रवाइयों की सूचना ViewModel.
• अपने डेटा लॉजिक को अपने ViewModel क्लास. ViewModel को विज्ञापन दिखाना चाहिए आपके यूज़र इंटरफ़ेस (यूआई) कंट्रोलर और बाकी ऐप्लिकेशन के बीच कनेक्टर के तौर पर. होना हालाँकि, ध्यान रखें कि यह ViewModel का डेटा फ़ेच करने की ज़िम्मेदारी आपकी है. उदाहरण के लिए, किसी नेटवर्क से. इसके बजाय, ViewModel को कॉल करना चाहिए डेटा फ़ेच करने के लिए सही कॉम्पोनेंट चुनें. इसके बाद, यूज़र इंटरफ़ेस (यूआई) कंट्रोलर.
• डेटा बाइंडिंग का इस्तेमाल करके, आपके व्यू और यूज़र इंटरफ़ेस (यूआई) कंट्रोलर के बीच साफ़ इंटरफ़ेस. इसकी मदद से, ये काम किए जा सकते हैं अपने व्यू को ज़्यादा डिक्लेरेटिव बनाएं. साथ ही, उस अपडेट कोड को छोटा करें जिसकी आपको ज़रूरत है अपनी गतिविधियों और फ़्रैगमेंट में लिखें. अगर आप Java में ऐसा करना पसंद करते हैं, तो प्रोग्रामिंग भाषा, तो किसी ऐसी बॉयलरप्लेट से बचने के लिए बटर नाइफ़ और एक बेहतर ऐब्स्ट्रैक्ट होता हो.
• अगर आपका यूज़र इंटरफ़ेस (यूआई) जटिल है, तो प्रज़ेंटर क्लास का इस्तेमाल करें. यह एक मुश्किल काम हो सकता है, लेकिन अपने यूज़र इंटरफ़ेस (यूआई) के कॉम्पोनेंट की जांच को आसान बनाएं.
• View या Activity का रेफ़रंस देने से बचें आपके ViewModel में संदर्भ दिया गया है. अगर कॉन्फ़िगरेशन में बदलाव होने पर ViewModel, गतिविधि से बाहर है, तो आपकी गतिविधि लीक हो जाती है और उसे कचरा इकट्ठा करने वाला डिवाइस सही तरीके से नष्ट नहीं करता है.
• मैनेज करने के लिए, Kotlin कोरूटीन का इस्तेमाल करें लंबे समय तक चलने वाले टास्क और अन्य कार्रवाइयां, जो एसिंक्रोनस रूप से चल सकती हैं.

लाइफ़साइकल की जानकारी वाले कॉम्पोनेंट के लिए, इस्तेमाल के उदाहरण

लाइफ़साइकल की जानकारी वाले कॉम्पोनेंट से, लाइफ़साइकल को मैनेज करना आसान हो जाता है का पता लगाया जा सकता है. यहां इसके कुछ उदाहरण दिए गए हैं:

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

स्टॉप इवेंट मैनेज करना

जब Lifecycle, AppCompatActivity से जुड़ा हो या Fragment, Lifecycle की स्थिति में बदलाव CREATED और ON_STOP इवेंट को तब भेजा जाता है, जब AppCompatActivity या Fragment का onSaveInstanceState() को कॉल किया जाता है.

जब Fragment या AppCompatActivity की स्थिति को इसके ज़रिए सेव किया जाता है onSaveInstanceState(), यह यूज़र इंटरफ़ेस (यूआई) है उसे तब तक नहीं बदला जा सकता, जब तक कि ON_START है कॉल किया गया. राज्य के सेव होने के बाद यूज़र इंटरफ़ेस (यूआई) को बदलने की कोशिश करने से ऐसा हो सकता है आपके ऐप्लिकेशन के नेविगेशन स्टेटस में अंतर होता है. इसकी वजह से, अगर FragmentManager स्टेटस सेव होने के बाद FragmentTransaction. यहां जाएं: ज़्यादा जानकारी के लिए, commit().

LiveData इस तरह के केस को रोकने से रोकता है अगर ऑब्ज़र्वर से जुड़ा Lifecycle है, तो अपने ऑब्ज़र्वर को कॉल करने से कम से कम इतना नहीं STARTED. परदे के पीछे, isAtLeast() इसके ऑब्ज़र्वर को शुरू करने का फ़ैसला लेने से पहले.

माफ़ करें, AppCompatActivity के onStop() वाले तरीके को बाद में कॉल किया जाता है onSaveInstanceState(), इस वजह से, यूज़र इंटरफ़ेस (यूआई) की स्थिति में बदलाव करने की अनुमति नहीं होती है. हालांकि, Lifecycle को अभी तक CREATED राज्य.

इस समस्या से बचने के लिए, beta2 वर्शन में Lifecycle क्लास का इस्तेमाल करें और कम से कम इस रूप में चिह्नित करें CREATED ताकि कोई भी कोड जो मौजूदा स्टेट, इवेंट को डिस्पैच नहीं करता, तब भी रीयल वैल्यू मिलती है. ऐसा तब तक होता है, जब तक सिस्टम onStop() को कॉल नहीं करता.

माफ़ करें, इस समाधान में दो बड़ी समस्याएं हैं:

• एपीआई लेवल 23 और उससे पहले के लेवल पर, Android सिस्टम असल में गतिविधि, भले ही वह किसी दूसरी गतिविधि के आंशिक रूप से कवर की गई हो. अन्य शब्दों, Android सिस्टम onSaveInstanceState() को कॉल करता है लेकिन ज़रूरी नहीं है कि यह onStop() को कॉल करे. इससे संभावित तौर पर लंबा अंतराल जहां ऑब्ज़र्वर को अब भी लगता है कि लाइफ़साइकल चालू है हालांकि, इसकी यूज़र इंटरफ़ेस (यूआई) स्थिति को बदला नहीं जा सकता.
• कोई भी क्लास, जो LiveData क्लास को Lifecycle वर्शन beta 2 और इससे पहले का वर्शन.

अन्य संसाधन

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

सैंपल

• Android आर्किटेक्चर कॉम्पोनेंट का बेसिक सैंपल
• Sunflower एक डेमो ऐप्लिकेशन है, जो आर्किटेक्चर घटक

कोड लैब

• Android लाइफ़साइकल की जानकारी वाले कॉम्पोनेंट

ब्लॉग

• पेश है Android Sunflower