अवरुद्ध करने पर निलंबन

इस लेख का उद्देश्य यह दिखाना है कि कोटलिन कॉरटाइन्स का उपयोग कैसे करें और रिएक्सेटिव एक्सएक्सटेंशन (आरएक्स) को हटा दें।

लाभ

आरएक्स पर कोराटाइन के चार लाभों पर विचार करना शुरू करने के लिए:

अवरुद्ध करने पर निलंबन

Rx का उपयोग करके गैर-अवरोधक कोड चलाने के लिए आप कुछ इस तरह से लिखेंगे:

Observable.interval(1, TimeUnit.SECONDS) .subscribe { textView.text = "$it seconds have passed" } 

जो प्रभावी रूप से एक नया सूत्र बना रहा है। थ्रेड स्मृति और प्रदर्शन के मामले में भारी वस्तुएं हैं।

दोनों मोबाइल विकास की दुनिया में महत्वपूर्ण हैं।

आप निम्नलिखित स्निपेट का उपयोग करके समान व्यवहार प्राप्त कर सकते हैं:

 launch { var i = 0 while (true){ textView.text = "${it++} seconds have passed" delay(1000) } } 

मूल रूप से, कोरआउट्स हल्के वजन के धागे होते हैं लेकिन हम कोई वास्तविक धागा नहीं बनाते हैं।
यहां हम नॉन-ब्लॉकिंग देरी () फ़ंक्शन का उपयोग कर रहे हैं, जो एक विशेष निलंबित फ़ंक्शन है जो एक थ्रेड को ब्लॉक नहीं करता है लेकिन कोरआउट को निलंबित करता है।

मैनुअल पर प्राकृतिक बैकपेचर हैंडलिंग

Backpressure तब होता है जब वेधशालाएं उन वस्तुओं का अधिक तेजी से उत्पादन करती हैं जो उनके पर्यवेक्षक उनका उपभोग करते हैं।
आरएक्स का उपयोग करते समय आपको स्पष्ट रूप से निर्दिष्ट करना होगा कि आप बैकस्पेस के साथ कैसे व्यवहार करेंगे।
2 बुनियादी दृष्टिकोण हैं:

• थ्रॉटलिंग, बफ़र्स या विंडो ऑपरेटर का उपयोग करें
• प्रतिक्रियाशील पुल मॉडल

जबकि Coroutines सस्पेंड कर सकते हैं कि वे बैकप्रेशर को संभालने के लिए एक प्राकृतिक उत्तर प्रदान करते हैं।
इस प्रकार, कोई अतिरिक्त कार्रवाई की आवश्यकता नहीं है।

Async पर कोड शैली को सिंक करें

मोबाइल एप्लिकेशन की मूल प्रकृति उपयोगकर्ता की क्रियाओं पर प्रतिक्रिया करना है। यही कारण है कि रिएक्टिव ईएक्सटेंशन एक अच्छा विकल्प होगा।

हालांकि, आपको एक कार्यात्मक शैली में एक कोड लिखना होगा। यदि आप अनिवार्य शैली में लिखते थे तो यह थोड़ा कठिन हो सकता है।

जबकि Coroutines आपको Async कोड लिखने में सक्षम करता है जैसे कि यह सामान्य सिंक फ़ंक्शंस था। उदाहरण के लिए,

 suspend fun showTextFromRemote() { val text = remote.getText() textView.text = text } 

यहां तक ​​कि मैं लंबे समय तक कार्यात्मक शैली के साथ काम कर रहा हूं, फिर भी एक अनिवार्य कोड को पढ़ना और डीबग करना आसान है।

तीसरे पक्ष के दायित्व से अधिक मूल

कॉरटीन एक मूल बिल्ड-इन कोटलिन की विशेषता है।

आपको कोई अतिरिक्त निर्भरता नहीं मिलानी है। वर्तमान में, सभी मुख्य पुस्तकालय कोरआउट्स से निपट सकते हैं।

