LiveData के बारे में खास जानकारी Android Jetpack का हिस्सा है.

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

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

आपके पास ऐसे ऑब्जेक्ट के साथ जोड़े गए ऑब्ज़र्वर को रजिस्टर करने का विकल्प होता है जो LifecycleOwner इंटरफ़ेस पर कॉपी करने की सुविधा मिलती है. यह संबंध, ऑब्ज़र्वर को तब निकालने देता है, जब संबंधित Lifecycle ऑब्जेक्ट में बदलाव से DESTROYED. यह गतिविधियों और फ़्रैगमेंट के लिए खास तौर पर फ़ायदेमंद है, क्योंकि LiveData ऑब्जेक्ट को मॉनिटर करें जानकारी लीक होने की चिंता न करें—ऐक्टिविटी और फ़्रैगमेंट तुरंत उसकी लाइफ़साइकल खत्म होने पर, सदस्यता छोड़ दी जाएगी.

LiveData इस्तेमाल करने के तरीके के बारे में ज़्यादा जानने के लिए, LiveData के साथ काम करना चीज़ें.

LiveData इस्तेमाल करने के फ़ायदे

LiveData का इस्तेमाल करने के ये फ़ायदे हैं:

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

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

डिवाइस की मेमोरी लीक नहीं हुई

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

रोकी गई गतिविधियों की वजह से, कोई क्रैश नहीं हुआ

अगर ऑब्ज़र्वर का लाइफ़साइकल इनऐक्टिव है, जैसे कि तो उसे कोई LiveData इवेंट नहीं मिलता.

अब मैन्युअल तौर पर लाइफ़साइकल हैंडलिंग नहीं करनी होगी

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

हमेशा अप-टू-डेट डेटा

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

कॉन्फ़िगरेशन में सही बदलाव

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

संसाधन शेयर करना

आप LiveData की अवधि बढ़ा सकते हैं सिंगलटन पैटर्न का इस्तेमाल करके सिस्टम सेवाओं को रैप करें, ताकि वे आपके ऐप्लिकेशन में शेयर किए गए वीडियो होते हैं. LiveData ऑब्जेक्ट, सिस्टम सेवा से एक बार कनेक्ट होता है, साथ ही, जिस ऑब्ज़र्वर को संसाधन की ज़रूरत होती है वह सिर्फ़ LiveData देख सकता है ऑब्जेक्ट है. ज़्यादा जानकारी के लिए, Extend LiveData देखें.

LiveData ऑब्जेक्ट के साथ काम करना

साथ काम करने के लिए, यह तरीका अपनाएं LiveData ऑब्जेक्ट:

1. खास तरह का डेटा रखने के लिए, LiveData का इंस्टेंस बनाएं. यह है आम तौर पर आपके ViewModel क्लास.
2. Observer बनाएं ऑब्जेक्ट जो onChanged() तरीका, जिससे यह कंट्रोल होता है कि LiveData ऑब्जेक्ट में मौजूद डेटा को होल्ड पर रखे जाने पर क्या होगा बदलाव. आम तौर पर, यूज़र इंटरफ़ेस (यूआई) कंट्रोलर में Observer ऑब्जेक्ट बनाया जाता है, जैसे कोई ऐक्टिविटी या फ़्रैगमेंट.

3. इसका इस्तेमाल करके Observer ऑब्जेक्ट को LiveData ऑब्जेक्ट में अटैच करें observe() तरीका. observe() तरीका LifecycleOwner ऑब्जेक्ट है. इससे Observer ऑब्जेक्ट, LiveData ऑब्जेक्ट से जुड़ जाता है को बदलावों की सूचना दी जाती है. आम तौर पर, Observer ऑब्जेक्ट को यूज़र इंटरफ़ेस (यूआई) कंट्रोलर, जैसे कि ऐक्टिविटी या फ़्रैगमेंट.

LiveData ऑब्जेक्ट में स्टोर की गई वैल्यू को अपडेट करने पर, यह सभी रजिस्टर किए गए ऑब्ज़र्वर का इस्तेमाल तब तक किया जा सकता है, जब तक अटैच किया गया LifecycleOwner ऐक्टिव है राज्य.

