MVIDroid: नई MVI लाइब्रेरी (मॉडल-व्यू-इंटेंट) की समीक्षा

सभी को नमस्कार! इस लेख में मैं एक नई लाइब्रेरी के बारे में बात करना चाहता हूं जो एमवीआई डिज़ाइन पैटर्न को एंड्रॉइड पर लाती है। इस लाइब्रेरी को MVIDroid कहा जाता है, कोटलिन में 100% लिखा गया है, हल्का और RxJava 2.x का उपयोग करता है। मैं व्यक्तिगत रूप से पुस्तकालय का लेखक हूं, इसका स्रोत कोड GitHub पर उपलब्ध है, और आप इसे JitPack (लेख के अंत में रिपॉजिटरी से लिंक) के माध्यम से जोड़ सकते हैं। इस लेख में दो भाग शामिल हैं: पुस्तकालय का एक सामान्य विवरण और इसके उपयोग का एक उदाहरण।

MVI

और इसलिए, एक प्रस्तावना के रूप में, मुझे आपको याद दिलाना है कि एमवीआई क्या है। मॉडल - दृश्य - आशय या, यदि रूसी में, मॉडल - दृश्य - इरादा। यह एक ऐसा डिज़ाइन पैटर्न है जिसमें मॉडल एक सक्रिय घटक है जो इंटेंट्स को स्वीकार करता है और राज्य उत्पन्न करता है। प्रस्तुति (देखें) बदले में प्रतिनिधित्व के मॉडल (देखें मॉडल) को स्वीकार करता है और उन्हीं इरादों को पैदा करता है। एक ट्रांसफ़ॉर्म फ़ंक्शन (दृश्य मॉडल मैपर) का उपयोग करके राज्य को एक दृश्य मॉडल में परिवर्तित किया जाता है। योजनाबद्ध रूप से, एमवीआई पैटर्न को निम्नानुसार दर्शाया जा सकता है:

MVIDroid में, प्रतिनिधित्व सीधे इरादों का उत्पादन नहीं करता है। इसके बजाय, यह UI ईवेंट का उत्पादन करता है, जिसे तब ट्रांसफ़ॉर्म फ़ंक्शन का उपयोग करके इंटेंट में परिवर्तित किया जाता है।

MVIDroid के मुख्य घटक

आदर्श

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

MVIDroid में, मॉडल को MviStore इंटरफ़ेस (स्टोर का नाम Redux से उधार लिया गया है) द्वारा दर्शाया गया है:

interface MviStore<State : Any, in Intent : Any, Label : Any> : (Intent) -> Unit, Disposable { @get:MainThread val state: State val states: Observable<State> val labels: Observable<Label> @MainThread override fun invoke(intent: Intent) @MainThread override fun dispose() @MainThread override fun isDisposed(): Boolean } 

और ताकि हमारे पास:

• इंटरफ़ेस में तीन जेनेरिक पैरामीटर हैं: स्टेट - स्टेट का प्रकार, इंटेंट - इंटेंट का प्रकार और लेबल - लेबल का प्रकार
• इसमें तीन क्षेत्र शामिल हैं: राज्य - मॉडल की वर्तमान स्थिति, राज्य - अवलोकन योग्य राज्य और लेबल - अवलोकन लेबल। अंतिम दो फ़ील्ड क्रमशः स्थिति और टैग में परिवर्तन की सदस्यता का अवसर प्रदान करते हैं।
• उपभोक्ता का इरादा
• यह डिस्पोजेबल है, जो मॉडल को नष्ट करना और उसमें होने वाली सभी प्रक्रियाओं को रोकना संभव बनाता है

ध्यान दें कि सभी मॉडल विधियों को मुख्य धागे पर निष्पादित किया जाना चाहिए। किसी अन्य घटक के लिए भी यही सच है। बेशक, आप मानक RxJava टूल का उपयोग करके पृष्ठभूमि कार्य कर सकते हैं।

