RxVMS मूल बातें: RxCommand और GetIt

यह मेरी स्पंदन वास्तुकला श्रृंखला का चौथा भाग है:

• परिचय
• डार्ट स्ट्रीम बेसिक्स
• RxDart: प्रवाह के जादुई रूपांतरण
• RxVMS मूल बातें: RxCommand और GetIt (यह पोस्ट)
• RxVMS: सेवाएं और प्रबंधक
• RxVMS: स्व-निहित विजेट
• RxVMS के साथ उपयोगकर्ता प्रमाणीकरण

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

गेट इट: फास्ट सर्विसलॉकर

जब आप किसी एप्लिकेशन में विभिन्न RxVMS तत्वों को दिखाने वाले आरेख को याद करते हैं ...

... शायद आप सोच रहे हैं कि विभिन्न मैपिंग, प्रबंधक और सेवाएं एक-दूसरे के बारे में कैसे पता लगाती हैं। इससे भी महत्वपूर्ण बात, आप सोच रहे होंगे कि एक तत्व दूसरे के कार्यों तक कैसे पहुंच सकता है।

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

के उपयोग

GetIt का उपयोग करना बहुत स्पष्ट है। आवेदन की शुरुआत में, आप सेवाओं और / या प्रबंधकों को पंजीकृत करते हैं जिन्हें आप बाद में उपयोग करने की योजना बनाते हैं। भविष्य में, पंजीकृत कक्षाओं के उदाहरणों तक पहुंचने के लिए बस गेट इट विधियों को कॉल करें।

एक अच्छी विशेषता यह है कि आप कंक्रीट कार्यान्वयन की तरह ही इंटरफेस या अमूर्त कक्षाएं पंजीकृत कर सकते हैं। एक उदाहरण तक पहुँचने के लिए, बस इंटरफेस / अमूर्त का उपयोग करें, आसानी से पंजीकरण के दौरान आवश्यक कार्यान्वयन की जगह। इससे आप आसानी से वास्तविक सेवा को मॉकसेवा में बदल सकते हैं।

थोड़ा सा अभ्यास

मैं आमतौर पर एक सेवा में अपने सेविसलोकेटर को एक वैरिएबल वैरिएबल के माध्यम से service_locator.dart नाम से आरंभ करता हूं। इस प्रकार पूरी परियोजना के लिए एक वैश्विक चर प्राप्त होता है।

//    GetIt sl = new GetIt(); void setUpServiceLocator(ErrorReporter reporter) { //  // [registerSingleton]  -  . //   . // sl.get<ErrorReporter>.get()    . sl.registerSingleton<ErrorReporter>(reporter); // [registerLazySingleton]   ,       // sl.get<ImageService>.get()            . sl.registerLazySingleton<ImageService>(() => new ImageServiceImplementation()); sl.registerLazySingleton<MapService>(() => new MapServiceImplementation()); //  sl.registerSingleton<UserManager>(new UserManagerImplementation()); sl.registerLazySingleton<EventManager>(() => new EvenManagerImplementation()); sl.registerLazySingleton<ImageManager>(() => new ImageManagerImplementation()); sl.registerLazySingleton<AppManager>(() => new AppManagerImplementation()); 

जब भी आप पहुंचना चाहें, बस कॉल करें

 RegistrationType object = sl.get<RegistrationType>(); //  GetIt  `callable`,   : RegistrationType object2 = sl<RegistrationType>(); 

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

यदि यह आपके लिए मुश्किल है, तो कृपया विवरण के लिए मेरे ब्लॉग पर जाएं ।

RxCommand

अब जब हम GetIt का उपयोग अपनी वस्तुओं को हर जगह (उपयोगकर्ता इंटरफ़ेस सहित) तक पहुंचाने के लिए करते हैं, तो मैं यह वर्णन करना चाहता हूं कि हम UI घटनाओं के लिए हैंडलर फ़ंक्शन कैसे लागू कर सकते हैं। सबसे आसान तरीका प्रबंधकों को फ़ंक्शन जोड़ना और उन्हें विजेट में कॉल करना होगा:

 class SearchManager { void lookUpZip(String zip); } 

