लाइफ़साइकल की जानकारी वाले कॉम्पोनेंट (व्यू) की मदद से लाइफ़साइकल मैनेज करना

सिद्धांत और Jetpack Compose में लागू करना

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

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

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

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

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

Kotlin

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
    }
}

Java

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 से पहले पूरा हो जाता है. इससे कॉम्पोनेंट को ज़रूरत से ज़्यादा समय तक चालू रखा जाता है.

Kotlin

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

}

Java

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 ऑब्जेक्ट से ट्रैक किए गए कॉम्पोनेंट की मौजूदा स्थिति.

पहली इमेज. Android ऐक्टिविटी के लाइफ़साइकल की स्थितियां और इवेंट.

स्टेट को ग्राफ़ के नोड और इवेंट को इन नोड के बीच के किनारों के तौर पर माना जाता है.

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

Kotlin

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

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

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

Java

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 में तय किया जाता है. अलग-अलग कॉम्पोनेंट में अपना लॉजिक सेव करने से, गतिविधियों और फ़्रैगमेंट के लॉजिक को मैनेज करना आसान हो जाता है.

Kotlin

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

Java

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 क्लास, अन्य ऑब्जेक्ट को मौजूदा स्थिति के बारे में क्वेरी करने की अनुमति देती है.

Kotlin

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
    }
}

Java

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 क्लास का इस्तेमाल किया जा सकता है. हालांकि, आपको उस क्लास में इवेंट फ़ॉरवर्ड करने होंगे. इसका उदाहरण यहां दिया गया है:

Kotlin

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
    }
}

Java

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 इवेंट को डिसपैच किया जाता है.

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

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

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

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

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

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

अन्य संसाधन

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

सैंपल

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

कोडलैब

ब्लॉग