अंग

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

जैसा कि आप आरेख से देख सकते हैं, घटक में घटनाओं को बदलने और पुनर्निर्देशित करने का एक महत्वपूर्ण कार्य है।

घटक फ़ंक्शन की एक पूरी सूची निम्नानुसार है:

• एसोसिएटेड आने वाले रिप्रेजेंटेशन इवेंट्स और टैग प्रत्येक मॉडल के साथ प्रदान किए गए ट्रांसफ़ॉर्मिंग फ़ंक्शन का उपयोग करते हुए
• आउटगोइंग मॉडल लेबल को बाहर तक लाएं
• जब एक घटक नष्ट हो जाता है तो सभी मॉडल को नष्ट कर देता है और सभी संबंधों को तोड़ देता है

घटक का अपना इंटरफ़ेस भी है:

 interface MviComponent<in UiEvent : Any, out States : Any> : (UiEvent) -> Unit, Disposable { @get:MainThread val states: States @MainThread override fun invoke(event: UiEvent) @MainThread override fun dispose() @MainThread override fun isDisposed(): Boolean } 

घटक इंटरफ़ेस पर अधिक विस्तार से विचार करें:

• दो सामान्य पैरामीटर शामिल हैं: UiEvent - व्यू इवेंट्स और स्टेट्स का प्रकार - मॉडल के प्रकार
• मॉडल क्षेत्र समूह (उदाहरण के लिए, एक इंटरफ़ेस या डेटा वर्ग के रूप में) को एक्सेस देने वाले राज्यों के क्षेत्र को समाहित करता है
• उपभोक्ता दृश्य घटनाएं
• यह डिस्पोजेबल है, जो घटक और उसके सभी मॉडलों को नष्ट करना संभव बनाता है

प्रतिनिधित्व (देखें)

जैसा कि आप अनुमान लगा सकते हैं, डेटा प्रदर्शित करने के लिए एक दृश्य की आवश्यकता है। प्रत्येक दृश्य के डेटा को एक दृश्य मॉडल में वर्गीकृत किया गया है और आमतौर पर एक डेटा वर्ग (कोटलिन) के रूप में दर्शाया गया है। देखें इंटरफ़ेस पर विचार करें:

 interface MviView<ViewModel : Any, UiEvent : Any> { val uiEvents: Observable<UiEvent> @MainThread fun subscribe(models: Observable<ViewModel>): Disposable } 

यहां सब कुछ थोड़ा सरल है। दो सामान्य पैरामीटर: ViewModel - व्यू मॉडल का प्रकार और UiEvent - व्यू इवेंट्स का प्रकार। एक uiEvents फ़ील्ड ऑब्जर्वेबल व्यू इवेंट है, जो ग्राहकों को इन समान घटनाओं की सदस्यता लेने में सक्षम बनाता है। और एक सदस्यता () विधि है जो आपको व्यू मॉडल की सदस्यता लेने की अनुमति देती है।

उदाहरण का उपयोग करें

अब अभ्यास में कुछ करने की कोशिश करने का समय है। मैं बहुत सरल कुछ करने का प्रस्ताव करता हूं। कुछ ऐसा है जिसे समझने के लिए बहुत प्रयास की आवश्यकता नहीं है, और एक ही समय में यह विचार करना है कि यह सब कैसे उपयोग करना है और किस दिशा में आगे बढ़ना है। इसे UUID जनरेटर होने दें: एक बटन के स्पर्श पर, हम एक UUID उत्पन्न करेंगे और इसे स्क्रीन पर प्रदर्शित करेंगे।

विचार

सबसे पहले, हम मॉडल देखें:

 data class ViewModel(val text: String) 

और घटनाएँ देखें:

 sealed class UiEvent { object OnGenerateClick: UiEvent() } 

