Share
Embed
Transcript
35 slides
-
What is RxJava? RxJava is a Java VM implementation of
ReactiveX (Reactive Extensions): a library for composing asynchronous and event-based programs by using observable sequences See also: 2 minutes introduction to Rx https://medium.com/@andrestaltz/2-minute-introduction-to-rx-24c8ca793877#.rwup8ee0s -
Threads Handler handler = new Handler(Looper.getMainLooper()); new Thread(){ @Override public
void run() { final String result = doHeavyTask(); handler.post(new Runnable() { // or runUIThread on Activity @Override public void run() { showResult(result); } }); } }.start(); -
Threads Pros: - Simple Cons: - Hard way to deliver
results in UI thread - Pyramid of Doom -
AsyncTask new AsyncTask<Void, Integer, String>(){ @Override protected String doInBackground(Void... params)
{ return doHeavyTask(); } @Override protected void onPostExecute(String s) { showResult(s); } }.execute(); -
AsyncTask Pros: - Deal with main thread Cons: - Hard
way to handling error - Not bound to activity/fragment lifecycle - Not composable - Nested AsyncTask - “Antek Async” -
Why Rx? - Because multithreading is hard - Execution context
- Powerful operators - Composable - No Callback Hell - Etc ... -
The Basic The basic building blocks of reactive code are
Observables and Subscribers. An Observable emits items; a Subscriber consumes those items. The smallest building block is actually an Observer, but in practice you are most often using Subscriber because that's how you hook up to Observables. -
The Basic Observables often don't start emitting items until someone
explicitly subscribes to them -
Hello World public Observable<String> getStrings() { return Observable.create(new Observable.OnSubscribe<String>() {
@Override public void call(Subscriber<? super String> subscriber) { try { subscriber.onNext("Hello, World"); subscriber.onCompleted(); } catch (Exception ex) { subscriber.onError(ex); } } }); } -
Hello World getStrings().subscribe(new Subscriber(){ @Override public void onCompleted() { //
no - op } @Override public void onError(Throwable e) { e.printStackTrace(); } @Override public void onNext(String s) { System.out.println(s); } }; -
Observable<String> myObservable = Observable.just("Hello, world!"); Action1<String> onNextAction = new Action1<>()
{ @Override public void call(String s) { System.out.println(s); } }; myObservable.subscribe(onNextAction); // Outputs "Hello, world!" Simpler Code -
Observable Creation Observable.create(Observable.onSubscribe) from( ) — convert an Iterable or a
Future or single value into an Observable repeat( ) — create an Observable that emits a particular item or sequence of items repeatedly timer( ) — create an Observable that emits a single item after a given delay empty( ) — create an Observable that emits nothing and then completes error( ) — create an Observable that emits nothing and then signals an error never( ) — create an Observable that emits nothing at all -
Filtering Operators - filter( ) — filter items emitted by an
Observable - takeLast( ) — only emit the last n items emitted by an Observable - takeLastBuffer( ) — emit the last n items emitted by an Observable, as a single list item - skip( ) — ignore the first n items emitted by an Observable - take( ) — emit only the first n items emitted by an Observable - first( ) — emit only the first item emitted by an Observable, or the first item that meets some condition - elementAt( ) — emit item n emitted by the source Observable - timeout( ) — emit items from a source Observable, but issue an exception if no item is emitted in a specified timespan - distinct( ) — suppress duplicate items emitted by the source Observable -
Filter Observable.just("Esa", "Ganteng", "Jelek") .filter(s -> !s.equalsIgnoreCase("jelek")) .buffer(2) .subscribe(strings ->
{ print(strings.get(0) + “ “ + strings.get(1)); }); // print Esa Ganteng -
Transformation Operators - map( ) — transform the items emitted by
an Observable by applying a function to each of them - flatMap( ) — transform the items emitted by an Observable into Observables, then flatten this into a single Observable - scan( ) — apply a function to each item emitted by an Observable, sequentially, and emit each successive value - groupBy( ) and groupByUntil( ) — divide an Observable into a set of Observables that emit groups of items from the original Observable, organized by key - buffer( ) — periodically gather items from an Observable into bundles and emit these bundles rather than emitting the items one at a time - window( ) — periodically subdivide items from an Observable into Observable windows and emit these windows rather than emitting the items one at a time -
Map Observable.from(Arrays.asList("Esa", "Esa", "Esa")) .map(s -> s + " ganteng")
.subscribe(System.out::println); // print Esa ganteng 3 times -
Confused? Getting map/flatMap/compose mixed up? Think types: map : T
-> R flatMap : T -> Observable<R> compose : Observable<T> -> Observable<R> #ProTips -
Retrofit Integration @GET("mobile_detail_calc_halte_trans.php") Observable<List<HalteDetail>> getHalteDetails(@Query("coridor") String coridor); mApiService.getHalteDetails(halte.getCoridor()) .observeOn(AndroidSchedulers.mainThread()) .doOnTerminate(this::resetUILoading)
.subscribe(halteDetails -> { if (halteDetails != null) { setMarker(halteDetails); } }); -
More Examples mApiService.getCommentList() .compose(bindToLifecycle()) .compose(applyApiCall()) .doOnTerminate(this::stopLoading) .subscribe(comments -> { if
(comments != null) mCommentAdapter.pushData(comments); }); -
More Samples Observable<Bitmap> imageObservable = Observable.create(observer -> { Bitmap bm
= downloadBitmap(); return bm; }); imageObservable.subscribe(image -> loadToImageView(image)); // blocking the UI thread imageObservable .subscribeOn(Schedulers.newThread()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(image -> loadToImageView(image)); // non blocking but also execute loadToImageView on UI Thread -
More Examples public Observable<List<Area>> getAreas() { Observable<List<Area>> network = mApiService.getArea()
.observeOn(AndroidSchedulers.mainThread()) .doOnNext(areas -> saveAreas(areas)); Observable<List<Area>> cache = getAreasFromLocal(); return Observable.concat(cache, network).first(areas -> areas != null); } -
More Examples (Again) public void onLocationChanged(Location location) { onLocationChanged.onNext(location); }
mGmsLocationManager.onLocationChanged .throttleLast(10, TimeUnit.SECONDS) .observeOn(AndroidSchedulers.mainThread()) .subscribe(location -> { mPrensenter.updateMyLocation(location); }); -
FAQ 1. Should we still use Thread and AsyncTask? 2.
Where to start? -
Third Party Implementation - Android ReactiveLocation https://github.com/mcharmas/Android-ReactiveLocation - RxPermissions https://github.com/tbruyelle/RxPermissions
- RxBinding https://github.com/JakeWharton/RxBinding - SQLBrite https://github.com/square/sqlbrite - RxLifeCycle https://github.com/trello/RxLifecycle -
Links - http://slides.com/yaroslavheriatovych/frponandroid - https://github.com/Netflix/RxJava/ - https://github.com/orfjackal/retrolambda - https://github.com/evant/gradle-retrolambda -
http://cr.openjdk.java.net/~briangoetz/lambda/lambda-translation.html - https://github.com/Netflix/RxJava/wiki