LiveData, यूज़र इंटरफ़ेस (यूआई) कंट्रोलर को अपडेट की सदस्यता लेने की अनुमति देता है. जब डेटा LiveData ऑब्जेक्ट बदलने के दौरान, यूज़र इंटरफ़ेस (यूआई) अपने-आप अपडेट हो जाता है.

LiveData ऑब्जेक्ट बनाना

LiveData एक रैपर है, जिसका इस्तेमाल किसी भी डेटा के साथ किया जा सकता है. इसमें वे ऑब्जेक्ट भी शामिल हैं Collections को लागू करें, जैसे कि List. ऐप्लिकेशन आम तौर पर, LiveData ऑब्जेक्ट आम तौर पर होता है ViewModel में सेव किया गया ऑब्जेक्ट है और इसे गैटर तरीके से ऐक्सेस किया जाता है, जैसा कि नीचे दिखाया गया है उदाहरण:

class NameViewModel : ViewModel() {

    // Create a LiveData with a String
    val currentName: MutableLiveData<String> by lazy {
        MutableLiveData<String>()
    }

    // Rest of the ViewModel...
}

public class NameViewModel extends ViewModel {

    // Create a LiveData with a String
    private MutableLiveData<String> currentName;

    public MutableLiveData<String> getCurrentName() {
        if (currentName == null) {
            currentName = new MutableLiveData<String>();
        }
        return currentName;
    }

    // Rest of the ViewModel...
}

शुरुआत में, LiveData ऑब्जेक्ट में डेटा सेट नहीं होता.

ViewModel क्लास के फ़ायदों और इस्तेमाल के बारे में ज़्यादा जानने के लिए, यहां जाएं: ViewModel गाइड.

LiveData ऑब्जेक्ट पर नज़र रखें

ज़्यादातर मामलों में, ऐप्लिकेशन कॉम्पोनेंट के onCreate() तरीके से LiveData ऑब्जेक्ट ये वजहें हो सकती हैं:

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

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

नीचे दिया गया सैंपल कोड बताता है कि LiveData को मॉनिटर करना कैसे शुरू किया जाता है ऑब्जेक्ट:

class NameActivity : AppCompatActivity() {

    // Use the 'by viewModels()' Kotlin property delegate
    // from the activity-ktx artifact
    private val model: NameViewModel by viewModels()

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

        // Other code to setup the activity...

        // Create the observer which updates the UI.
        val nameObserver = Observer<String> { newName ->
            // Update the UI, in this case, a TextView.
            nameTextView.text = newName
        }

        // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.
        model.currentName.observe(this, nameObserver)
    }
}

public class NameActivity extends AppCompatActivity {

    private NameViewModel model;

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

        // Other code to setup the activity...

        // Get the ViewModel.
        model = new ViewModelProvider(this).get(NameViewModel.class);

        // Create the observer which updates the UI.
        final Observer<String> nameObserver = new Observer<String>() {
            @Override
            public void onChanged(@Nullable final String newName) {
                // Update the UI, in this case, a TextView.
                nameTextView.setText(newName);
            }
        };

        // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.
        model.getCurrentName().observe(this, nameObserver);
    }
}

इस तारीख के बाद observe() को इस तरह कॉल किया गया है: nameObserver पैरामीटर, onChanged() mCurrentName में सेव की गई सबसे नई वैल्यू को तुरंत शुरू कर दिया जाता है. अगर LiveData ऑब्जेक्ट ने mCurrentName में कोई मान सेट नहीं किया है, तो onChanged() कॉल नहीं किया गया.

LiveData ऑब्जेक्ट अपडेट करें