अब हम स्वयं दृश्य लागू करते हैं, इसके लिए हमें MviAbstractView अमूर्त वर्ग से विरासत की आवश्यकता है:

 class View(activity: Activity) : MviAbstractView<ViewModel, UiEvent>() { private val textView = activity.findViewById<TextView>(R.id.text) init { activity.findViewById<Button>(R.id.button).setOnClickListener { dispatch(UiEvent.OnGenerateClick) } } override fun subscribe(models: Observable<ViewModel>): Disposable = models.map(ViewModel::text).distinctUntilChanged().subscribe { textView.text = it } } 

सब कुछ बेहद सरल है: हम UUID परिवर्तनों की सदस्यता लेते हैं और जब हम एक नया UUID प्राप्त करते हैं, और TextView को अपडेट करते हैं, और जब बटन पर क्लिक किया जाता है, तो हम OnGenerateClick घटना भेजते हैं।

आदर्श

मॉडल में दो भाग होंगे: इंटरफ़ेस और कार्यान्वयन।

इंटरफेस:

 interface UuidStore : MviStore<State, Intent, Nothing> { data class State(val uuid: String? = null) sealed class Intent { object Generate : Intent() } } 

यहां सब कुछ सरल है: हमारा इंटरफ़ेस MviStore इंटरफ़ेस का विस्तार करता है, जो राज्य (राज्य) और आशय (इरादे) के प्रकारों को दर्शाता है। टैग का प्रकार - कुछ भी नहीं, क्योंकि हमारा मॉडल उन्हें उत्पन्न नहीं करता है। इंटरफ़ेस में राज्य और आशय वर्ग भी शामिल हैं।

मॉडल को लागू करने के लिए, आपको यह समझने की आवश्यकता है कि यह कैसे काम करता है। मॉडल के इनपुट पर, इंटेंट्स प्राप्त होते हैं, जिन्हें विशेष इंटेंटट्यूशन फ़ंक्शन का उपयोग करके क्रियाओं में परिवर्तित किया जाता है। कार्य निष्पादनकर्ता के लिए इनपुट हैं, जो उन्हें निष्पादित करता है और परिणाम और लेबल का उत्पादन करता है। परिणाम फिर Reducer पर जाते हैं, जो वर्तमान स्थिति को एक नए में परिवर्तित करता है।

सभी चार रचना मॉडल:

• IntentToAction - एक फ़ंक्शन जो इरादे को कार्रवाई में परिवर्तित करता है
• MviExecutor - कार्य निष्पादित करता है और परिणाम और टैग तैयार करता है
• MviReducer - जोड़े (राज्य, परिणाम) को नए राज्यों में परिवर्तित करता है
• MviBootstrapper एक विशेष घटक है जो आपको मॉडल को इनिशियलाइज़ करने की अनुमति देता है। वही सभी एक्ट्स देता है जो एक्जिक्यूटिव को भी जाते हैं। आप एक बार की कार्रवाई कर सकते हैं, या आप किसी डेटा स्रोत की सदस्यता ले सकते हैं और कुछ घटनाओं पर कार्रवाई कर सकते हैं। जब आप एक मॉडल बनाते हैं तो बूटस्ट्रैपर स्वतः शुरू हो जाता है।

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

हमारे मॉडल का कारखाना निम्नानुसार दिखेगा:

 class UuidStoreFactory(private val factory: MviStoreFactory) { fun create(factory: MviStoreFactory): UuidStore = object : UuidStore, MviStore<State, Intent, Nothing> by factory.create( initialState = State(), bootstrapper = Bootstrapper, intentToAction = { when (it) { Intent.Generate -> Action.Generate } }, executor = Executor(), reducer = Reducer ) { } private sealed class Action { object Generate : Action() } private sealed class Result { class Uuid(val uuid: String) : Result() } private object Bootstrapper : MviBootstrapper<Action> { override fun bootstrap(dispatch: (Action) -> Unit): Disposable? { dispatch(Action.Generate) return null } } private class Executor : MviExecutor<State, Action, Result, Nothing>() { override fun invoke(action: Action): Disposable? { dispatch(Result.Uuid(UUID.randomUUID().toString())) return null } } private object Reducer : MviReducer<State, Result> { override fun State.reduce(result: Result): State = when (result) { is Result.Uuid -> copy(uuid = result.uuid) } } } 

