MVVM में ViewModel से लेकर गतिविधि / फ्रैगमेंट तक की घटनाओं को भेजना

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



इसलिए सभी को नमस्कार!

मेरा नाम अलेक्सी है, मैं Home Credit Bank में एक Android डेवलपर हूं।

इस लेख में, मैं ViewModels से लेकर Views (क्रियाएँ / Fragments) तक की घटनाओं को भेजने और प्राप्त करने का हमारा तरीका साझा करूँगा।

हमारे आवेदन में "होम क्रेडिट बैंक से किस्त माल" हम टुकड़ों का उपयोग करते हैं, इसलिए हम उनके बारे में बात करेंगे, लेकिन गतिविधि के लिए भी सब कुछ प्रासंगिक है।

हम क्या चाहते हैं?

हमारे पास एक Fragment है, जिसमें कई ViewModel शामिल हैं, डेटा DataBinding द्वारा बाध्य है। सभी उपयोगकर्ता ईवेंट्स ViewModel प्राप्त करते हैं। यदि ईवेंट एक नेविगेशन एक है: आपको एक और टुकड़ा / गतिविधि खोलने की आवश्यकता है, AlertDialog , AlertDialog , अनुमतियों के लिए एक सिस्टम अनुरोध इत्यादि दिखाएं, फिर इस तरह के आयोजन को टुकड़े में निष्पादित किया जाना चाहिए।

और क्या, वास्तव में, समस्या है?

दृश्य और ViewModels जीवन चक्र असंबंधित हैं। श्रोताओं के साथ बंधना असंभव है, क्योंकि ViewModel को टुकड़ों के बारे में कुछ भी नहीं पता होना चाहिए, और इसमें टुकड़ों का लिंक भी नहीं होना चाहिए, अन्यथा, जैसा कि आप जानते हैं, स्मृति " आनन्दित " होने लगेगी।

Fragments और ViewModels के बीच बातचीत के लिए मानक दृष्टिकोण ViewModel में स्थित LiveData सदस्यता लेना है। LiveData माध्यम से सीधे घटनाओं को प्रसारित करना असंभव है, इस तथ्य के कारण कि यह दृष्टिकोण ध्यान में नहीं रखता है कि क्या घटना पहले ही पूरी हो चुकी है या नहीं।

क्या समाधान मौजूद हैं:

1. SingleLiveEvent उपयोग करें
पेशेवरों: घटना को एक बार निष्पादित किया जाता है।
विपक्ष: एक घटना - एक SingleLiveEvent । बड़ी संख्या में घटनाओं के साथ, एन इवेंट-ऑब्जेक्ट व्यूमॉडल में दिखाई देते हैं, जिनमें से प्रत्येक को टुकड़े में सब्सक्राइब करना होगा।

2. एक अच्छा उदाहरण ।
पेशेवरों: एक घटना को एक बार भी निष्पादित किया जाता है, आप डेटा को व्यूकोड से टुकड़े में स्थानांतरित कर सकते हैं।
विपक्ष: घटना में डेटा की आवश्यकता है, लेकिन अगर आपको डेटा के बिना किसी घटना को निष्पादित करने की आवश्यकता है (val content: T) , तो आपको एक और वर्ग बनाने की आवश्यकता होगी। यह एक प्रकार की घटना को एक बार निष्पादित करने की समस्या को हल नहीं करता है (घटना को एक बार ही निष्पादित किया जाता है, लेकिन इस प्रकार की घटना को कई बार निष्पादित किया जाएगा क्योंकि हम इसे व्यूमॉडल से चलाते हैं)। उदाहरण के लिए, एन-अनुरोध एसिंक्रोनस रूप से चलते हैं, लेकिन कोई नेटवर्क नहीं है। प्रत्येक अनुरोध नेटवर्क त्रुटि के साथ वापस आ जाएगा, और नेटवर्क त्रुटि के बारे में एन घटनाओं के एक टुकड़े में खींच लेगा, एन अलर्ट टुकड़े में खुल जाएगा। उपयोगकर्ता इस तरह के निर्णय को मंजूरी नहीं देगा :)। हमें इस त्रुटि के साथ एक बार संदेश दिखाना चाहिए। दूसरे शब्दों में, इस प्रकार के आयोजन को एक बार निष्पादित किया जाना चाहिए।

निर्णय

हम आधार के रूप में घटना से निपटने की जानकारी को बचाने के लिए SingleLiveEvent का विचार लेते हैं।

