लाइफ़साइकल की जानकारी वाले कॉम्पोनेंट की मदद से लाइफ़साइकल मैनेज करना   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 वगैरह जैसे मिलते-जुलते तरीकों को बदलकर, कॉम्पोनेंट के लाइफ़साइकल स्टेटस पर नज़र रख सकती है. इसके बाद, Lifecycle क्लास के addObserver() तरीके को कॉल करके और अपने ऑब्ज़र्वर का इंस्टेंस पास करके, ऑब्ज़र्वर जोड़ा जा सकता है. उदाहरण के लिए:

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 देखें.

यह इंटरफ़ेस, Fragment और AppCompatActivity जैसी अलग-अलग क्लास से Lifecycle के मालिकाना हक को ऐब्स्ट्रैक्ट करता है. साथ ही, उनसे काम करने वाले कॉम्पोनेंट लिखने की अनुमति देता है. कोई भी कस्टम ऐप्लिकेशन क्लास, 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 लागू करना

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

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

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 प्रोग्रामिंग भाषा में ऐसा करना है, तो Butter Knife जैसी लाइब्रेरी का इस्तेमाल करें. इससे, आपको बोइलरप्लेट कोड से बचने और बेहतर एब्स्ट्रैक्शन पाने में मदद मिलेगी.
• अगर आपका यूज़र इंटरफ़ेस (यूआई) जटिल है, तो यूआई में बदलाव करने के लिए, प्रज़ेंटर क्लास बनाएं. यह काम मुश्किल हो सकता है, लेकिन इससे आपके यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट की जांच करना आसान हो सकता है.
• अपने ViewModel में View या Activity के संदर्भ का इस्तेमाल करने से बचें. अगर कॉन्फ़िगरेशन में बदलाव होने पर ViewModel, गतिविधि के बाद भी मौजूद रहता है, तो आपकी गतिविधि लीक हो जाती है और उसे गै़रबेज कलेक्टर ठीक से हटा नहीं पाता.
• लंबे समय तक चलने वाले टास्क और ऐसे अन्य ऑपरेशन मैनेज करने के लिए, Kotlin कोरूटीन का इस्तेमाल करें जो एसिंक्रोनस तरीके से चल सकते हैं.

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

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

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

रोकने के इवेंट को मैनेज करना

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

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

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

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

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

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

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

अन्य संसाधन

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

सैंपल

• Sunflower, आर्किटेक्चर कॉम्पोनेंट के साथ सबसे सही तरीके दिखाने वाला डेमो ऐप्लिकेशन

कोडलैब

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

ब्लॉग

• पेश है Android Sunflower