एंड्रॉइड में RxJava का उपयोग कब करें और एंड्रॉइड आर्किटेक्चर घटकों से LiveData का उपयोग कब करें?


185

मुझे एंड्रॉइड आर्किटेक्चर कंपोनेंट्स से एंड्रॉइड और लाइवडाटा में RxJava का उपयोग करने का कारण नहीं मिल रहा है। यह वास्तव में मददगार होगा यदि दोनों के बीच के यूसेज और अंतर को कोड के रूप में नमूना उदाहरण के साथ समझाया जाए जो दोनों के बीच के अंतर को बताता है।


5
क्या आपको अभी तक एक अच्छा कारण मिला? मैं भी यही सोच रहा हूँ ...
इगोरगानापोलस्की

जवाबों:


117

Android LiveData मूल पर्यवेक्षक पैटर्न का एक प्रकार है, जिसमें सक्रिय / निष्क्रिय बदलाव शामिल हैं। जैसे, यह अपने दायरे में बहुत प्रतिबंधक है।

Android LiveData में वर्णित उदाहरण का उपयोग करते हुए , स्थान डेटा की निगरानी के लिए एक वर्ग बनाया जाता है, और आवेदन स्थिति के आधार पर रजिस्टर और अपंजीकृत किया जाता है।

RxJava उन ऑपरेटरों को प्रदान करता है जो बहुत अधिक सामान्यीकृत हैं। मान लेते हैं कि यह अवलोकन स्थान डेटा प्रदान करेगा:

Observable<LocationData> locationObservable;

Observable.create()कॉल बैक ऑपरेशंस को मैप करने के लिए ऑब्जर्वेबल के कार्यान्वयन का निर्माण किया जा सकता है । जब अवलोकन योग्य सदस्यता ली जाती है, तो कॉल बैक पंजीकृत होता है, और जब यह सदस्यता समाप्त हो जाती है, तो कॉल बैक अपंजीकृत होता है। कार्यान्वयन उदाहरण में प्रदान किए गए कोड के समान दिखता है।

आइए यह भी मान लें कि आपके पास एक अवलोकन योग्य है जो अनुप्रयोग के सक्रिय होने पर सच का उत्सर्जन करता है:

Observable<Boolean> isActive;

फिर आप निम्नलिखित द्वारा LiveData की सभी कार्यक्षमता प्रदान कर सकते हैं

Observable<LocationData> liveLocation =
  isActive
    .switchMap( active -> active ? locationObservable : Observable.never() );

switchMap()ऑपरेटर या तो एक धारा के रूप में वर्तमान स्थान, या कुछ भी नहीं प्रदान करेगा यदि आवेदन सक्रिय नहीं है। एक बार आपके पास liveLocationदेखने योग्य होने के बाद, RxJava ऑपरेटरों का उपयोग करके बहुत सी चीजें आप इसके साथ कर सकते हैं। मेरा पसंदीदा उदाहरण है:

liveLocation.distinctUntilChanged()
  .filter( location -> isLocationInAreaOfInterest( location ) )
  .subscribe( location -> doSomethingWithNewLocation( location ) );

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

RxJava की बात यह है कि यह एक ब्रह्मांड में नियंत्रण और समय को जोड़ती है, पुस्तकालय से प्रदान किए गए संचालन या आपके द्वारा प्रदान किए जाने वाले कस्टम संचालन का उपयोग करते हुए।

LiveData उस ब्रह्मांड के केवल एक छोटे से हिस्से को संबोधित करता है, जो इमारत के बराबर है liveLocation


2
धन्यवाद, LiveData डॉक्स अब किसी स्थान के नमूने का संदर्भ नहीं देता है। यहां अधिक दिलचस्प बिंदु (स्थान के नमूने के साथ) हैं: androidkt.com/livedata
डैनियल विल्सन

5
@DanielWilson लिंक अब उपलब्ध नहीं है।
तुरा

यार मुझे याद नहीं है कि wtf उस लिंक पर था: DI एक लाइव डेटा के लिए मार्क एलिसन के सैंपल कोड की तरह: blog.stylingandroid.com/altecture-compenders-livedata
डैनियल विल्सन

3
The point of RxJava is that it combines control and timing into a single universe, using operations provided from the library, or even custom operations that you provide. लेकिन LiveData जीवन चक्र के बारे में पता नहीं है। यदि हम Rx का उपयोग करते हैं, तो क्या हमें जीवनचक्र में बदलाव नहीं करना पड़ेगा?
स्पार्कर .0 आई