LiveData में सेव किए गए डेटा को अपडेट करने का ऐसा कोई तरीका उपलब्ध नहीं है जो सार्वजनिक तौर पर उपलब्ध हो. कॉन्टेंट बनाने MutableLiveData क्लास दिखाती है setValue(T) और postValue(T) तरीकों को सार्वजनिक रूप से अपडेट कर सकते हैं और अगर आपको एक LiveData ऑब्जेक्ट. आम तौर पर MutableLiveData का इस्तेमाल इसमें किया जाता है: ViewModel और इसके बाद ViewModel सिर्फ़ ऑब्ज़र्वर को LiveData ऑब्जेक्ट दिखाता है, जिनमें बदलाव नहीं किया जा सकता.

ऑब्ज़र्वर संबंध सेट करने के बाद, आप को LiveData ऑब्जेक्ट की मदद से बनाया गया है, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है, जो जब उपयोगकर्ता किसी बटन पर टैप करता है, तो सभी ऑब्ज़र्वर ट्रिगर होते हैं:

button.setOnClickListener {
    val anotherName = "John Doe"
    model.currentName.setValue(anotherName)
}

button.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View v) {
        String anotherName = "John Doe";
        model.getCurrentName().setValue(anotherName);
    }
});

उदाहरण में setValue(T) को कॉल करने पर, ऑब्ज़र्वर उनके onChanged() John Doe मान वाली विधियां. उदाहरण में बताया गया है कि किसी बटन को कितनी बार दबाया गया है, लेकिन mName को अपडेट करने के लिए, setValue() या postValue() को कॉल किया जा सकता है. ऐसा, अलग-अलग तरह की कई किसी नेटवर्क अनुरोध या डेटाबेस लोड की प्रतिक्रिया शामिल करने के कारण पूरा करना; सभी मामलों में, setValue() या postValue() को किया गया कॉल ऑब्ज़र्वर का इस्तेमाल करता है और यूज़र इंटरफ़ेस (यूआई) को अपडेट करता है.

कमरे के साथ LiveData इस्तेमाल करना

Room परसिस्टेंस लाइब्रेरी, मॉनिटर की जा सकने वाली क्वेरी, जो पेज पर वापस दिखती हैं LiveData ऑब्जेक्ट. ऑब्ज़र्व की जा सकने वाली क्वेरी, डेटाबेस ऐक्सेस ऑब्जेक्ट (डीएओ) के हिस्से के तौर पर लिखी जाती हैं.

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

LiveData के साथ कोरूटीन इस्तेमाल करना

LiveData में Kotlin कोरूटीन के साथ काम किया जा सकता है. ज़्यादा जानकारी के लिए, यह देखें Android आर्किटेक्चर कॉम्पोनेंट के साथ Kotlin कोरूटीन इस्तेमाल करें.

ऐप्लिकेशन के आर्किटेक्चर में LiveData

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

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

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

class UserRepository {

    // DON'T DO THIS! LiveData objects should not live in the repository.
    fun getUsers(): LiveData<List<User>> {
        ...
    }

    fun getNewPremiumUsers(): LiveData<List<User>> {
        return getUsers().map { users ->
            // This is an expensive call being made on the main thread and may
            // cause noticeable jank in the UI!
            users
                .filter { user ->
                  user.isPremium
                }
          .filter { user ->
              val lastSyncedTime = dao.getLastSyncedTime()
              user.timeCreated > lastSyncedTime
                }
    }
}

class UserRepository {

    // DON'T DO THIS! LiveData objects should not live in the repository.
    LiveData<List<User>> getUsers() {
        ...
    }

    LiveData<List<User>> getNewPremiumUsers() {
    return Transformations.map(getUsers(),
        // This is an expensive call being made on the main thread and may cause
        // noticeable jank in the UI!
        users -> users.stream()
            .filter(User::isPremium)
            .filter(user ->
                user.getTimeCreated() > dao.getLastSyncedTime())
            .collect(Collectors.toList()));
    }
}

अगर आपको अपने ऐप्लिकेशन की अन्य लेयर में डेटा की स्ट्रीम का इस्तेमाल करना है, तो Kotlin फ़्लो का इस्तेमाल करके और फिर उसेLiveData ViewModel asLiveData() का इस्तेमाल करके. इस कोडलैब में, LiveData के साथ Kotlin Flow का इस्तेमाल करने के बारे में ज़्यादा जानें. Java के साथ बनाए गए कोड बेस के लिए, एक्ज़िकेटर का इस्तेमाल करें कॉलबैक या RxJava के साथ जोड़ा जा सकता है.

LiveData को बढ़ाएं

LiveData, ऑब्ज़र्वर को ऐक्टिव स्टेटस में रखता है, अगर ऑब्ज़र्वर की लाइफ़साइकल या तो STARTED या RESUMED राज्य. नीचे दिया गया सैंपल कोड बताता है कि LiveData क्लास:

class StockLiveData(symbol: String) : LiveData<BigDecimal>() {
    private val stockManager = StockManager(symbol)

