CODEWITHSUNDEEP
androidreactive-programmingrx-javarx-android
sirvon
sirvon

Reputation: 2625

How would I run this statement using RxJava?

Rx way of doing things can be very complex for none and for many reasons... but I feel there ARE simple ways to do simple things with RX...

How would I simply perform this statement on a background thread and receive the response on the ui thread?

All functions of this object need to run on a background thread. Get, put, clear, and delete.

 String city = Paper.get("city");

Upvotes: 6

Views: 1112

Answers (2)

fweigl
fweigl

Reputation: 22018

EDIT: This is not correct. Will not delete the answer though to preserve the comments.

Very simple example: 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);


    getPaper()
            .subscribeOn(Schedulers.newThread())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Action1<String>() {
                @Override
                public void call(String s) {
                    Log.d("xxx", s);
                }
            });


}

private Observable<String> getPaper() {

    return Observable.just(Paper.get());
}

where Paper.get() is a long running operation that returns a String. Check the docs for Scheduler.

Don't forget to observe on the main thread if you want to change the UI after receiving the result of your operation, else you will get an exception for changing the UI from outside the UI thread.

Upvotes: 0

njzk2
njzk2

Reputation: 39406

The base object in Rx is Observable. That object usually wraps an OnSubscribe object, which is simply an extension of Action1 that takes a Subscriber as a parameter.

What all that means is that you just need to define a class that wraps your call and passes the result to the Subscriber:

public class RxPaperGet implements Observable.OnSubscribe<String> {
    @Override
    public void call(Subscriber<? super String> t1) {
        try {
            t1.onNext(Paper.get("city"));
        } catch (Throwable t) {
            t1.onError(t);
            return;
        }
        t1.onCompleted();
    }
}

That's a basic example. Now, you would want to wrap that so you can call any function, and not just Paper.get("city"). Something like https://github.com/ReactiveX/RxJavaAsyncUtil/blob/0.x/src/main/java/rx/util/async/operators/OperatorFromFunctionals.java#L44 does that, by allowing you to pass an arbitrary Callable.

Which in your case, would implement as:

Observable<String> res = OperatorFromFunctionals.fromCallable(() -> Paper.get("city"));

(In case you're wondering, this is java8 lambdas brought to android by retrolambda. quite nice to remove the verbosity of Rx)

Once you have your observable, you can subscribe on it, and get results. To execute on the background, and retrieve the results on the ui thread, you would do:

 res.subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())

AndroidSchedulers is provided by rx-android.

Then you can simply be calledback with the result:

.subscribe(city -> Log.d(TAG, city));

That returns a subscription, which is useful if you need to cancel it.

Overall:

OperatorFromFunctionals.fromCallable(() -> Paper.get("city"))
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(city -> Log.d(TAG, city));

Upvotes: 5

Related Questions