@ Sparker0i को यहाँ पॉइंट मिला। RxJava जीवन चक्र से अवगत नहीं है। हमें मैन्युअल रूप से संभालना होगा। जहां LiveData में पहले से ही जीवनचक्र का ध्यान रखा जाता है।
aks4125

119

मूल प्रश्न के बारे में, RxJava और LiveData दोनों एक-दूसरे के पूरक हैं।

LiveDataAndroid जीवनचक्र के साथ इसके तंग एकीकरण के साथ, ViewModel परत पर चमकता है और ViewModelRxJavaपरिवर्तनों में अधिक क्षमता प्रदान करता है (जैसा कि @ याकूब डलगिश ने उल्लेख किया है)।

वर्तमान में, हम उपयोग कर रहे हैं RxJava डेटा स्रोत और रिपॉजिटरी लेयर्स में , और यह ViewModels (गतिविधियों / अंशों के डेटा को उजागर करने से पहले) में LiveData(उपयोग करके LiveDataReactiveStreams) में तब्दील हो गया है - इस दृष्टिकोण से काफी खुश हैं।


8
यदि हमने आपको सही तरीके से समझा है, तो LiveData केवल Android UI- विशिष्ट कार्यान्वयन के लिए उपयोगी है। यदि हम केवल क्लीन आर्किटेक्चर के साथ एक जेनेरिक ऐप बना रहे हैं, और इस आर्किटेक्चर को अन्य प्लेटफार्मों के साथ साझा कर रहे हैं, तो RxJava LiveData से बेहतर है?
इगोरगानापोलस्की

@IgorGanapolsky जेनेरिक ऐप के लिए आप किस भाषा / रूपरेखा का उपयोग करते हैं?
kzotin

एंड्रॉइड-इंडिपेंडेंट एपीआई और क्लीन आर्क को जावा / कोटलिन में लिखा गया है।
इगोरगानापोलस्की

1
क्या आप अपने उत्तर में LiveDataReactiveStreams के किसी भी कार्यशील उदाहरण का सुझाव दे सकते हैं?
पवन

2
@kzotin कि आप की जरूरत नहीं है observeOn, LiveDataReactiveStreamsवैसे भी फोन करके करता है LiveData.postValue()। और इसकी कोई गारंटी नहीं है कि आपका subscribeOnसामान्य रूप से कोई प्रभाव पड़ेगा।

77