उदाहरण के लिए,

पुराना वापस

 interface Api { @Get("users") suspend fun loadUsers() : List<User> } 

कक्ष

 interface Dao { @Update suspend fun update(user: UserEntity) } 

तो, आप एक ऐप बना सकते हैं जो सभी तरह से निलंबित है - यूआई परत शुरू करना, डोमेन के माध्यम से और डेटा परत में समाप्त होना।

ऐप

चलो व्यापार के लिए नीचे जाओ। हम एक क्लासिक मास्टर-डिटेल ऐप बनाएंगे।
पहले पृष्ठ में प्रसव की अनंत सूची होगी।
आइटम पर क्लिक करने पर, हम एक विवरण पृष्ठ खोलेंगे।
इसके अलावा, हम ऑफ़लाइन मोड का समर्थन करेंगे - सभी डेटा कैश किया जाएगा।
इसके अलावा, मैं MVVM आर्किटेक्चर का उपयोग करूंगा जहां AACM से ViewModel के बजाय ViewModel की भूमिका Fragment द्वारा निभाई जाती है। इसके कई कारण हैं:
टुकड़े आमतौर पर बहुत गंजे होते हैं - बस दृश्यमॉडल को XML से बांधें।

स्थिति बार रंग सेट करने जैसी विशेषताएं AAC ViewModel में नहीं की जा सकीं - आपको टुकड़े की विधि को ट्रिगर करना होगा। ViewModel के रूप में टुकड़े का उपयोग करने से हमें एक वर्ग में सभी संबंधित कार्यक्षमता (एक स्क्रीन को प्रबंधित करना) को स्टोर करने की अनुमति मिलेगी।

सबसे पहले, BaseViewModel बनाएँ:

 abstract class BaseViewModel<B : BaseBindings, V : ViewDataBinding> : Fragment(), CoroutineScope by CoroutineScope(Dispatchers.IO){ protected abstract val layoutId: Int protected abstract val bindings: B protected lateinit var viewBinding: V override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) retainInstance = true } override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? { viewBinding = DataBindingUtil.inflate(inflater, layoutId, container, false) return viewBinding.root } override fun onViewCreated(view: View, savedInstanceState: Bundle?) { super.onViewCreated(view, savedInstanceState) viewBinding.lifecycleOwner = viewLifecycleOwner viewBinding.setVariable(BR.bindings, bindings) } override fun onDestroy() { cancel() super.onDestroy() } } 

हम अपने ViewModel को CoroutineScope के रूप में चिह्नित करते हैं, ताकि हम व्यू मॉडल के अंदर कॉरआउट शुरू कर सकें और किसी भी लॉन्च किए गए कॉरआउट को एक टुकड़े के जीवनचक्र तक सीमित किया जा सके।

हमें मेमोरी लीक से बचने के लिए सभी चल रहे अनुरोधों को रद्द करने के लिए स्कोप के जीवनचक्र कॉलिंग cancel() विधि के अंत को स्पष्ट रूप से निर्दिष्ट करना होगा।

हमने retainInstance = true सेट किया retainInstance = true ताकि कॉन्फ़िगरेशन परिवर्तन में टुकड़े को फिर से न बनाया जाए ताकि हम सभी लंबे समय से चल रहे अनुरोधों को पूरा कर सकें।

इसके अलावा, हमें दो-तरफ़ा डेटा बाइंडिंग को चालू करने के लिए बाइंडिंग जीवनचक्र सेट करना होगा।

अपवाद संभालना

Coroutines प्रलेखन के अनुसार:

 Coroutine builders come in two flavors: propagating exceptions automatically (launch and actor) or exposing them to users (async and produce). The former treat exceptions as unhandled, similar to Java's Thread.uncaughtExceptionHandler 

