RxJava a Java implementation of Reactive Extentions HACKATRON TALK 

DrAL3X Mobile Developer at 
 Spreaker.com DrAL3X on ALESSANDRO CALZAVARA 

A Library for composing asynchronous and event-based programming using observable sequences for the Java VM RXJAVA WHAT IS 

"It extends the observer pattern to support sequences of data and/or events and adds operators that allow you to compose sequences together declaratively while abstracting away concerns about things like low-level threading, synchronization, thread-safety, concurrent data structures, and non-blocking I/O." @ ReactiveX.io “ 

OBSERVER PATTERN THE BASICS OF Observer: • handle notifications Subject: • register/unregister observers • notify observers 

WHY USING RX 

SIMPLE API EVERYTHING BEGINS WITH A public Data getData(); Owner of API should retain control of concurrency behaviour. User should simply not care how it work behind. 

CHANGE API CHANGE INTERACTION BY single items multiple items synch T getData() Iterable getData() asynch Future getData() Observable getData() 

ITERABLE and OBSERVABLE DUALITY BETWEEN Iterable Observable pull push T next() onNext(T) throws Exception onError(Exception) returns onCompleted() 

T getData() SYNC SINGLE ITEM String s = getData(args); if (s.equals(x)) { // do something } else { // do something else } 

Iterable getData() SYNC MULTIPLE ITEMS Iterable values = getData(args); for (String s : values) { if (s.equals(x)) { // do something } else { // do something else } } 

Future getData() ASYNC SINGLE ITEM Future s = getData(args); if (s.get().equals(x)) { // do something } else { // do something else } 

FUTURES REMOVE BLOCKING WITH Future d = getData(args); Futures.addCallback(d, new FutureCallback { public void onSuccess(String s) { if (s.equals(x)) { // do something } else { // do something else } } }, executor); 

COMPOSABLE FUTURE REMOVE BLOCKING WITH Future d = getData(args); d.map({ s -> if (s.equals(x)) { // do something } else { // do something else } }); Only Java 8+ or Scala 

Observable getData() ASYNC MULTIPLE ITEMS Observable d = getData(args); d.map({ s -> if (s.equals(x)) { // do something } else { // do something else } }); 

OBSERVABLE API MORE FLEXIBLE One interface to rule them all. Client code treats all interactions with the API as ASYNCHRONOUS. The API implementation chooses whether something is BLOCKING or NON- BLOCKING and WHAT resources it uses. 

HOW TO CREATE AN OBSERVABLE 

Observable.create(new OnSubscribe() { @Override public void call(Subscriber subscriber) { try { subscriber.onNext("Hello"); subscriber.onCompleted(); } catch (Exception e) { subscriber.onError(e); } } }) 

ASYNC OBSERABLE WITH MULTIPLE VALUES 

Observable getTopImages() { return Observable.create(new OnSubscribe() { @Override public void call(Subscriber subscriber) { try { for (id in imageIds) { Image i = …do network call… subscriber.onNext(i); } subscriber.onCompleted(); } catch (Exception e) { subscriber.onError(e); } } }) 

ASYNCHRONOUS OBSERVER 

getTopImages().subscribe(new Observer() { void onNext(Image image) { println("Image: " + image.getImageId()); } void onError(Exception e) { println("Error"); e.printStackTrace(); } void onCompleted() { println("Completed"); } }); 

Transform: map, flatmap, reduce, scan Filter: take, skip, sample, takeWhile, filter Combine: concat, merge, zip, combineLatest,
 multicast, publish, cache, refCount Concurrency: observeOn, subscribeOn Error handling: onErrorReturn, onErrorResume OPERATORS COMPOSABLE FUNCTIONS AKA 

MERGE COMBINING VIA 

ZIP COMBINING VIA 

ERRORS HANDLING 

REAL WORLD EXAMPLE 

this._episodeRepository.getEpisodeWithSegments(episodeId) .map(new Func1() { @Override public Episode call(Episode episode) { // Check if EPISODE segment is available… } }) .flatMap(new Func1>() { @Override public Observable call(final Episode episode) { // Write episode to database… } }) .subscribeOn(RxSchedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new Subscriber() { // Add download to queue or notify error… }); 

MAP CHECK IF AUDIO SEGMENT IS AVAILABLE .map(new Func1() { @Override public Episode call(Episode episode) { // Check if EPISODE segment is available String downloadUrl = null; for (AudioSegment segment : episode.getSegments()) { if (segment.getType() == AudioSegment.Type.EPISODE && segment.getHttpUrl() != null) { downloadUrl = segment.getHttpUrl(); break; } } 

MAP CHECK IF AUDIO SEGMENT IS AVAILABLE episode.getSegments()) { if (segment.getType() == AudioSegment.Type.EPISODE && segment.getHttpUrl() != null) { downloadUrl = segment.getHttpUrl(); break; } } if (downloadUrl == null) { throw new IllegalArgumentException(…); } // Update episode property episode.setOfflineUrl(downloadUrl); episode.setOfflineFilepath(_destinationFileForEpisode( episode.getEpisodeId()).getAbsolutePath()); episode.setOfflineAt(createdAt); episode.setOfflineStatus(Episode.OfflineStatus.WAITING); return episode; } }) 

FLATMAP WRITE EPISODE TO DATABASE WITH .flatMap(new Func1>() { @Override public Observable call(final Episode episode) { // Write episode to database return _offlineRepository .addOfflineEpisodeDatabase(ep) .map(new Func1() { @Override public Episode call(Boolean added) { return ep; } }); }}) 

SUBSCRIBE HANDLE ERROR OR SUCCESS ON .subscribe(new Subscriber() { @Override public void onError(Throwable e) { // Notify failure … } @Override public void onNext(Episode episode) { // Notify success and add to download queue … } }); 

Interactions with the API are ASYNCHRONOUS and DECLARATIVE API implementation controls CONCURRENCY BEHAVIOUR The only "rule" is: DON'T MUTATE STATE OUTSIDE OF FUNCTION LESSONS LEARNED TO SUM UP 

ReactiveX: http://reactivex.io What does it means to be Reactive? https://www.youtube.com/watch? v=sTSQlYX5DU0 RxJava @ Github: https://github.com/ReactiveX/RxJava Observer Pattern: https://en.wikipedia.org/wiki/ Observer_pattern Marbles diagrams: http://rxmarbles.com/ 

THANK YOU