LiveData और RxJava के बीच कई अंतर हैं:

  1. LiveData एक STREAM नहीं है जबकि RxJava में सब कुछ (शाब्दिक रूप से सब कुछ) एक STREAM है
  2. LiveData एक अवलोकन योग्य डेटा धारक वर्ग है। एक नियमित अवलोकन के विपरीत, LiveData जीवनचक्र के प्रति जागरूक है, जिसका अर्थ है कि यह अन्य ऐप घटकों, जैसे गतिविधियों, अंशों या सेवाओं के जीवनचक्र का सम्मान करता है। यह जागरूकता LiveData को केवल ऐप घटक पर्यवेक्षकों को अपडेट करती है जो एक सक्रिय जीवन चक्र की स्थिति में हैं।
  3. LiveData तुल्यकालिक है , इसलिए आप कोड का एक हिस्सा (नेटवर्क कॉल, डेटाबेस हेरफेर इत्यादि) निष्पादित नहीं कर सकते हैं जैसा कि आप RxJava के साथ करते हैं।
  4. इस जोड़ी का सबसे अधिक फायदा उठाने के लिए आप सबसे अच्छा क्या कर सकते हैं अपने व्यापार तर्क (नेटवर्क कॉल, डेटा हेरफेर आदि ) के लिए RxJava का उपयोग करें, जो कुछ भी ( रिपॉजिटरी में और उससे आगे होता है ) और अपनी प्रस्तुति परत के लिए LiveData का उपयोग करें। इसके द्वारा, आप अपने यूआई के लिए अपने व्यावसायिक तर्क और जीवनचक्र के प्रति सजगता के लिए परिवर्तन और स्ट्रीम क्षमताएं प्राप्त करते हैं।
  5. LiveData और RxJava एक दूसरे की प्रशंसा करते हैं यदि एक साथ उपयोग किया जाता है। मेरा क्या मतलब है, RxJava के साथ सब कुछ करें और अंत में जब आप यूआई को अपडेट करना चाहते हैं, तो अपने ऑब्जर्वेबल को लाइवडेट में बदलने के लिए नीचे दिए गए कोड की तरह कुछ करें। तो, आपका View (UI) ViewModel में LiveData का अवलोकन करता है, जहाँ आपकी LiveData और नॉन-म्यूटेबल MutLiveLiveData (या MutableLiveData, परस्पर LiveData) के अलावा कुछ नहीं है।
  6. तो यहाँ सवाल यह है कि, आपको पहले स्थान पर LiveData का उपयोग क्यों करना चाहिए? जैसा कि आप कोड में नीचे देख सकते हैं, आप अपनी प्रतिक्रिया RxJava से MutableLiveData (या LiveData) में संग्रहीत करते हैं और आपका LiveData जीवनचक्र के प्रति जागरूक है, इसलिए एक तरह से आपका डेटा जीवनचक्र के प्रति सजग है। अब, केवल उस संभावना की कल्पना करें जब आपका डेटा खुद जानता है कि कब और कब-नहीं यूआई को अपडेट करना है।
  7. LiveData का इतिहास नहीं है (केवल वर्तमान स्थिति)। इसलिए, आपको चैट एप्लिकेशन के लिए LiveData का उपयोग नहीं करना चाहिए।
  8. आप RxJava साथ LiveData का उपयोग करते हैं आप की तरह सामान की जरूरत नहीं है MediatorLiveData , SwitchMap आदि वे धारा नियंत्रण उपकरण हैं और RxJava कई बार से है कि कम से बेहतर है।
  9. LiveData को डेटा धारक चीज़ के रूप में देखें और कुछ नहीं। हम यह भी कह सकते हैं कि LiveData जीवनचक्र के प्रति जागरूक उपभोक्ता है।

    public class RegistrationViewModel extends ViewModel {
        Disposable disposable;

        private RegistrationRepo registrationRepo;
        private MutableLiveData<RegistrationResponse> modelMutableLiveData =
                new MutableLiveData<>();

        public RegistrationViewModel() {
        }

        public RegistrationViewModel(RegistrationRepo registrationRepo) {
            this.registrationRepo = registrationRepo;
        }

        public void init(RegistrationModel registrationModel) {
            disposable = registrationRepo.loginForUser(registrationModel)
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(new Consumer<Response<RegistrationResponse>>() {
                        @Override
                        public void accept(Response<RegistrationResponse>
                                                   registrationModelResponse) throws Exception {

                            modelMutableLiveData.setValue(registrationModelResponse.body());
                        }
                    });
        }

        public LiveData<RegistrationResponse> getModelLiveData() {
            return modelMutableLiveData;
        }

       @Override
       protected void onCleared() {
                super.onCleared();
            disposable.dispose();
         }
    }

5
LiveData को डेटा धारक चीज़ के रूप में देखें और कुछ नहीं। ==> यस
लो मोर्डा

3
अच्छा उदाहरण है। आप डिस्पोजेबल की घोषणा करना भूल गए और उन्हें अंदर साफ करना अच्छा होगा onCleared
Snicolas

क्या आप बता सकते हैं कि लिवटा समकालिक कैसे है? जहां तक ​​मुझे पता है कि हम एक और धागे के लिए लवेदाटा वस्तु भेज सकते हैं और फिर उस धागे को स्थगित कर सकते हैं जो पर्यवेक्षक मेनथ्रेड में सुन सकता है।
हितेश बिष्ट