चूंकि हम ज्यादातर मामलों में लॉन्च बिल्डर का उपयोग कर रहे हैं, इसलिए हमें CoroutineExceptionHandler को निर्दिष्ट करना होगा
CoroutineExceptionHandler CoroutineContext.Element है, जिसका उपयोग किसी अन्य ऑपरेटर का उपयोग करके कोरटाइन संदर्भ बनाने के लिए किया जा सकता है।
मैं स्थैतिक हैंडलर की घोषणा इस प्रकार करेगा:

 val exceptionHandler = CoroutineExceptionHandler { _, throwable -> Timber.e(throwable) } 

और BaseViewModel बदलें:

 abstract class BaseViewModel<B : BaseBindings, V : ViewDataBinding> : Fragment(), CoroutineScope by CoroutineScope(Dispatchers.IO + exceptionHandler) 

यहाँ से ViewModel के दायरे में लॉन्च किए गए कोरआउट में किसी भी अपवाद को दिए गए हैंडलर को दिया जाएगा।
इसके बाद, मुझे अपना API और DAO घोषित करने की आवश्यकता है:

 interface DeliveriesApi { @GET("deliveries") suspend fun getDeliveries(@Query("offset") offset: Int, @Query("limit") limit: Int): List<DeliveryResponse> } @Dao interface DeliveryDao { @Query("SELECT * FROM ${DeliveryEntity.TABLE_NAME}") fun getAll(): DataSource.Factory<Int, DeliveryEntity> @Insert(onConflict = OnConflictStrategy.REPLACE) suspend fun insert(delivery: DeliveryEntity) } 

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

 Not sure how to convert a Cursor to this method's return type ... 

यहाँ हमें सस्पेंड करने की आवश्यकता नहीं है क्योंकि:

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

हमें किसी तरह दूरस्थ और स्थानीय डेटा स्रोतों को जोड़ना होगा।
यह याद रखने योग्य है - सत्य का एक ही बिंदु होना चाहिए।
ऑफ़लाइन-प्रथम डिज़ाइन के अनुसार, यह स्थानीय भंडारण होगा। इसलिए, हम डेटाबेस स्थिति का निरीक्षण करेंगे। जब कोई पुनर्प्राप्त करने के लिए कुछ नहीं होता है तो हम रिमोट से डेटा पूछेंगे और इसे डेटाबेस में डालेंगे।
हम सूची वर्ग का परिचय देंगे

 data class Listing<T>( val pagedList: LiveData<PagedList<T>>, val dataState: LiveData<DataState>, val refreshState: LiveData<DataState>, val refresh: () -> Unit, val retry: () -> Unit ) 

आइए जाने वैल से वैल:

• pagedList - मुख्य डेटा जिसे PagedList के रूप में बनाया गया है ताकि अनंत स्क्रॉलिंग को सक्षम किया जा सके और डेटा को सक्षम करने के लिए LiveData के साथ लिपटे
• dataState - तीन में से एक स्थिति जिसमें हमारा डेटा हो सकता है: सक्सेस, रनिंग, एरर। परिवर्तनों को देखने के लिए लाइवडाटा से भी लिपटा
• रिफ्रेशस्टेट - जब हम स्वाइप-रिफ्रेश के माध्यम से रिफ्रेशिंग डेटा को ट्रिगर करते हैं तो हमें कुछ टूल की आवश्यकता होती है, जिसके द्वारा हम रिफ्रेश रिक्वेस्ट फीडबैक और अगले पेज रिक्वेस्ट फीडबैक के बीच अंतर करते हैं। पूर्व के लिए, हम सूची के अंत में एक त्रुटि दिखाना चाहते हैं लेकिन ताज़ा त्रुटि के लिए, हम एक टोस्ट संदेश दिखाना चाहते हैं और एक लोडर को छिपाना चाहते हैं।
• रिफ्रेश () - स्वाइप-रिफ्रेश पर ट्रिगर करने के लिए कॉलबैक