    private val listener = { price: BigDecimal ->
        value = price
    }

    override fun onActive() {
        stockManager.requestPriceUpdates(listener)
    }

    override fun onInactive() {
        stockManager.removeUpdates(listener)
    }
}

public class StockLiveData extends LiveData<BigDecimal> {
    private StockManager stockManager;

    private SimplePriceListener listener = new SimplePriceListener() {
        @Override
        public void onPriceChanged(BigDecimal price) {
            setValue(price);
        }
    };

    public StockLiveData(String symbol) {
        stockManager = new StockManager(symbol);
    }

    @Override
    protected void onActive() {
        stockManager.requestPriceUpdates(listener);
    }

    @Override
    protected void onInactive() {
        stockManager.removeUpdates(listener);
    }
}

इस उदाहरण में, प्राइस लिसनर के लागू होने की जानकारी में ये शामिल हैं ज़रूरी तरीके:

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

StockLiveData क्लास का इस्तेमाल इस तरह किया जा सकता है:

public class MyFragment : Fragment() {
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        val myPriceListener: LiveData<BigDecimal> = ...
        myPriceListener.observe(viewLifecycleOwner, Observer<BigDecimal> { price: BigDecimal? ->
            // Update the UI.
        })
    }
}

public class MyFragment extends Fragment {
    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        LiveData<BigDecimal> myPriceListener = ...;
        myPriceListener.observe(getViewLifecycleOwner(), price -> {
            // Update the UI.
        });
    }
}

कॉन्टेंट बनाने observe() तरीका LifecycleOwner को पार करता है फ़्रैगमेंट के व्यू से जुड़ा हुआ होता है. ऐसा करने से पता चलता है कि यह ऑब्ज़र्वर Lifecycle ऑब्जेक्ट से बाउंड है मालिक से जुड़ा हो, जिसका मतलब है:

• अगर Lifecycle ऑब्जेक्ट चालू नहीं है, तो ऑब्ज़र्वर नहीं तब भी कॉल किया जाता है, जब वैल्यू बदल जाती है.
• Lifecycle ऑब्जेक्ट के खत्म होने के बाद, ऑब्ज़र्वर अपने-आप बंद हो जाता है हटाया गया.

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

class StockLiveData(symbol: String) : LiveData<BigDecimal>() {
    private val stockManager: StockManager = StockManager(symbol)

    private val listener = { price: BigDecimal ->
        value = price
    }

    override fun onActive() {
        stockManager.requestPriceUpdates(listener)
    }

    override fun onInactive() {
        stockManager.removeUpdates(listener)
    }

    companion object {
        private lateinit var sInstance: StockLiveData

        @MainThread
        fun get(symbol: String): StockLiveData {
            sInstance = if (::sInstance.isInitialized) sInstance else StockLiveData(symbol)
            return sInstance
        }
    }
}

public class StockLiveData extends LiveData<BigDecimal> {
    private static StockLiveData sInstance;
    private StockManager stockManager;

    private SimplePriceListener listener = new SimplePriceListener() {
        @Override
        public void onPriceChanged(BigDecimal price) {
            setValue(price);
        }
    };

    @MainThread
    public static StockLiveData get(String symbol) {
        if (sInstance == null) {
            sInstance = new StockLiveData(symbol);
        }
        return sInstance;
    }

    private StockLiveData(String symbol) {
        stockManager = new StockManager(symbol);
    }