यदि आप फिर से पढ़ते हैं तो मैंने जो लिखा है इसका मतलब है कि आप सिर्फ एक और धागे पर काम नहीं कर सकते हैं (हाँ, मैंने "बस" वहां भी "का उपयोग किया) LiveData का उपयोग करते हुए जैसा कि आप RxJava का उपयोग कर सकते हैं
अभिषेक कुमार

क्या LiveData के लिए जीवन चक्र एक बड़ा अंतर नहीं है? आप 1. वर्णन करते हैं कि आपकी पाइपलाइन को क्या करने की आवश्यकता है और आपके अंतिम परिणाम क्या हैं, 2. "अवलोकन" खंडों में परिणाम की सदस्यता लें, और फिर 3. पाइपलाइन केवल तभी संचालित हो रही है यदि आपका जीवनचक्र राज्य इसकी अनुमति देता है।
Srg

29

वास्तव में, LiveData के लिए एक अनिवार्य रूप से अलग उपकरण नहीं है RxJavaतो क्यों यह जब एक वास्तुकला घटक के रूप में पेश किया गया था, RxJavaएक में observables लिए सभी सदस्यता भंडारण के द्वारा आसानी से जीवन चक्र में कामयाब हो सकता है CompositeDispoable वस्तु और फिर उन्हें में निपटाने onDestroy() की Activity या onDestroyView() की Fragment केवल एक का उपयोग कर कोड की लाइन?

मैंने इस सवाल का पूरी तरह से जवाब दिया है एक बार RxJava का उपयोग करके और फिर यहां LiveData का उपयोग करके एक मूवी सर्च ऐप बनाकर ।

लेकिन संक्षेप में, हाँ, यह हो सकता है, लेकिन इसके लिए पहले बुनियादी जीवन चक्र के ज्ञान के अलावा प्रासंगिक जीवनचक्र के तरीकों की जरूरत होती है। यह अभी भी कुछ के लिए समझ में नहीं आ सकता है, लेकिन तथ्य यह है कि Google I / O 2018 में जेटपैक सत्रों में से एक के अनुसार कई डेवलपर्स जीवन चक्र प्रबंधन परिसर पाते हैं। जीवनचक्र निर्भरता को नहीं संभालने से उत्पन्न होने वाली क्रैश त्रुटियां एक और संकेत हो सकती हैं कि कुछ डेवलपर्स, भले ही जीवनचक्र के जानकार हों, अपने ऐप में उपयोग होने वाली प्रत्येक गतिविधि / परिहास में इस बात का ध्यान रखना भूल जाते हैं। बड़े ऐप्स में यह एक मुद्दा बन सकता है, इसके बावजूद उत्पादकता पर पड़ने वाले नकारात्मक प्रभाव के बावजूद।

लब्बोलुआब यह है कि शुरू करने से LiveData, बड़ी संख्या में डेवलपर्स को जीवन चक्र प्रबंधन, स्मृति रिसाव और दुर्घटना को समझने के बिना भी MVVM को अपनाने की उम्मीद है। भले ही मुझे इसमें कोई संदेह नहीं है कि LiveDataयह RxJavaक्षमताओं और डेवलपर्स को दी जाने वाली शक्ति, प्रतिक्रियाशील प्रोग्रामिंग के मामले में तुलनीय नहीं है और यह कई लोगों के लिए RxJavaएक कठिन अवधारणा और उपकरण है। दूसरी तरफ, मुझे नहीं लगता कि LiveDataयह एक प्रतिस्थापन के लिए है RxJava- यह बस नहीं कर सकता है - लेकिन कई डेवलपर्स द्वारा अनुभव किए गए एक विवादास्पद व्यापक मुद्दे को संभालने के लिए एक बहुत ही सरल उपकरण।

** अद्यतन ** मैंने यहां एक नया लेख जोड़ा है जहां मैंने बताया है कि लाइवडेट का दुरुपयोग करने से अप्रत्याशित परिणाम कैसे हो सकते हैं। RxJava इन स्थितियों में बचाव के लिए आ सकता है



2
"यह क्यों पेश किया गया था जब RxJava आसानी से एक समग्र में सभी सदस्यताएँ संग्रहीत करके जीवनचक्र का प्रबंधन कर सकता था और फिर उन्हें गतिविधि के LiveDataonStop
onDestroy

मेरी समझ से @arekolek: यहां तक ​​कि कंपोजिटडिसपेबलवे को संभालने के लिए जीवन-चक्र के तरीकों को अधिलेखित किया गया है। लेकिन लाइव डेटा में सभी कोड की एक पंक्ति में शामिल होंगे। इसलिए हम कोड की न्यूनतम 20 लाइनें सहेज रहे हैं।
सुरेश

हम एक बेसफ्रैगमेंट को परिभाषित कर सकते हैं और सभी व्युत्पन्न अंशों से अलग होने के लिए डिस्पोजेबल [] सदस्यताएँ () विधि को परिभाषित कर सकते हैं, इस विधि को onCreateView में कॉल करें और एक कंपोजिटडायसोस्पोर्ट में रिटर्न वैल्यू जोड़ें, यह डिसाइड करें कि onDestroyView, अब और नहीं भूल रहा है।
android2013

यह केवल निपटाने की बात नहीं है। RxJava का उपयोग करते हुए, आपको onStop पर निपटाना होगा, फिर onStart / onResume में फिर से सदस्यता लें, कॉन्फ़िगरेशन परिवर्तन संभालें, और अन्य सामान का एक गुच्छा करें। यही कारण है कि RxJava का उपयोग करते हुए बहुत सारे क्रैश होते हैं। LiveData सब कुछ संभालती है, लेकिन RxJava जितना लचीला नहीं है।
user932178

24

जैसा कि आप प्रतिक्रियाशील पारिस्थितिक तंत्र में जानते हैं कि हमारे पास एक ऑब्जर्वेबल है जो डेटा और एक ऑब्जर्वर का उत्सर्जन करता है (इस अवलोकन योग्य उत्सर्जन की सदस्यता लेता है), कुछ भी अजीब नहीं है कि तथाकथित ऑब्जर्वर पैटर्न कैसे काम करता है। एक ऑब्जर्वेबल "चिल्लाता है" कुछ, ऑब्जर्वर को सूचित किया जाता है कि ऑब्जर्वेबल एक निश्चित क्षण में कुछ चिल्लाए।

LiveDataएक पर्यवेक्षक के रूप में सोचें जो आपको पर्यवेक्षकों को प्रबंधित करने की अनुमति देता है जो एक activeराज्य में हैं। अन्य शब्दों में LiveData, एक सरल अवलोकन है, लेकिन जीवन चक्र का भी ध्यान रखता है।

लेकिन आपके द्वारा अनुरोध किए गए दो कोड मामले देखें:

ए) लाइव डेटा