• पुनः प्रयास करें () - पृष्ठांकित लोडिंग त्रुटि पर ट्रिगर करने के लिए कॉलबैक
  अगला, सूची दृश्य मॉडल:

  
  

   class DeliveryListViewModel : BaseViewModel<DeliveryListBindings, DeliveryListBinding>(), DeliveryListBindings, DeliveryListItemBindings, DeliveryListErrorBindings { override val layoutId: Int = R.layout.delivery_list override val bindings: DeliveryListBindings = this private val deliveryGateway: DeliveryGateway by inject { parametersOf(this) } private val listing = deliveryGateway.getDeliveries() override val dataState = listing.dataState override val isRefreshing = Transformations.switchMap(listing.refreshState) { MutableLiveData(it == DataState.Loading) } override fun onViewCreated(view: View, savedInstanceState: Bundle?) { super.onViewCreated(view, savedInstanceState) setupList() setupRefresh() } private fun setupList() { val adapter = DeliveriesAdapter(this, this) viewBinding.deliveries.adapter = adapter viewBinding.deliveries.setHasFixedSize(true) listing.pagedList.observe(viewLifecycleOwner, Observer { adapter.submitList(it) }) listing.dataState.observe(viewLifecycleOwner, Observer { adapter.updateDataState(it) }) } private fun setupRefresh() { listing.refreshState.observe(viewLifecycleOwner, Observer { if (it is DataState.Error) { Toast.makeText(context, it.message, LENGTH_SHORT).show() } }) } override fun refresh() { listing.refresh() } override fun onDeliveryClicked(delivery: Delivery) { view?.findNavController()?.navigate(DeliveryListViewModelDirections.toDetails(delivery)) } override fun onRetryClicked() { listing.retry() } } 

  
  

  कक्षा घोषणा से शुरू करते हैं।

  
  

सबसे पहले DeliveryListBindings और DeliveryListBinding। पहले एक्सएमएल दृश्य के साथ दृश्य मॉडल को गोंद करने के लिए हमारा घोषित इंटरफ़ेस है। दूसरा XML पर आधारित ऑटोजेनरेटेड क्लास है। हमें अपने बाइंडिंग इंटरफ़ेस और जीवनचक्र को XML पर सेट करने के लिए दूसरे की आवश्यकता है।

इसके अलावा, कोटलिन के सिंथेटिक का उपयोग करने के बजाय इस ऑटोजेनरेटेड बाइंडिंग का उपयोग करके विचारों को संदर्भित करना अच्छा है।

वर्तमान दृश्य में सिंथेटिक दृश्य के माध्यम से संदर्भित होने पर मामला हो सकता है। डेटा बाध्यकारी के साथ, आप संकलन चरण पर भी तेजी से विफल हो जाएंगे।

इसके बाद, तीन इंटरफेस: डिलिवरी लिस्टबाइंडिंग, डिलिवरी लिस्टइमबाइंडिंग, डिलिवरी लिस्ट्रार बिंदिंग्स।

1. DeliveryListBindings - स्क्रीन के लिए ही बाइंडिंग। उदाहरण के लिए, इसमें ताज़ा () विधि शामिल है जिसे ऊर्ध्वाधर स्वाइप पर कहा जाता है।
2. DeliveryListItemBindings - सूची में एक आइटम के लिए बाइंडिंग। उदाहरण के लिए, onClicked ()
3. DeliveryListErrorBindings - त्रुटि दृश्य के लिए बाइंडिंग जो त्रुटि स्थिति पर दिखाई गई सूची आइटम भी है। उदाहरण के लिए, इसमें पुनर्प्रयास () विधि शामिल है

इस प्रकार, हम सिंगल व्यू मॉडल में सब कुछ संभाल रहे हैं क्योंकि यह सिंगल स्क्रीन है, लेकिन इंटरफेस सेग्रीगेशन सिद्धांत का भी पालन कर रहा है

आइए इस लाइन पर विशेष ध्यान दें:

 private val deliveryGateway: DeliveryGateway by inject { parametersOf(this) } 

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

