RxJava

Question

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

public void getData(final OnResponseListener listener){ 
    if(data!=null && !data.isEmpty()){ 
     listener.onSuccess(); 
    } 
    else{ 
     listener.onError(); 
    } 
} 

एक साधारण कॉलबैक:

public interface OnResponseListener { 
    public void onSuccess(); 
    public void onError(); 
} 

और "पर्यवेक्षक":

object.getData(new OnResponseListener() { 
    @Override 
    public void onSuccess() { 
     Log.w(TAG," on success"); 
    } 

    @Override 
    public void onError() { 
     Log.e(TAG," on error"); 
    } 
}); 

धन्यवाद

यहाँ मेरी कोड refactor करने के लिए है!

Answer 1

उदाहरण के लिए आप अपने डेटा के साथ देखने योग्य बनाने के लिए Observable.fromable का उपयोग कर सकते हैं।

public Observable<Data> getData(){ 
    return Observable.fromCallable(() -> { 
     Data result = null; 
     //do something, get your Data object 
     return result; 
    }); 
} 

फिर अपने डेटा

getData().subscribeOn(Schedulers.io()) 
      .observeOn(AndroidSchedulers.mainThread()) 
      .subscribe(data -> { 
       //do something with your data 
      }, error -> { 
       //do something on error 
      }); 

प्रयुक्त rxjava 1.x और लैम्ब्डा भाव का उपयोग करें।

संपादित करें:

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

public Single<Data> getData() { 
     return Single.create(singleSubscriber -> { 
      Data result = object.getData(); 
      if(result == null){ 
       singleSubscriber.onError(new Exception("no data")); 
      } else { 
       singleSubscriber.onSuccess(result); 
      } 
     }); 
    } 

getData().subscribeOn(Schedulers.io()) 
      .observeOn(AndroidSchedulers.mainThread()) 
      .subscribe(data -> { 
       //do something with your data 
      }, error -> { 
       //do something on error 
      }); 

Answer 2

मैं आपके कोड को दोबारा कैसे सुधारूंगा;

public void getData(final OnResponseListener listener){ 
    if(data!=null && !data.isEmpty()){ 
     listener.onSuccess(); 
    } 
    else{ 
     listener.onError(); 
    } 
} 

public Single<Boolean> getDataSingle() { 
    return Single.create(new SingleOnSubscribe<Boolean>() { 
     @Override 
     public void subscribe(SingleEmitter<Boolean> e) throws Exception { 
      getData(new OnResponseListener() { 
       @Override 
       public void onSuccess() { 
        e.onSuccess(true); 
       } 

       @Override 
       public void onError() { 
        e.onSuccess(false); 
       } 
      }); 
     } 
    }); 
} 

या जावा 8 के साथ:

public Single<Boolean> getDataSingle() { 
    return Single.create(e -> getData(
      new OnResponseListener() { 
       @Override 
       public void onSuccess() { 
        e.onSuccess(true); 
       } 

       @Override 
       public void onError() { 
        e.onSuccess(false); 
       } 
      }) 
    ); 
} 

अब आप कॉलबैक के एक साथ एक आरएक्स एपीआई उजागर हो GetData विधि के साथ-साथ, मैं GetData विधि एक एकल के रूप में लिपटे जोड़ना होगा। यह अपने खुद के dataProvider किसी तरह का है मान, अब आप कॉलबैक के साथ काम कर इस तरह के बिना इसका इस्तेमाल कर सकते हैं:

dataProvider.getDataSingle() 
     .map(result -> result ? "User exist" : "User doesn't exist") 
     .subscribe(message -> display(message)); 

मैं RX2 थे, लेकिन तर्क RX1 के साथ एक ही है।

मैंने एक पर्यवेक्षण के बजाय Single का भी उपयोग किया, क्योंकि आप केवल एक मान का इंतजार कर रहे हैं। ब्याज आपके कार्य के लिए एक अधिक अभिव्यक्तिपूर्ण अनुबंध है।

आप एक पर्यवेक्षक की तरफ से मूल्य उत्सर्जित नहीं कर सकते हैं, यानी myObservable.send (value) जैसे कुछ कॉल कर सकते हैं। पहला समाधान Subject का उपयोग करना है। एक और समाधान (उपर्युक्त) पर्यवेक्षण योग्य() (या एकल .create()) के साथ देखने योग्य है। आप कॉलबैक विधि को कॉल करते हैं और विधि Observable.create() के अंदर श्रोता बनाते हैं, क्योंकि यह Observable.create() के अंदर है जिसे आप स्यूसे() विधि पर कॉल कर सकते हैं, जिस विधि ने अवलोकन करने योग्य को मूल्य को पास करने के लिए कहा था।

मैं कॉलबैक को देखने योग्य में लपेटने के लिए उपयोग करता हूं। पहले थोड़ा जटिल, लेकिन अनुकूलित करने में आसान है।

मैं आपको एक और उदाहरण देता हूं, जैसा कि पूछा गया था।

View rootView; 
EditText editTextView; 

//Wrap Android addTextChangedListener into an Observable 
Observable<String> textObservable = Observable.create(consumer -> 
     editTextView.addTextChangedListener(new TextWatcher() { 
      @Override 
      public void beforeTextChanged(CharSequence s, int start, int count, int after) { 

      } 

      @Override 
      public void onTextChanged(CharSequence s, int start, int before, int count) { 

      } 

      @Override 
      public void afterTextChanged(Editable s) { 
       consumer.onNext(s.toString()); 
      } 
     }) 
); 

//Use it 
textObservable.subscribe(text -> Snackbar.make(rootView, text, Snackbar.LENGTH_SHORT).show()); 

Answer 3

आप Completable.create लिए देख रहे हैं:

Completable: मान लीजिए कि आप एक Snackbar के रूप में एक EditText के परिवर्तन प्रदर्शित करना चाहते हैं किसी भी मूल्य लेकिन पूरा करने के लिए केवल संकेत के बिना एक आस्थगित गणना का प्रतिनिधित्व करता है या अपवाद। कक्षा एक समान घटना पैटर्न का पालन करती है जैसे प्रतिक्रियाशील-स्ट्रीम: ऑन सदस्यता (ऑनरर | ऑन कॉम्प्लेट)?

Completable.create(subscriber -> { 
    object.getData(new OnResponseListener() { 
     @Override 
     public void onSuccess() { 
      subscriber.onCompleted(); 
     } 

     @Override 
     public void onError() { 
      subscriber.onError(* put appropriate Throwable here *); 
     } 
    } 
}) 
...//apply Schedulers 
.subscribe((() -> *success*), (throwable -> *error*)); 

Answer 4

Maybe.<String>create(new MaybeOnSubscribe<String>() { 
     @Override 
     public void subscribe(MaybeEmitter<String> e) throws Exception { 
     OnSuccessListener(uri->{ 
      e.onSuccess(uri)); 
     }) 
     .addOnFailureListener(throwable -> { 
      e.onError(throwable); 
     }); 
     } 
    });