Android LiveData घटनाएँ

LiveData आपके डेटा और ऑब्जेक्ट्स को जीवन चक्र (LifecycleOwner, आमतौर पर एक Fragment या गतिविधि) के साथ जोड़ने की स्थिति के लिए एक महान उपकरण है।

आमतौर पर, LiveData को ViewModel में रखा जाता है और आपके UI की स्थिति को अपडेट करने के लिए उपयोग किया जाता है। अक्सर, एक ViewModel एक LifecycleOwner बच सकता है और एक LiveData स्थिति बनाए रख सकता है। ऐसा तंत्र उपयुक्त है जब आपको डेटा को बचाने और कुछ समय बाद इसे पुनर्स्थापित करने की आवश्यकता होती है, उदाहरण के लिए, कॉन्फ़िगरेशन परिवर्तन के बाद।

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

उदाहरण के लिए, एक कोड इस तरह:

Observer { handle(it) yourViewModel.liveData.value = null } 

लेकिन इस दृष्टिकोण के कई नुकसान हैं और सभी आवश्यक आवश्यकताओं को पूरा नहीं करता है।

मैं एक घटना तंत्र रखना चाहूंगा कि:

1. केवल सक्रिय ग्राहकों को सूचित करता है
2. सदस्यता के समय पिछले डेटा के बारे में सूचित नहीं करता है,
3. इवेंट की आगे की प्रक्रिया को बाधित करने के लिए संभाले हुए ध्वज को सही पर सेट करने की क्षमता है।

मैंने MutableLiveEvent क्लास को लागू किया, जिसमें उपरोक्त सभी गुण हैं और यह एक सामान्य LiveData की तरह काम कर सकता है।

कैसे उपयोग करें:

 //   EventArgs        class MyIntEventArgs(data: Int) : EventArgs<Int>(data) //  viewModel class MainViewModel : ViewModel() { private val myEventMutable = MutableLiveEvent<MyIntEventArgs>() val myEvent = myEventMutable as LiveData<MyIntEventArgs> fun sendEvent(data: Int) { myEventMutable.value = MyIntEventArgs(data) } } val vm = ViewModelProviders.of(this).get(MainViewModel::class.java) vm.myEvent.observe(this, Observer { //   /* *   ,    , *      ,   handled = true */ it.handled = true }) 

सभी कोड GitHub पर उपलब्ध है , और नीचे मैं कार्यान्वयन के बारे में थोड़ी बात करूंगा।

 class MutableLiveEvent<T : EventArgs<Any>> : MutableLiveData<T>() { internal val observers = ArraySet<PendingObserver<in T>>() @MainThread override fun observe(owner: LifecycleOwner, observer: Observer<in T>) { val wrapper = PendingObserver(observer) observers.add(wrapper) super.observe(owner, wrapper) } override fun observeForever(observer: Observer<in T>) { val wrapper = PendingObserver(observer) observers.add(wrapper) super.observeForever(observer) } @MainThread override fun removeObserver(observer: Observer<in T>) { when (observer) { is PendingObserver -> { observers.remove(observer) super.removeObserver(observer) } else -> { val pendingObserver = observers.firstOrNull { it.wrappedObserver == observer } if (pendingObserver != null) { observers.remove(pendingObserver) super.removeObserver(pendingObserver) } } } } @MainThread override fun setValue(event: T?) { observers.forEach { it.awaitValue() } super.setValue(event) } } 

विचार यह है कि MutableLiveEvent वर्ग के अंदर, अवलोकन और अवलोकन विधि में, एक विशेष आंतरिक वर्ग PendingObserver में ब्राउज़रों को लपेटें, जो वास्तविक ब्राउज़र को केवल एक बार कॉल करता है और यदि लंबित ध्वज सत्य पर सेट है और घटना अभी तक संसाधित नहीं हुई है।

 internal class PendingObserver<T : EventArgs<Any>>(val wrappedObserver: Observer<in T>) : Observer<T> { private var pending = false override fun onChanged(event: T?) { if (pending && event?.handled != true) { pending = false wrappedObserver.onChanged(event) } } fun awaitValue() { pending = true } } 

PendingObserver में, लंबित ध्वज डिफ़ॉल्ट रूप से गलत पर सेट है। यह हमारी सूची से आइटम 2 (पुराने डेटा की सूचना न दें) को हल करता है।

और MutableLiveEvent में कोड

 override fun setValue(event: T?) { observers.forEach { it.awaitValue() } super.setValue(event) } 

पहले सही पर लंबित सेट और उसके बाद ही डेटा को अपडेट करता है। यह दावे 1 के कार्यान्वयन को सुनिश्चित करता है। (अलर्ट केवल सक्रिय ग्राहक)।

अंतिम बिंदु जिसके बारे में मैंने अभी तक बात नहीं की है वह है EventArgs। यह वर्ग एक सामान्यीकरण है जिसमें घटना के आगे के प्रसंस्करण (क्लाज 3) को बाधित करने के लिए एक संभाला हुआ झंडा होता है।

 open class EventArgs<out T>(private val content: T?) { var handled: Boolean = false val data: T? get() { return if (handled) { null } else { content } } } 

यह सब, देखने के लिए धन्यवाद!