और फिर UI में

 TextField(onChanged: sl.get<SearchManager>().lookUpZip,) 

यह TextField में हर बदलाव पर lookUpZip को lookUpZip करेगा। लेकिन हम भविष्य में हमारे लिए परिणाम कैसे पास करेंगे? चूँकि हम प्रतिक्रियाशील होना चाहते हैं, हम अपने SearchManager एक StreamController जोड़ेंगे:

 abstract class SearchManager { Stream<String> get nameOfCity; void lookUpZip(String zip); } class SearchManagerImplementation implements SearchManager{ @override Stream<String> get nameOfCity => cityController.stream; StreamController<String> cityController = new StreamController(); @override Future<void> lookUpZip(String zip) async { var cityName = await sl.get<ZipApiService>().lookUpZip(zip); cityController.add(cityName); } } 

और UI में:

 StreamBuilder<String>( initialData:'', stream: sl.get<SearchManager>().nameOfCity, builder: (context, snapshot) => Text(snapShot.data); 

हालांकि यह दृष्टिकोण काम करता है, यह इष्टतम नहीं है। यहां समस्याएं हैं:

• निरर्थक कोड - हमें हमेशा एक विधि, स्ट्रीमकंट्रोलर और अपनी स्ट्रीम के लिए एक गेटर बनाना होगा, अगर हम इसे सार्वजनिक डोमेन में स्पष्ट रूप से प्रदर्शित नहीं करना चाहते हैं
• व्यस्त अवस्था - क्या होगा यदि हम स्पिनर को प्रदर्शित करना चाहते हैं जबकि फ़ंक्शन अपना काम कर रहा है?
• त्रुटि से निपटने - क्या होता है यदि कोई फ़ंक्शन अपवाद फेंकता है?

बेशक, हम राज्यों और त्रुटियों को संभालने के लिए अधिक StreamControllers जोड़ सकते हैं ... लेकिन जल्द ही यह थकाऊ हो जाता है, और rx_command पैकेज यहां काम आता है ।

RxCommand उपरोक्त सभी समस्याओं का हल करता है और बहुत कुछ। RxCommand एक फ़ंक्शन (सिंक्रोनस या एसिंक्रोनस) को RxCommand करता है और स्वचालित रूप से स्ट्रीम में इसके परिणाम पोस्ट करता है।

RxCommand का उपयोग करते हुए, हम अपने प्रबंधक को इस तरह फिर से लिख सकते हैं:

 abstract class SearchManager { RxCommand<String,String> lookUpZipCommand; } class SearchManagerImplementation implements SearchManager{ @override RxCommand<String,String> lookUpZipCommand; SearchManagerImplementation() { lookUpZipCommand = RxCommand.createAsync((zip) => sl.get<ZipApiService>().lookUpZip(zip)); } } 

और UI में:

 TextField(onChanged: sl.get<SearchManager>().lookUpZipCommand,) ... StreamBuilder<String>( initialData:'', stream: sl.get<SearchManager>().lookUpZipCommand, builder: (context, snapshot) => Text(snapShot.data); 

जो बहुत अधिक संक्षिप्त और पठनीय है।

RxCommand विस्तार से

RxCommand में एक इनपुट और पांच आउटपुट वेधशालाएँ हैं:

• canExecuteInput एक वैकल्पिक ऑब्जर्वेबल Observable<bool> जिसे आप RxCommand बनाते समय फैक्ट्री फ़ंक्शन को पास कर सकते हैं। यह RxCommand को इंगित करता है कि क्या इसे निष्पादित किया जा सकता है, यह प्राप्त अंतिम मूल्य के आधार पर।

  
  

• isExecuting एक Observable<bool> जो संकेत देता है कि कमांड वर्तमान में अपना कार्य कर रहा है या नहीं। जब कोई टीम व्यस्त होती है, तो उसे फिर से नहीं चलाया जा सकता है। यदि आप स्पिनर को रनटाइम पर प्रदर्शित करना चाहते हैं, तो isExecuting को isExecuting

  
  

• canExecute एक ऑब्जर्वेबल Observable<bool> जो एक कमांड को निष्पादित करने की क्षमता का संकेत देता है। यह, उदाहरण के लिए, चालू / बंद राज्य के बीच एक बटन के रूप को बदलने के लिए स्ट्रीमब्यूलर के साथ अच्छी तरह से चला जाता है।
  इसका अर्थ इस प्रकार है:

  
  

   Observable<bool> canExecute = Observable.combineLatest2<bool,bool>(canExecuteInput,isExecuting) => canExecuteInput && !isExecuting).distinct. 

  
  

  जिसका मतलब है

  
  
  • अगर सही रिटर्न का निष्पादन हो तो false होगा
  • यह तभी true लौटाया जा सकता है, जब विदेशी रिटर्न false ।
  
  

• thrownException एक ऑब्जर्वेबल Observable<Exception> । सभी अपवाद जो एक पैकेज्ड फंक्शन फेंक सकते हैं, उन्हें पकड़कर इस ऑब्जर्वेबल में भेजा जाएगा। यदि कोई त्रुटि होती है, तो उसे सुनना और एक संवाद बॉक्स प्रदर्शित करना सुविधाजनक है।

  
  

• (टीम ही) वास्तव में एक अवलोकन योग्य भी है। वर्किंग फंक्शन द्वारा लौटाए गए मानों को इस चैनल पर प्रसारित किया जाएगा, ताकि आप सीधे RxCommand को स्ट्रीमलाइनर में स्ट्रीम पैरामीटर के लिए पास कर सकें

  
  

• परिणामों में सभी कमांड Observable<CommandResult> एक Observable<CommandResult> , जहाँ CommandResult परिभाषित किया जाता है

  
  

 /// Combined execution state of an `RxCommand` /// Will be issued for any state change of any of the fields /// During normal command execution, you will get this item's listening at the command's [.results] observable. /// 1. If the command was just newly created, you will get `null, false, false` (data, error, isExecuting) /// 2. When calling execute: `null, false, true` /// 3. When exceution finishes: `result, false, false` class CommandResult<T> { final T data; final Exception error; final bool isExecuting; const CommandResult(this.data, this.error, this.isExecuting); bool get hasData => data != null; bool get hasError => error != null; @override bool operator ==(Object other) => other is CommandResult<T> && other.data == data && other.error == error && other.isExecuting == isExecuting; @override int get hashCode => hash3(data.hashCode, error.hashCode, isExecuting.hashCode); @override String toString() { return 'Data: $data - HasError: $hasError - IsExecuting: $isExecuting'; } } 

.results विशेष रूप से उपयोगी है यदि आप सीधे स्ट्रीमब्यूलर पर कमांड के परिणाम को पास करना चाहते हैं। यह कमांड की स्थिति के आधार पर विभिन्न सामग्री को प्रदर्शित करेगा, और यह rx_widgets पैकेज से RxLoader साथ बहुत अच्छी तरह से काम करता है। यहाँ एक उदाहरण RxLoader विजेट है जो .results का उपयोग करता है:

 Expanded( /// RxLoader      ///    Stream<CommandResult> child: RxLoader<List<WeatherEntry>>( spinnerKey: AppKeys.loadingSpinner, radius: 25.0, commandResults: sl.get<AppManager>().updateWeatherCommand.results, /// ,  .hasData == true dataBuilder: (context, data) => WeatherListView(data, key: AppKeys.weatherList), /// ,  .isExceuting == true placeHolderBuilder: (context) => Center( key: AppKeys.loaderPlaceHolder, child: Text("No Data")), /// ,  .hasError == true errorBuilder: (context, ex) => Center( key: AppKeys.loaderError, child: Text("Error: ${ex.toString()}")), ), ), 

RxCommands बनाना

RxCommands तुल्यकालिक और अतुल्यकालिक कार्यों का उपयोग कर सकता है जो:

• उनके पास एक पैरामीटर नहीं है और एक परिणाम वापस नहीं करता है;
• उनके पास एक पैरामीटर है और परिणाम वापस नहीं करता है;
• उनके पास एक पैरामीटर नहीं है और एक परिणाम लौटाता है;
• उनके पास एक पैरामीटर है और एक परिणाम लौटाता है;

सभी विकल्पों के लिए, RxCommand सिंक्रोनस और एसिंक्रोनस हैंडलर्स को ध्यान में रखते हुए कई फैक्ट्री विधियाँ प्रदान करता है:

 static RxCommand<TParam, TResult> createSync<TParam, TResult>(Func1<TParam, TResult> func,... static RxCommand<void, TResult> createSyncNoParam<TResult>(Func<TResult> func,... static RxCommand<TParam, void> createSyncNoResult<TParam>(Action1<TParam> action,... static RxCommand<void, void> createSyncNoParamNoResult(Action action,... static RxCommand<TParam, TResult> createAsync<TParam, TResult>(AsyncFunc1<TParam, TResult> func,... static RxCommand<void, TResult> createAsyncNoParam<TResult>(AsyncFunc<TResult> func,... static RxCommand<TParam, void> createAsyncNoResult<TParam>(AsyncAction1<TParam> action,... static RxCommand<void, void> createAsyncNoParamNoResult(AsyncAction action,... 

यहां तक ​​कि अगर आपका पैक किया गया फ़ंक्शन मान वापस नहीं करता है, तो फ़ंक्शन निष्पादित होने के बाद RxCommand एक खाली मान लौटाएगा। इस प्रकार, आप श्रोता को ऐसी कमांड पर सेट कर सकते हैं ताकि यह फ़ंक्शन के पूरा होने पर प्रतिक्रिया करे।

नवीनतम परिणाम के लिए प्रवेश

RxCommand.lastResult आपको कमांड निष्पादन के परिणाम के अंतिम सफल मूल्य तक पहुंच प्रदान करता है, जिसका उपयोग initialData में आरंभिक initialData रूप में किया जा सकता है।

यदि आप रन टाइम में या त्रुटि के मामले में CommandResult इवेंट्स में शामिल अंतिम परिणाम प्राप्त करना चाहते हैं, तो कमांड बनाते समय आप emitInitialCommandResult = true पास कर सकते हैं।

यदि आप .lastResult लिए एक प्रारंभिक मान निर्दिष्ट करना चाहते हैं, उदाहरण के लिए, यदि आप इसे initialData में initialData के रूप में उपयोग करते हैं, तो आप कमांड बनाते समय इसे initialLastResult पैरामीटर के साथ पास कर सकते हैं।

उदाहरण - स्पंदन प्रतिक्रियाशील बनाना

उदाहरण के नवीनतम संस्करण को RxVMS के लिए पुनर्गठित किया गया है, इसलिए अब आपके पास इसका उपयोग करने का एक अच्छा विकल्प होना चाहिए।

चूंकि यह एक बहुत ही सरल अनुप्रयोग है, हमें केवल एक प्रबंधक की आवश्यकता है:

 class AppManager { RxCommand<String, List<WeatherEntry>> updateWeatherCommand; RxCommand<bool, bool> switchChangedCommand; RxCommand<String, String> textChangedCommand; AppManager() { //    bool         //   Observable switchChangedCommand = RxCommand.createSync<bool, bool>((b) => b); //    switchChangedCommand  canExecute Observable  // updateWeatherCommand updateWeatherCommand = RxCommand.createAsync<String, List<WeatherEntry>>( sl.get<WeatherService>().getWeatherEntriesForCity, canExecute: switchChangedCommand, ); //         textChangedCommand = RxCommand.createSync<String, String>((s) => s); //    ... textChangedCommand //     500ms... .debounce(new Duration(milliseconds: 500)) // ...   updateWeatherCommand .listen(updateWeatherCommand); //     updateWeatherCommand(''); } } 

आप विभिन्न RxCommands को एक साथ जोड़ सकते हैं। ध्यान दें कि switchedChangedCommand वास्तव में updateWeatherCommand के लिए एक अवलोकन योग्य है ।

अब देखते हैं कि उपयोगकर्ता इंटरफ़ेस में प्रबंधक का उपयोग कैसे किया जाता है:

  return Scaffold( appBar: AppBar(title: Text("WeatherDemo")), resizeToAvoidBottomPadding: false, body: Column( children: <Widget>[ Padding( padding: const EdgeInsets.all(16.0), child: TextField( key: AppKeys.textField, autocorrect: false, controller: _controller, decoration: InputDecoration( hintText: "Filter cities", ), style: TextStyle( fontSize: 20.0, ), //    textChangedCommand! onChanged: sl.get<AppManager>().textChangedCommand, ), ), Expanded( /// RxLoader   builders   ///   Stream<CommandResult> child: RxLoader<List<WeatherEntry>>( spinnerKey: AppKeys.loadingSpinner, radius: 25.0, commandResults: sl.get<AppManager>().updateWeatherCommand.results, dataBuilder: (context, data) => WeatherListView(data, key: AppKeys.weatherList), placeHolderBuilder: (context) => Center(key: AppKeys.loaderPlaceHolder, child: Text("No Data")), errorBuilder: (context, ex) => Center(key: AppKeys.loaderError, child: Text("Error: ${ex.toString()}")), ), ), Padding( padding: const EdgeInsets.all(8.0), child: Row( children: <Widget>[ ///  Updatebutton    updateWeatherCommand.canExecute Expanded( //        Streambuilder, //      WidgetSelector child: WidgetSelector( buildEvents: sl .get<AppManager>() .updateWeatherCommand .canExecute, onTrue: RaisedButton( key: AppKeys.updateButtonEnabled, child: Text("Update"), onPressed: () { _controller.clear(); sl.get<AppManager>().updateWeatherCommand(); }, ), onFalse: RaisedButton( key: AppKeys.updateButtonDisabled, child: Text("Please Wait"), onPressed: null, ), ), ), //    canExecuteInput StateFullSwitch( state: true, onChanged: sl.get<AppManager>().switchChangedCommand, ), ], ), ), ], ), ); 

विशिष्ट उपयोग पैटर्न

हमने पहले से ही CommandResults का उपयोग करते हुए एक कमांड के विभिन्न राज्यों को जवाब देने का एक तरीका देखा है। उन मामलों में जहां हम यह प्रदर्शित करना चाहते हैं कि क्या कमांड सफल था (लेकिन परिणाम प्रदर्शित नहीं करता है), एक सामान्य पैटर्न initState स्टेटफुलविटगेट फ़ंक्शन में initState को सुनने के लिए है। यहाँ एक वास्तविक परियोजना का एक उदाहरण है।

createEventCommand लिए परिभाषा:

  RxCommand<Event, void> createEventCommand; 

यह डेटाबेस में ईवेंट ऑब्जेक्ट बनाएगा और कोई वास्तविक मान नहीं लौटाएगा। लेकिन, जैसा कि हमने पहले सीखा था, यहां तक ​​कि एक RxCommand एक वापसी प्रकार के void साथ पूरा होने पर एक एकल डेटा आइटम लौटाएगा। इस प्रकार, कमांड पूरा होते ही हम अपने एप्लिकेशन में कार्रवाई को ट्रिगर करने के लिए इस व्यवहार का उपयोग कर सकते हैं:

 @override void initState() { //      ,        _eventCommandSubscription = _createCommand.listen((_) async { Navigator.pop(context); await showToast('Event saved'); }); //        _errorSubscription = _createEventCommand.thrownExceptions.listen((ex) async { await sl.get<ErrorReporter>().logException(ex); await showMessageDialog(context, 'There was a problem saving event', ex.toString()); }); } 

महत्वपूर्ण : जब हमारी अब आवश्यकता नहीं है, तो सदस्यता को पूरा करना न भूलें:

 @override void dispose() { _eventCommandSubscription?.cancel(); _errorSubscription?.cancel(); super.dispose(); } 

इसके अलावा, यदि आप व्यस्त काउंटर डिस्प्ले का उपयोग करना चाहते हैं, तो आप कर सकते हैं:

• initState फ़ंक्शन में isExecuting योग्य आदेशों को isExecuting करने के लिए सुनो;
• सदस्यता में काउंटर को दिखाना / छिपाना; साथ ही
• StreamBuilder के लिए डेटा स्रोत के रूप में कमांड का उपयोग करें

RxCommandListeners के साथ जीवन को आसान बनाना

यदि आप कई अवलोकनीय का उपयोग करना चाहते हैं, तो आपको संभवतः कई सदस्यता का प्रबंधन करना होगा। सदस्यता के एक समूह को सुनने और जारी करने का प्रत्यक्ष नियंत्रण मुश्किल हो सकता है, कोड को कम पठनीय बनाता है और आपको त्रुटियों के जोखिम में डालता है (उदाहरण के लिए, पूर्ण होने की प्रक्रिया को cancel भूल जाता है)।

Rx_command का नवीनतम संस्करण सहायक वर्ग RxCommandListener को जोड़ता है, जिसे इस प्रसंस्करण को सरल बनाने के लिए डिज़ाइन किया गया है। इसका निर्माता विभिन्न राज्य परिवर्तनों के लिए कमांड और हैंडलर स्वीकार करता है:

 class RxCommandListener<TParam, TResult> { final RxCommand<TParam, TResult> command; //       final void Function(TResult value) onValue; //    isExecuting final void Function(bool isBusy) onIsBusyChange; //       final void Function(Exception ex) onError; //    canExecute final void Function(bool state) onCanExecuteChange; //    .results Observable  final void Function(CommandResult<TResult> result) onResult; //     /  final void Function() onIsBusy; final void Function() onNotBusy; //     final Duration debounceDuration; RxCommandListener(this.command,{ this.onValue, this.onIsBusyChange, this.onIsBusy, this.onNotBusy, this.onError, this.onCanExecuteChange, this.onResult, this.debounceDuration,} ) void dispose(); 

आपको सभी हैंडलर फ़ंक्शन को पास करने की आवश्यकता नहीं है। उनमें से सभी वैकल्पिक हैं, इसलिए आप केवल उन लोगों को स्थानांतरित कर सकते हैं जिनकी आपको आवश्यकता है। आपको अपने RxCommandListener को अपने RxCommandListener में कॉल करने की आवश्यकता है, और यह सब सदस्यता के अंदर उपयोग को रद्द कर देगा।

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

• ImagePicker संवाद प्रदर्शित किया जाता है।
• छवि का चयन करने के बाद लोड किया गया है
• डाउनलोड पूरा होने के बाद, कमांड इमेज स्टोरेज एड्रेस को वापस करता है ताकि आप एक नई चैट एंट्री बना सकें।

RxCommandListener के बिना:

 _selectImageCommandSubscription = sl .get<ImageManager>() .selectAndUploadImageCommand .listen((imageLocation) async { if (imageLocation == null) return; //    sl.get<EventManager>().createChatEntryCommand(new ChatEntry( event: widget.event, isImage: true, content: imageLocation.downloadUrl, )); }); _selectImageIsExecutingSubscription = sl .get<ImageManager>() .selectAndUploadImageCommand .isExecuting .listen((busy) { if (busy) { MySpinner.show(context); } else { MySpinner.hide(); } }); _selectImageErrorSubscription = sl .get<ImageManager>() .selectAndUploadImageCommand .thrownExceptions .listen((ex) => showMessageDialog(context, 'Upload problem', "We cannot upload your selected image at the moment. Please check your internet connection")); 

RxCommandListener का उपयोग करना:

 selectImageListener = RxCommandListener( command: sl.get<ImageManager>().selectAndUploadImageCommand, onValue: (imageLocation) async { if (imageLocation == null) return; sl.get<EventManager>().createChatEntryCommand(new ChatEntry( event: widget.event, isImage: true, content: imageLocation.downloadUrl, )); }, onIsBusy: () => MySpinner.show(context), onNotBusy: MySpinner.hide, onError: (ex) => showMessageDialog(context, 'Upload problem', "We cannot upload your selected image at the moment. Please check your internet connection")); 

आम तौर पर, मैं हमेशा एक RxCommandListener का उपयोग करूंगा यदि एक से अधिक ऑब्जर्वेबल हो।

RxCommands आज़माएं और देखें कि यह आपके जीवन को कैसे आसान बना सकता है।
वैसे, आपको RxCommands का लाभ उठाने के लिए RxVMS का उपयोग करने की आवश्यकता नहीं है।

RxCommand अधिक जानकारी के लिए RxCommand readme पैकेज पढ़ें।