बी) RXJava

ए) यह लाइवडाटा का एक बुनियादी कार्यान्वयन है

1) आप आमतौर पर अभिविन्यास परिवर्तन को बनाए रखने के लिए ViewModel में LiveData को इंस्टेंट करते हैं (आप LiveData हो सकता है जिसे केवल पढ़ा जाता है, या MutableLiveData जो कि लेखन योग्य है, इसलिए आप आमतौर पर कक्षा LiveData से बाहर निकलते हैं)

2) मुख्य गतिविधि की OnCreateविधि में (ViewModel नहीं) आप एक ऑब्जर्वर ऑब्जेक्ट (आमतौर पर एक ऑनचेंज विधि) की "सदस्यता" लेते हैं

3) आप लिंक को स्थापित करने के लिए विधि का पालन करते हैं

पहला ViewModel(व्यावसायिक तर्क का स्वामी)

class ViewModel : ViewModel() { //Point 1

    var liveData: MutableLiveData<Int> = MutableLiveData()

}

और यह MainActivity(जितना संभव हो उतना गूंगा)

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val ViewModelProvider= ViewModelProviders.of(this).get(ViewModel::class.java)

        ViewModelProvider.observe(this, Observer {//Points 2 and 3
            //what you want to observe
        })


        }
    }
}

बी) यह RXJava का मूल कार्यान्वयन है

1) आप एक अवलोकनीय घोषित करते हैं

2) आप एक पर्यवेक्षक की घोषणा करते हैं

3) आप ऑब्जर्वर को ऑब्जर्वर के साथ सब्सक्राइब करें

Observable.just(1, 2, 3, 4, 5, 6) // Point 1

   .subscribe(new Subscriber() {    //Points 2 & 3
       @Override
       public void onCompleted() {
           System.out.println("Complete!");
       }

       @Override
       public void onError(Throwable e) {
       }

       @Override
       public void onNext(Double value) {
           System.out.println("onNext: " + value);
       }
    });

विशेष रूप LiveDataसे प्रयोग किया जाता है Lifecycleऔर अक्सर ViewModel(जैसा कि हमने देखा है) वास्तुकला घटकों के साथ। वास्तव में जब LiveDataएक ViewModel के साथ संयुक्त है , तो आप ऑब्जर्वर में हर बदलाव को वास्तविक समय में अपडेट रखने की अनुमति देते हैं , ताकि घटनाओं को वास्तविक समय में प्रबंधित किया जा सके जहां जरूरत है। जीवन चक्रLiveData की अवधारणा और संबंधित वस्तुओं को जानने के लिए दृढ़ता से उपयोग करने की अनुशंसा की जाती है LifeCycleOwner / LifeCycle , यह भी मैं आपको रूपांतरणों पर एक नज़र रखने का सुझाव दूंगा , यदि आप वास्तविक जीवन परिदृश्यों में लागू करना चाहते हैं। यहां आप महान कॉमन्सवेयर से कुछ उपयोग के मामले पा सकते हैं ।LiveData