    @Override
    protected void onActive() {
        stockManager.requestPriceUpdates(listener);
    }

    @Override
    protected void onInactive() {
        stockManager.removeUpdates(listener);
    }
}

और इसे फ़्रैगमेंट में इस तरह इस्तेमाल किया जा सकता है:

class MyFragment : Fragment() {

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        StockLiveData.get(symbol).observe(viewLifecycleOwner, Observer<BigDecimal> { price: BigDecimal? ->
            // Update the UI.
        })

    }

public class MyFragment extends Fragment {
    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        StockLiveData.get(symbol).observe(getViewLifecycleOwner(), price -> {
            // Update the UI.
        });
    }
}

कई फ़्रैगमेंट और ऐक्टिविटी, MyPriceListener इंस्टेंस को मॉनिटर कर सकती हैं. LiveData, सिस्टम सर्विस से सिर्फ़ तब कनेक्ट होता है, जब इनमें से एक या उससे ज़्यादा जानकारी दिखती है और सक्रिय हों.

LiveData में बदलाव करना

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

Transformations.map()

LiveData ऑब्जेक्ट में स्टोर की गई वैल्यू पर फ़ंक्शन लागू करता है और नतीजे को डाउनस्ट्रीम लागू करता है.

val userLiveData: LiveData<User> = UserLiveData()
val userName: LiveData<String> = userLiveData.map {
    user -> "${user.name} ${user.lastName}"
}

LiveData<User> userLiveData = ...;
LiveData<String> userName = Transformations.map(userLiveData, user -> {
    user.name + " " + user.lastName
});

Transformations.switchMap()

map() की तरह, LiveData में स्टोर वैल्यू पर फ़ंक्शन लागू करता है ऑब्जेक्ट को खोलता है और नतीजे को डाउनस्ट्रीम में भेजता है. फ़ंक्शन पास हो गया switchMap() को LiveData ऑब्जेक्ट देना होगा, जैसा कि यहां दिया गया उदाहरण देखें:

private fun getUser(id: String): LiveData<User> {
  ...
}
val userId: LiveData<String> = ...
val user = userId.switchMap { id -> getUser(id) }

private LiveData<User> getUser(String id) {
  ...;
}

LiveData<String> userId = ...;
LiveData<User> user = Transformations.switchMap(userId, id -> getUser(id) );

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

अगर आपको लगता है कि आपकोLifecycle ViewModel ऑब्जेक्ट, a बदलाव एक बेहतर समाधान है. उदाहरण के लिए, मान लें कि आपके पास एक यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट, जो पते को स्वीकार करता है और उसका पिन कोड देता है इससे पहले ही अपने कारोबार के हिसाब से name@yourcompany.com जैसा कोई ईमेल पता बनाएं. इस कॉम्पोनेंट के लिए, छोटे ViewModel को इस तरह लागू किया जा सकता है नीचे दिए गए सैंपल कोड की मदद से दिखाया गया है:

class MyViewModel(private val repository: PostalCodeRepository) : ViewModel() {

    private fun getPostalCode(address: String): LiveData<String> {
        // DON'T DO THIS
        return repository.getPostCode(address)
    }
}

class MyViewModel extends ViewModel {
    private final PostalCodeRepository repository;
    public MyViewModel(PostalCodeRepository repository) {
       this.repository = repository;
    }

    private LiveData<String> getPostalCode(String address) {
       // DON'T DO THIS
       return repository.getPostCode(address);
    }
}

इसके बाद, यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट का पिछले LiveData ऑब्जेक्ट से रजिस्ट्रेशन रद्द करना होगा और जब भी यह getPostalCode() को कॉल करे, तो नए इंस्टेंस में रजिस्टर करें. तय सीमा में इसके अलावा, अगर यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट को फिर से बनाया गया है, तो यह पिछले कॉल के नतीजे का इस्तेमाल करने के बजाय repository.getPostCode() तरीका.

इसके बजाय, आप पिन कोड लुकअप को पता इनपुट, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:

class MyViewModel(private val repository: PostalCodeRepository) : ViewModel() {
    private val addressInput = MutableLiveData<String>()
    val postalCode: LiveData<String> = addressInput.switchMap {
            address -> repository.getPostCode(address) }


    private fun setInput(address: String) {
        addressInput.value = address
    }
}

class MyViewModel extends ViewModel {
    private final PostalCodeRepository repository;
    private final MutableLiveData<String> addressInput = new MutableLiveData();
    public final LiveData<String> postalCode =
            Transformations.switchMap(addressInput, (address) -> {
                return repository.getPostCode(address);
             });

  public MyViewModel(PostalCodeRepository repository) {
      this.repository = repository
  }

  private void setInput(String address) {
      addressInput.setValue(address);
  }
}

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

इस तरीके से, ऐप्लिकेशन के निचले लेवल पर ऐसे LiveData ऑब्जेक्ट बनाए जा सकते हैं जो और मांग पर, लेज़ी तरीके से कैलकुलेट किए जाते हैं. ViewModel ऑब्जेक्ट आसानी से फ़ाइलें हासिल कर सकता है LiveData ऑब्जेक्ट का रेफ़रंस देता है और उसके ऊपर बदलाव के नियम तय करता है उन्हें.

नए बदलाव लाएं

एक दर्जन अलग-अलग तरह के बदलाव हैं जो आपके काम में मददगार हो सकते हैं का इस्तेमाल कर सकते हैं, लेकिन वे डिफ़ॉल्ट रूप से उपलब्ध नहीं होते हैं. अपने हिसाब से बदलाव करने का तरीका क्या तुम MediatorLiveData का इस्तेमाल कर सकती हो क्लास, जिसकी मदद से अन्य LiveData ऑब्जेक्ट और उनकी ओर से जनरेट होने वाले इवेंट प्रोसेस करता है. MediatorLiveData अपने यूआरएल को सही तरीके से स्टेट को सोर्स LiveData ऑब्जेक्ट की वैल्यू में बदलें. इस पैटर्न के बारे में ज़्यादा जानने के लिए, देखें दस्तावेज़ Transformations क्लास.

एक से ज़्यादा LiveData सोर्स मर्ज करना

MediatorLiveData है LiveData की एक सब-क्लास है, जो आपको कई LiveData सोर्स मर्ज करने की सुविधा मिलती है. MediatorLiveData को मॉनिटर करने वाले लोग इसके बाद, जब भी कोई ओरिजनल LiveData सोर्स ऑब्जेक्ट होता है, तो ऑब्जेक्ट ट्रिगर हो जाते हैं बदलें.

उदाहरण के लिए, अगर आपके यूज़र इंटरफ़ेस (यूआई) में ऐसा LiveData ऑब्जेक्ट है जिसे अपडेट किया जा सकता है एक लोकल डेटाबेस या नेटवर्क है, तो आपके पास इन सोर्स को MediatorLiveData ऑब्जेक्ट:

• डेटाबेस में सेव किए गए डेटा से जुड़ा LiveData ऑब्जेक्ट.
• नेटवर्क से ऐक्सेस किए गए डेटा से जुड़ा LiveData ऑब्जेक्ट.

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

अन्य संसाधन

इस बारे में ज़्यादा जानने के लिए LiveData क्लास, सलाह लें के लिए संसाधन उपलब्ध हैं.

सैंपल

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

कोड लैब

• दृश्य (Java) (कोटलिन)
• Kotlin फ़्लो और LiveData की मदद से, ऐडवांस कोरूटीन के बारे में जानें

ब्लॉग

• ViewModels और LiveData: पैटर्न + एंटीपैटर्न
• ViewModel के अलावा का LiveData — ट्रांसफ़ॉर्मेशन का इस्तेमाल करके रिऐक्टिव पैटर्न और MediatorLiveData
• SnackBar, नेविगेशन, और अन्य इवेंट के साथ LiveData (SingleLiveEvent का मामला)

वीडियो

• Jetpack LiveData
• LiveData की मदद से मनोरंजन करना (Android Dev समिट '18)