Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Conquering concurrency - bringing the Reactive ...

Conquering concurrency - bringing the Reactive Extensions to the Android platform

Functional reactive programming on Android and in the SoundCloud app using RxJava, presented at DroidCon UK 2013

Matthias Käppler

October 25, 2013
Tweet

More Decks by Matthias Käppler

Other Decks in Programming

Transcript

  1. “That place where Snoop Dog Lion, indie musicians, podcasters and

    dubstep drop junkies share a space.” ~ Me (ca. 2013)
  2. title, date, 01 of 10 Loader callbacks ContentObserver ResultReceiver Custom

    listeners BroadcastReceiver Pull-to-refresh callbacks :-(
  3. Radical changes required to → Streamline event handling → Embrace

    concurrency → Unified event model title, date, 01 of 10
  4. Imperative programming title, date, 01 of 10 int x =

    1 int y = x + 1 x = 2 → y: 2 :-(
  5. Reactive programming title, date, 01 of 10 int x =

    1 Func<int> y = () → { x + 1 } x = 2 → y: 3
  6. Reactive programming title, date, 01 of 10 int x =

    1 Func<int> y = () → { x + 1 } x = 2 → y: 3 :-)
  7. title, date, 01 of 10 Imperative programming + declarative, lazy

    evaluation = Reactive programming + higher order functions, composition = Functional reactive programming
  8. What does this mean for mobile applications? Fact: UI driven

    applications are event based and reactive by nature. Fact: Today’s data comes from the web. title, date, 01 of 10
  9. Our programming style should reflect that! → Asynchronous, declarative APIs

    aka “Ask to construct” (M. Odersky) → Events as observable sequences → Embrace failure title, date, 01 of 10
  10. AsyncTask → Single threaded, uses Futures + Handlers → Very

    prone to leaking Context → No error-handling → Not composable title, date, 01 of 10
  11. Event buses Go a long way to improve this, however:

    → No built in error-handling model → Events are not composable → Designed around global, shared state title, date, 01 of 10
  12. Observables → Events as observable sequences Observable.create((observer) -> { for

    (int i = 1; i <= 3; i++) { observer.onNext(i); } observer.onCompleted(); }).subscribe(intObserver); // Emits values: 1, 2, 3 title, date, 01 of 10
  13. Observers title, date, 01 of 10 Observer<Integer> intObserver = new

    Observer<Integer> { public void onNext(Integer value) { System.out.println(value); } public void onCompleted() { System.out.println(“Done!”); } public void onError(Throwable t) { … } }
  14. Composition → Transformed/composed with operators // Observable from previous example

    observable.map((i) -> { return i * 2; }).subscribe(...) // Standard out now prints: 2 4 6 Done! title, date, 01 of 10
  15. Schedulers → Parameterized concurrency via schedulers // observable from previous

    example observable .subscribeOn(Schedulers.newThread()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(intObserver); title, date, 01 of 10
  16. How do we do it. Dumb fragments (observe and update)

    + Service calls exposed as Observable<T> + Custom operators (e.g. for paging) + Reactive components (e.g. adapters) title, date, 01 of 10
  17. Example: Fragment Interacts with service object to get results pushed

    into observer //e.g. in onCreate Observable<Track> observable = AndroidObservables.fromFragment( this, service.loadTracks()) .subscribe(this) title, date, 01 of 10
  18. Example: Service object Interacts with service API to fetch, map,

    and emit result data public Observable<Track> loadTracks() { APIRequest<Track> request = /* build request */ return mRxHttpClient.fetchModels(request); } title, date, 01 of 10
  19. Example: HTTP client Sends HTTP request + maps response data

    public Observable<T> fetchModels(APIRequest request) { return fetchResponse(request).mapMany((response) -> { return mapResponseToModels(request, response); }); } title, date, 01 of 10
  20. Some observations 1. Simple, uniform event model onNext* → onCompleted

    | onError 2. Reusable: declarative definition of asynchronous task compositions 3. Simple to test: concurrency is parameterized title, date, 01 of 10
  21. :-( → Java 6 anonymous classes → Deep call stacks

    → Slight increase in GC activity → Learning curve title, date, 01 of 10
  22. References 1) https://github.com/soundcloud/rxjava 2) http://rx.codeplex.com/ 3) http://www.reactivemanifesto.org 4) mttkay.github.io/blog/2013/08/25/functional- reactive-programming-on-android-with-rxjava

    5) http://laser.inf.ethz.ch/2012/slides/Odersky/ odersky-laser-1.pdf 6) http://blog.maybeapps.com/post/42894317939/ input-and-output 7) http://paulstovell.com/blog/reactive-programming title, date, 01 of 10
  23. Image attributions 1) Sad guy: http://www.empireclaims.co.uk/blog/wp- content/uploads/2012/07/Desperate-man-neyvendotcom.jpg 2) Broken window:

    http://4.bp.blogspot. com/_yNbpKuMvpDI/TUuzAiAI8yI/AAAAAAAAATU/RNqPwwcllxc/s1600/3 D-broken_window-1(www.CoolWallpapers.org).jpg 3) Android: http://vmatechs.com/wp-content/uploads/2013/07/android.jpg 4) Domino Days: http://upload.wikimedia. org/wikipedia/commons/6/6d/Domino_01.jpg 5) Holy grail: http://powet.tv/powetblog/wp- content/uploads/2010/02/holy_grail_post_banner1.jpg title, date, 01 of 10