संभावित ईवेंट प्रकारों को परिभाषित करें

 enum class Type { EXECUTE_WITHOUT_LIMITS, //    –   ,             EXECUTE_ONCE, //      WAIT_OBSERVER_IF_NEEDED,//    ,     -       WAIT_OBSERVER_IF_NEEDED_AND_EXECUTE_ONCE //    ,     -           } 

एक ईवेंट बेस क्लास बनाएं - NavigationEvent

isHandled इंगित करता है कि क्या घटना प्राप्त हुई थी (हम मानते हैं कि यह निष्पादित किया गया था यदि पर्यवेक्षक को टुकड़े में प्राप्त हुआ था)।

 open class NavigationEvent(var isHandled: Boolean = false, var type: Events.Type) 

एक Emitter वर्ग बनाएं - Emitter

इवेंट एमिटर क्लास को LiveData < NavigationEvent > से विरासत में मिला है। इस वर्ग का उपयोग ViewModel में घटनाओं को भेजने के लिए किया जाएगा।

 class Emitter : MutableLiveData<NavigationEvent>() { private val waitingEvents: ArrayList<NavigationEvent> = ArrayList() private var isActive = false override fun onInactive() { isActive = false } override fun onActive() { isActive = true val postingEvents = ArrayList<NavigationEvent>() waitingEvents .forEach { if (hasObservers()) { this.value = it postingEvents.add(it) } }.also { waitingEvents.removeAll(postingEvents) } } private fun newEvent(event: NavigationEvent, type: Type) { event.type = type this.value = when (type) { Type.EXECUTE_WITHOUT_LIMITS, Type.EXECUTE_ONCE -> if (hasObservers()) event else null Type.WAIT_OBSERVER_IF_NEEDED, Type.WAIT_OBSERVER_IF_NEEDED_AND_EXECUTE_ONCE -> { if (hasObservers() && isActive) event else { waitingEvents.add(event) null } } } } /** Clear All Waiting Events */ fun clearWaitingEvents() = waitingEvents.clear() } 

isActive - हमें यह समझने की आवश्यकता है कि क्या कम से कम एक Observer को Emitter सदस्यता दी गई है। और उस मामले में जब ग्राहक दिखाई दिया है और उसके इंतजार की घटनाएं जमा हो गई हैं, हम इन घटनाओं को भेजते हैं। एक महत्वपूर्ण स्पष्टीकरण: ईवेंट भेजना आवश्यक नहीं है। यह this.postValue(event) माध्यम से नहीं, बल्कि सेटर के माध्यम से इस this.value = event । अन्यथा, ग्राहक को सूची में केवल अंतिम घटना प्राप्त होगी।

एक नई घटना भेजने की विधि, newEvent(event, type) , दो मापदंडों को स्वीकार करता है - वास्तव में, घटना स्वयं और इस घटना का प्रकार।

सभी प्रकार की घटनाओं (लंबे नामों) को याद न रखने के लिए, हम अलग-अलग सार्वजनिक तरीके बनाएंगे जो केवल घटना को ही स्वीकार करेंगे:

 class Emitter : MutableLiveData<NavigationEvent>() { … /** Default: Emit Event for Execution */ fun emitAndExecute(event: NavigationEvent) = newEvent(event, Type.EXECUTE_WITHOUT_LIMITS) /** Emit Event for Execution Once */ fun emitAndExecuteOnce(event: NavigationEvent) = newEvent(event, Type.EXECUTE_ONCE) /** Wait Observer Available and Emit Event for Execution */ fun waitAndExecute(event: NavigationEvent) = newEvent(event, Type.WAIT_OBSERVER_IF_NEEDED) /** Wait Observer Available and Emit Event for Execution Once */ fun waitAndExecuteOnce(event: NavigationEvent) = newEvent(event, Type.WAIT_OBSERVER_IF_NEEDED_AND_EXECUTE_ONCE) } 

औपचारिक रूप से, आप पहले से ही ViewModel में Emitter को सब्सक्राइब कर सकते हैं और उनके हैंडलिंग की परवाह किए बिना ईवेंट प्राप्त कर सकते हैं (ईवेंट को पहले ही संसाधित किया जा चुका है या नहीं)।

एक इवेंट ऑब्जर्वर क्लास बनाएं - EventObserver

 class EventObserver(private val handlerBlock: (NavigationEvent) -> Unit) : Observer<NavigationEvent> { private val executedEvents: HashSet<String> = hashSetOf() /** Clear All Executed Events */ fun clearExecutedEvents() = executedEvents.clear() override fun onChanged(it: NavigationEvent?) { when (it?.type) { Type.EXECUTE_WITHOUT_LIMITS, Type.WAIT_OBSERVER_IF_NEEDED -> { if (!it.isHandled) { it.isHandled = true it.apply(handlerBlock) } } Type.EXECUTE_ONCE, Type.WAIT_OBSERVER_IF_NEEDED_AND_EXECUTE_ONCE -> { if (it.javaClass.simpleName !in executedEvents) { if (!it.isHandled) { it.isHandled = true executedEvents.add(it.javaClass.simpleName) it.apply(handlerBlock) } } } } } } 

यह ऑब्जर्वर एक उच्च-क्रम फ़ंक्शन को एक इनपुट के रूप में स्वीकार करता है - घटना प्रसंस्करण एक टुकड़ा (नीचे उदाहरण) में लिखा जाएगा।

clearExecutedEvents() विधि निष्पादित घटनाओं की सफाई के लिए विधि (वे जिन्हें एक बार निष्पादित किया जाना चाहिए)। स्क्रीन को अपडेट करते समय आवश्यक है, उदाहरण के लिए, swipeToRefresh() ।

खैर, वास्तव में, मुख्य onChange() विधि, जो तब होती है जब नया एमिटर डेटा प्राप्त होता है, जिसके लिए यह पर्यवेक्षक सदस्यता लेता है।

यदि घटना में कई बार असीमित संख्या में निष्पादन प्रकार होता है, तो हम जांचते हैं कि क्या घटना को अंजाम दिया गया है और इसे संसाधित करें। हम घटना को निष्पादित करते हैं और इंगित करते हैं कि यह प्राप्त और संसाधित है।

 if (!it.isHandled) { it.isHandled = true it.apply(handlerBlock) } 

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

 if (it.javaClass.simpleName !in executedEvents) { if (!it.isHandled) { it.isHandled = true executedEvents.add(it.javaClass.simpleName) it.apply(handlerBlock) } } 

लेकिन घटनाओं के अंदर डेटा कैसे स्थानांतरित करें?

ऐसा करने के लिए, MyFragmentNavigation इंटरफ़ेस MyFragmentNavigation , जिसमें NavigationEvent() से विरासत में मिली कक्षाएं शामिल होंगी। उत्तीर्ण मापदंडों के साथ और बिना विभिन्न कक्षाएं नीचे बनाई गई हैं।

 interface MyFragmentNavigation { class ShowCategoryList : NavigationEvent() class OpenProduct(val productId: String, val productName: String) : NavigationEvent() class PlayVideo(val url: String) : NavigationEvent() class ShowNetworkError : NavigationEvent() } 

यह व्यवहार में कैसे काम करता है

ViewModel से घटनाएँ भेजना:

 class MyViewModel : ViewModel() { val emitter = Events.Enitter() fun doOnShowCategoryListButtonClicked() = emitter.emitAndExecute(MyNavigation.ShowCategoryList()) fun doOnPlayClicked() = emitter.waitAndExecuteOnce(MyNavigation.PlayVideo(url = "https://site.com/abc")) fun doOnProductClicked() = emitter.emitAndExecute(MyNavigation.OpenProduct( productId = "123", productTitle = " Samsung") ) fun doOnNetworkError() = emitter.emitAndExecuteOnce(MyNavigation.ShowNetworkError()) fun doOnSwipeRefresh(){ emitter.clearWaitingEvents() ..//loadData() } } 

एक टुकड़े में घटनाएँ प्राप्त करना:

 class MyFragment : Fragment() { private val navigationEventsObserver = Events.EventObserver { event -> when (event) { is MyFragmentNavigation.ShowCategoryList -> ShowCategoryList() is MyFragmentNavigation.PlayVideo -> videoPlayerView.loadUrl(event.url) is MyFragmentNavigation.OpenProduct -> openProduct(id = event.productId, name = event.otherInfo) is MyFragmentNavigation.ShowNetworkError -> showNetworkErrorAlert() } } override fun onViewCreated(view: View, savedInstanceState: Bundle?) { super.onViewCreated(view, savedInstanceState) // Observer   ViewModels     myViewModel.emitter.observe(viewLifecycleOwner, navigationEventsObserver) myViewModelSecond.emitter.observe(viewLifecycleOwner, navigationEventsObserver) myViewModelThird.emitter.observe(viewLifecycleOwner, navigationEventsObserver) } private fun ShowCategoryList(){ ... } private fun openProduct(id: String, name: String){ ... } private fun showNetworkErrorAlert(){ ... } } 

संक्षेप में, हमें Rx- BehaviorSubjec ta और EventBus -a का एक एनालॉग मिला है, जो केवल LiveData पर आधारित है, जिसमें Emitter ऑब्जर्वर निष्पादक के सामने आने से पहले घटनाओं को एकत्र कर सकता है, और जिसमें ऑब्जर्वर इवेंट प्रकारों की निगरानी कर सकता है और यदि आवश्यक हो, तो उन्हें केवल एक बार कॉल करें।

सुझावों के साथ टिप्पणियों में आपका स्वागत है।

स्रोत से लिंक करें
होम क्रेडिट बैंक से किस्त योजना ।