यह उदाहरण मॉडल के सभी चार घटकों को प्रस्तुत करता है। सबसे पहले, फैक्ट्री विधि तैयार करती है, फिर ठेकेदार और उसके बाद, रिड्यूसर और उसके अंत में रिड्यूसर।

अंग

घटक राज्य (राज्य समूह) डेटा-वर्ग द्वारा वर्णित हैं:

 data class States(val uuidStates: Observable<UuidStore.State>) 

एक घटक में नए मॉडल जोड़ते समय, उनकी स्थिति को समूह में भी जोड़ा जाना चाहिए।

और, वास्तव में, कार्यान्वयन खुद:

 class Component(uuidStore: UuidStore) : MviAbstractComponent<UiEvent, States>( stores = listOf( MviStoreBundle( store = uuidStore, uiEventTransformer = UuidStoreUiEventTransformer ) ) ) { override val states: States = States(uuidStore.states) private object UuidStoreUiEventTransformer : (UiEvent) -> UuidStore.Intent? { override fun invoke(event: UiEvent): UuidStore.Intent? = when (event) { UiEvent.OnGenerateClick -> UuidStore.Intent.Generate } } } 

हमें MviAbstractComponent अमूर्त वर्ग विरासत में मिला, राज्यों और दृश्य घटनाओं के प्रकारों को निर्दिष्ट करते हुए, हमारे मॉडल को सुपर क्लास में उत्तीर्ण किया, और राज्यों के क्षेत्र को लागू किया। इसके अतिरिक्त, हमने एक परिवर्तन फ़ंक्शन बनाया जो व्यू इवेंट्स को हमारे मॉडल के इरादों में बदल देगा।

मैपिंग मॉडल देखें

हमारे पास शर्तें और प्रस्तुति मॉडल हैं, यह एक को दूसरे में बदलने का समय है। ऐसा करने के लिए, हम MviViewModelMapper इंटरफ़ेस लागू करते हैं:

 object ViewModelMapper : MviViewModelMapper<States, ViewModel> { override fun map(states: States): Observable<ViewModel> = states.uuidStates.map { ViewModel(text = it.uuid ?: "None") } } 

संचार (बाइंडिंग)

अकेले घटक और प्रस्तुति की उपस्थिति पर्याप्त नहीं है। सब कुछ काम करना शुरू करने के लिए, उन्हें जुड़ा होना चाहिए। यह गतिविधि बनाने का समय है:

 class UuidActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_uuid) bind( Component(UuidStoreFactory(MviDefaultStoreFactory).create()), View(this) using ViewModelMapper ) } } 

हमने बाइंड () पद्धति का उपयोग किया, जो उनके मॉडल के मैपर्स के साथ एक घटक और दृश्यों की एक सरणी लेता है। यह विधि LifecycleOwner (जो गतिविधि और टुकड़ा है) पर एक विस्तार विधि है और Arch पैकेज से DefaultLifecycleObserver का उपयोग करती है, जिसके लिए जावा 8 स्रोत संगतता की आवश्यकता होती है। यदि किसी कारण से आप जावा 8 का उपयोग नहीं कर सकते हैं, तो दूसरा बाँध () विधि आपके लिए उपयुक्त है, जो कि विस्तार विधि नहीं है और MviLifecyleObserver देता है। इस मामले में, आपको जीवन चक्र विधियों को स्वयं कॉल करना होगा।

संदर्भ

लाइब्रेरी का स्रोत कोड, साथ ही साथ जोड़ने और उपयोग करने के लिए विस्तृत निर्देश GitHub पर पाए जा सकते हैं।