मूल रूपLiveDataसे लपेटने के लिए एक सरलीकृतRXJava, कई घटकों में परिवर्तनों का निरीक्षण करने के लिए एक सुरुचिपूर्ण तरीका है, ताकि घटकों के बीच स्पष्टता पर निर्भरता नियमों को बनाए बिना, ताकि आप कोड का बहुत आसान परीक्षण कर सकें और इसे अधिक पठनीय बना सकें। RXJava, आप LiveData की चीजों को करने की अनुमति देता है और बहुत कुछ। RXJava की विस्तारित कार्यक्षमता के कारण, आप दोनों सरल मामलों के लिए LiveData का उपयोग कर सकते हैं या RXJava की सभी शक्ति का उपयोग एंड्रॉइड आर्किटेक्चर घटकों को ViewModel के रूप में करने के लिएRXJavaकर सकते हैं, बेशक इसका मतलब यह है कि यहकहीं अधिक जटिल हो सकता है, बस लगता है कि इसके बजाय सैकड़ों ऑपरेटर हैं। लाइव मैप के स्विचपाइप और मानचित्र (फिलहाल)।

RXJava संस्करण 2 एक पुस्तकालय है जिसने ऑब्जेक्ट ओरिएंटेड प्रतिमान में क्रांति ला दी है, जो कार्यक्रम के प्रवाह को प्रबंधित करने के लिए एक तथाकथित कार्यात्मक तरीका जोड़ रहा है।


4

LiveData एंड्रॉइड आर्किटेक्चर घटकों का एक सबसेट है जो एंड्रॉइड टीम द्वारा विकसित किया गया है।

लाइव डेटा और अन्य आर्किटेक्चर घटकों के साथ, मेमोरी लीक और अन्य समान मुद्दों को आर्किटेक्चर घटकों द्वारा नियंत्रित किया जाता है। चूंकि यह एंड्रॉइड टीम द्वारा विकसित किया गया है, इसलिए यह एंड्रॉइड के लिए सबसे अच्छा है। वे अपडेट भी प्रदान करते हैं जो एंड्रॉइड के नए संस्करणों को संभालते हैं।

यदि आप केवल एंड्रॉइड ऐप डेवलपमेंट में उपयोग करना चाहते हैं, तो एंड्रॉइड आर्किटेक्चर घटकों के लिए जाएं। अन्यथा, यदि आप अन्य जावा ऐप, जैसे वेब ऐप, डेस्कटॉप ऐप आदि का उपयोग करना चाहते हैं, तो RxJava का उपयोग करें


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

2

LiveDataडेटा धारक चीज़ के रूप में और कुछ नहीं। हम यह भी कह सकते हैं कि LiveData जीवनचक्र उपभोक्ता है। LiveDataजीवनचक्र और रिश्तेदार वस्तुओं LifeCycleOwner / LifeCycle की अवधारणा को जानने के लिए दृढ़ता से अनुशंसा की जाती है, आप अपने यूआई के लिए अपने व्यावसायिक तर्क और जीवनचक्र जागरूक ऑपरेशन के लिए रूपांतरण और स्ट्रीम क्षमताएं प्राप्त करते हैं।

आरएक्स शक्तिशाली उपकरण है जो एक सुरुचिपूर्ण घोषणात्मक शैली में समस्या को हल करने में सक्षम बनाता है। यह व्यावसायिक पक्ष विकल्प या सेवा आपी संचालन को संभालता है


0

LiveData की तुलना RxJava में फलों के सलाद के साथ सेब से की जा रही है।

LiveData की तुलना ContentObserver से करें और आप सेब की तुलना सेब से कर रहे हैं। LiveData प्रभावी रूप से ContentObserver के लिए एक जीवनचक्र से अवगत प्रतिस्थापन है।

RxJava की तुलना AsyncTask या किसी अन्य थ्रेडिंग टूल से फलों के सलाद की तुलना संतरे से की जा रही है, क्योंकि RxJava सिर्फ थ्रेडिंग से अधिक मदद करता है।


0
  • LiveData आंशिक रूप से Rx विषय या SharedRxObservable के बराबर है

  • LiveData सदस्यता के जीवनचक्र का प्रबंधन करता है लेकिन Rx विषय सदस्यता को बनाया और मैन्युअल रूप से निपटाया जाना चाहिए

  • LiveData में समाप्ति की स्थिति नहीं है, लेकिन Rx विषय में OnError और OnCompleted है

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.