CoroutineScope इंटरफ़ेस में एकमात्र फ़ील्ड है - CoroutineContext। संक्षेप में, एक गुंजाइश और एक संदर्भ समान चीजें हैं। एक संदर्भ और एक दायरे के बीच का अंतर उनके इच्छित उद्देश्य में है।

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

 class DeliveryBoundGateway( private val db: DataBase, private val api: DeliveriesApi, private val deliveryDao: DeliveryDao, private val coroutineScope: CoroutineScope ) : DeliveryGateway { private val boundaryCallback = DeliveriesBoundaryCallback( api = api, coroutineScope = coroutineScope, handleResponse = { insertIntoDatabase(it) } ) @MainThread override fun getDeliveries(): Listing<Delivery> { val refreshTrigger = MutableLiveData<Unit>() val refreshState = Transformations.switchMap(refreshTrigger) { refresh() } val pagingConfig = Config( initialLoadSizeHint = PAGE_SIZE, pageSize = PAGE_SIZE, prefetchDistance = PAGE_SIZE ) val deliveries = deliveryDao.getAll() .toLiveData( config = pagingConfig, boundaryCallback = boundaryCallback ) return Listing( pagedList = deliveries, dataState = boundaryCallback.dataState, retry = { boundaryCallback.helper.retryAllFailed() }, refresh = { refreshTrigger.value = null }, refreshState = refreshState ) } /** * When refresh is called, we simply run a fresh network request and when it arrives, clear * the database table and insert all new items in a transaction. * <p> * Since the PagedList already uses a database bound data source, it will automatically be * updated after the database transaction is finished. */ @MainThread private fun refresh(): LiveData<DataState> { boundaryCallback.refresh() val dataState = MutableLiveData<DataState>() dataState.value = DataState.Loading coroutineScope.launch { try { val deliveries = api.getDeliveries(0, PAGE_SIZE) db.withTransaction { deliveryDao.clear() insertIntoDatabase(deliveries) } dataState.postValue(DataState.Loaded) } catch (throwable: Throwable) { Timber.w(throwable) dataState.postValue(DataState.Error(throwable.message)) } } return dataState } private suspend fun insertIntoDatabase(deliveries: List<DeliveryResponse>) { deliveries.forEach { delivery -> val entity = deliveryConverter.fromNetwork(delivery) deliveryDao.insert(entity) } } companion object { const val PAGE_SIZE = 20 } } 

यहां हम शुरुआत से ही LiveData संरचना का निर्माण कर रहे हैं और फिर कोरटाइन लोड डेटा का उपयोग कर इसे LiveData पर पोस्ट कर रहे हैं। इसके अलावा, हम स्थानीय डेटाबेस और दूरस्थ एपीआई को गोंद करने के लिए PagedList.BoundaryCallback () के कार्यान्वयन का उपयोग कर रहे हैं । जब हम पृष्ठांकित सूची के अंत तक पहुँचते हैं तो सीमा वापस चालू हो जाती है और डेटा का अगला हिस्सा लोड हो जाता है।

जैसा कि आप देख सकते हैं कि हम नए coroutines को लॉन्च करने के लिए coroutineScope का उपयोग कर रहे हैं।

चूँकि यह दायरा खंड के जीवनचक्र के बराबर है - सभी लंबित अनुरोधों को खंड के onDestroy() कॉलबैक पर रद्द कर दिया जाएगा।

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

 class DeliveryViewModel : BaseViewModel<DeliveryBindings, DeliveryBinding>(), DeliveryBindings { override val layoutId: Int = R.layout.delivery override val bindings: DeliveryBindings = this private val args: DeliveryViewModelArgs by navArgs() override fun onViewCreated(view: View, savedInstanceState: Bundle?) { super.onViewCreated(view, savedInstanceState) viewBinding.delivery = args.delivery viewBinding.image.clipToOutline = true } } 

मुझसे संपर्क करें

यहाँ github स्रोत कोड का लिंक दिया गया है।

टिप्पणियों और खुले मुद्दों को छोड़ने के लिए आपका स्वागत है।