Why_use_Reactive_Programming_-_Droidcon.pdf

Transcript

1. Why you should use reactive programming Ovidiu Latcu Android Technical Lead @
2. Let’s take an example • we need to show the nearby restaurants fit for the logged in user • we need to fetch the user data from DB • get the current location • then fetch nearby stores • so we have 3 async calls to execute
3. userDb.getUser(object : Callback<User> { override fun onResult(user: User) { })
4. userDb.getUser(object : Callback<User> { override fun onResult(user: User) { locationApi.getLocation(object : Callback<Location> { override fun onResult(location: Location) { })
5. userDb.getUser(object : Callback<User> { override fun onResult(user: User) { locationApi.getLocation(object : Callback<Location> { override fun onResult(location: Location) { restaurantsApi.getRestaurants(user, location, object : Callback<List<Restaurant>> { override fun onResult(result: List<Restaurant>) { showRestaurants(result) } override fun onError(exception: Throwable) { showError(exception) } }) } //...code stripped, more error handling })
6. Results • 3 nested callbacks • too much boilerplate • hard to read & browse • hard to handle errors • complicated to cancel calls / subscriptions
7. What if we need to change it ? • what if we want to improve this ? • get location & DB data in parallel • what are our options in Android & Java ?
8. ExecutorService, Threads, CountDownLatch, AsyncTask… exciting
9. Thread(Runnable { var user: User? = null var location: Location? = null var error: Throwable? = null val latch = CountDownLatch(2) userDb.getUser(object : Callback<User> { override fun onResult(result: User) { user = result latch.countDown() } override fun onError(exception: Throwable) { error = exception latch.countDown() } })
10. Thread(Runnable { var user: User? = null var location: Location? = null var error: Throwable? = null val latch = CountDownLatch(2) userDb.getUser(object : Callback<User> { override fun onResult(result: User) { user = result latch.countDown() } override fun onError(exception: Throwable) { error = exception latch.countDown() } }) locationApi.getLocation(object : Callback<Location> { override fun onResult(result: Location) { location = result latch.countDown() } override fun onError(exception: Throwable) { error = exception latch.countDown() } }) latch.await()
11. Thread(Runnable { var user: User? = null var location: Location? = null var error: Throwable? = null val latch = CountDownLatch(2) userDb.getUser(object : Callback<User> { override fun onResult(result: User) { user = result latch.countDown() } override fun onError(exception: Throwable) { error = exception latch.countDown() } }) locationApi.getLocation(object : Callback<Location> { override fun onResult(result: Location) { location = result latch.countDown() } override fun onError(exception: Throwable) { error = exception latch.countDown() } }) latch.await() if (user != null && location != null) { restaurantsApi.getRestaurants(user!!, location!!, object : Callback<List<Restaurant>> { override fun onResult(result: List<Restaurant>) { uiHandler.post({ showRestaurants(result) }) } override fun onError(exception: Throwable) { uiHandler.post({ showError(exception) }) } }) } else { uiHandler.post({ showError(error!!) }) } }).start()
12. The code became even more of a mess now
13. Could this be done more easy using Reactive Programming ?
14. Implementation using Reactive Programming Observable.zip( locationApi.getLocation(), userDb.getUser(), BiFunction { location: Location, user: User -> Data(location, user) })
15. Implementation using Reactive Programming Observable.zip( locationApi.getLocation(), userDb.getUser(), BiFunction { location: Location, user: User -> Data(location, user) }) .flatMap { data -> restaurantsApi.getRestaurants(data.user, data.location) }
16. Implementation using Reactive Programming Observable.zip( locationApi.getLocation(), userDb.getUser(), BiFunction { location: Location, user: User -> Data(location, user) }) .flatMap { data -> restaurantsApi.getRestaurants(data.user, data.location) } .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe({ showRestaurants(it) })
18. What is reactive programming ?
19. Reactive Programming Definition • “Reactive programming is an asynchronous programming paradigm concerned with data streams and the propagation of change.”, Wiki
20. Reactive Programming Definition • “An API for asynchronous programming with observable streams.”, ReactiveX
21. Reactive Programming Definition • “Reactive programming is programming with asynchronous data streams.”, GitHub • everything can be a stream of data : location, DB entries, current user, shopping cart, etc. • streams can be combined, transformed and the resulting stream observed by subscribers
22. Building blocks • Observables - streams of data • Operators - create, transform, filter, combine • Subscribers - consumers of data • Schedulers - add threading
23. The marble diagram
24. Observables - streams of data Observable.zip( locationApi.getLocation(), userDb.getUser(), BiFunction { location: Location, user: User -> Data(location, user) }) .flatMap { data -> restaurantsApi.getRestaurants(data.user, data.location) } .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe({ showRestaurants(it) }) Observable<Location> Observable<User>
25. Operators - combine, transform streams Observable.zip( locationApi.getLocation(), userDb.getUser(), BiFunction { location: Location, user: User -> Data(location, user) }) .flatMap { data -> restaurantsApi.getRestaurants(data.user, data.location) } .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe({ showRestaurants(it) }) ZIP OPERATOR FLAT MAP OPERATOR
26. Schedulers - add threading Observable.zip( locationApi.getLocation(), userDb.getUser(), BiFunction { location: Location, user: User -> Data(location, user) }) .flatMap { data -> restaurantsApi.getRestaurants(data.user, data.location) } .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe({ showRestaurants(it) }) BACKGROUND EXECUTION UI THREAD DELIVERY
27. Subscribers - handle results Observable.zip( locationApi.getLocation(), userDb.getUser(), BiFunction { location: Location, user: User -> Data(location, user) }) .flatMap { data -> restaurantsApi.getRestaurants(data.user, data.location) } .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe({ showRestaurants(it) }) SUBSCRIBER
28. Tweets list example • we want to fetch Droidcon Tweets • fetch Tweets by @droidconRO • fetch Tweets with #droidconro hashtag • do this in parallel • deliver final results to UI • should we first imagine this in Java, without RX ?
29. Using RX this is a piece of cake Observable.zip( twitterApi.getTweetsByHashtag("#droidcon"), twitterApi.getTweetsByUser("@droidconro"),
30. Using RX this is a piece of cake Observable.zip( twitterApi.getTweetsByHashtag("#droidcon"), twitterApi.getTweetsByUser("@droidconro"), BiFunction { hashTagTweets: List<Tweet>, tweetsByUser: List<Tweet> -> hashTagTweets.union(tweetsByUser).toList() })
31. Using RX this is a piece of cake Observable.zip( twitterApi.getTweetsByHashtag("#droidcon"), twitterApi.getTweetsByUser("@droidconro"), BiFunction { hashTagTweets: List<Tweet>, tweetsByUser: List<Tweet> -> hashTagTweets.union(tweetsByUser).toList() }) .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(::showTweets)
32. TwitterAPI - using Retrofit RX Adapter interface TwitterApi { @GET("/1.1/statuses/user_timeline.json") fun getTweetsByHashtag(@Query hashTag: String): Observable<List<Tweet>> @GET("/1.1/statuses/tweets.json") fun getTweetsByUser(@Query user: String): Observable<List<Tweet>> }
33. Repository pattern example • for the previous example, we also want DB storage • implement a repository for Tweets • first fetches items from DB • then fetches new items from API • stores API items in DB • deliver both results to the UI as they arrive
34. Again, very simple using RX class TweetsRepository(val database: TweetsDatabase, val api: TweetsApi) { fun getTweets(): Observable<List<Tweet>> {} }
35. Again, very simple using RX class TweetsRepository(val database: TweetsDatabase, val api: TweetsApi) { fun getTweets(): Observable<List<Tweet>> { return Observable.concatArray( database.getTweets(), api.getTweets() } }
36. Again, very simple using RX class TweetsRepository(val database: TweetsDatabase, val api: TweetsApi) { fun getTweets(): Observable<List<Tweet>> { return Observable.concatArray( database.getTweets(), api.getTweets() .doOnNext { database.storeTweets(it) }) } }
37. TwitterDatabase - using Room RX Adapters @Dao interface TweetsDatabase { @Query("SELECT * FROM tweet") fun getTweets(): Observable<List<Tweet>> @Insert fun storeTweets(users: List<Tweet>) }
38. Where are those Observable coming from ? • existing “adapters” / RX libraries • Retrofit • Room • SQLite • RXLocation • RXNetworking
39. Creating Observables
40. First “Observable” - RxLocation • there are cases when we need to write our own Observable • more advanced, must know what you doing • use Observable.create( subscriber ) • connect to the service / client ( eg: location) • emit data as it arrives via subscriber.onNext(data) • disconnect from the service / client when the subscription is disposed
41. fun getLocation(): Observable<Location> { return Observable.create<Location>({ subscriber -> }) }
42. fun getLocation(): Observable<Location> { return Observable.create<Location>({ subscriber -> val listener = object : LocationCallback() { override fun onLocationResult(result: LocationResult) { super.onLocationResult(result) result.lastLocation?.let { subscriber.onNext(it) } } } locationClient.requestLocationUpdates(createLocationRequest(), listener, Looper.myLooper()) } }) }
43. fun getLocation(): Observable<Location> { return Observable.create<Location>({ subscriber -> val listener = object : LocationCallback() { override fun onLocationResult(result: LocationResult) { super.onLocationResult(result) result.lastLocation?.let { subscriber.onNext(it) } } } locationClient.requestLocationUpdates(createLocationRequest(), listener, Looper.myLooper()) } }) } EMIT ITEMS FOR THE SUBSCRIBER
44. fun getLocation(): Observable<Location> { return Observable.create<Location>({ subscriber -> val listener = object : LocationCallback() { override fun onLocationResult(result: LocationResult) { super.onLocationResult(result) result.lastLocation?.let { subscriber.onNext(it) } } } locationClient.requestLocationUpdates(createLocationRequest(), listener, Looper.myLooper()) subscriber.setCancellable { locationClient.removeLocationUpdates(listener) } }) }
45. fun getLocation(): Observable<Location> { return Observable.create<Location>({ subscriber -> val listener = object : LocationCallback() { override fun onLocationResult(result: LocationResult) { super.onLocationResult(result) result.lastLocation?.let { subscriber.onNext(it) } } } locationClient.requestLocationUpdates(createLocationRequest(), listener, Looper.myLooper()) subscriber.setCancellable { locationClient.removeLocationUpdates(listener) } }) } subscription.dispose() → disconnect client/services
46. fun getLocation(): Observable<Location> { return Observable.create<Location>({ subscriber -> val listener = object : LocationCallback() { override fun onLocationResult(result: LocationResult) { super.onLocationResult(result) result.lastLocation?.let { subscriber.onNext(it) } } } locationClient.requestLocationUpdates(createLocationRequest(), listener, Looper.myLooper()) subscriber.setCancellable { locationClient.removeLocationUpdates(listener) } }) }
47. Final example ( : - Hunters Application • continuously track hunter Location • continuously track hunter compass • poll other hunters location from API every 5 seconds • check if hunter direction intersects other hunters • alarm user
48. How would we do this in Java, without RX ?
49. Location, API calls & azimuth are Observables interface HuntingApi { fun getLocation(): Observable<Location> fun getOrientation(): Observable<Double> fun getHunters(): Observable<List<Hunter>> }
50. val huntersObservable = Observable .interval(5000, TimeUnit.MILLISECONDS) .flatMap { getHunters() } MAKE API CALL EVERY 5 SECONDS
51. val huntersObservable = Observable .interval(5000, TimeUnit.MILLISECONDS) .flatMap { getHunters() } Observable.combineLatest( getLocation(), getOrientation(), huntersObservable, //... COMBINE LATEST LOCATION , ORIENTATION, AND HUNTERS DATA
52. val huntersObservable = Observable .interval(5000, TimeUnit.MILLISECONDS) .flatMap { getHunters() } Observable.combineLatest( getLocation(), getOrientation(), huntersObservable, Function3 { location: Location, azimuth: Double, hunters: List<Hunter> -> //Check if hunter direction intersects other nearby hunters checkHuntersIntersection(location, azimuth, hunters) }) PASS DATA TO A FUNCTION THAT CHECKS IF WE INTERSECT ANY OTHER HUNTER
53. val huntersObservable = Observable .interval(5000, TimeUnit.MILLISECONDS) .flatMap { getHunters() } Observable.combineLatest( getLocation(), getOrientation(), huntersObservable, checkHuntersIntersection()) //... fun checkHuntersIntersection() = Function3 { loc: Location, azimuth: Double, hunters: List<Hunter> -> //...check if hunter direction intersects other nearby hunters true } SIMPLIFIED, EXTRACTED TO A METHOD RETURNING A FUNCTION
54. val huntersObservable = Observable .interval(5000, TimeUnit.MILLISECONDS) .flatMap { getHunters() } Observable.combineLatest( getLocation(), getOrientation(), huntersObservable, checkHuntersIntersection()) .subscribe({ inDanger -> if (inDanger) alarmUser() }) IN THE END, SUBSCRIBE TO THE RESULT
55. val huntersObservable = Observable .interval(5000, TimeUnit.MILLISECONDS) .flatMap { getHunters() } Observable.combineLatest( getLocation().filter { it.accuracy > 85 }, getOrientation(), huntersObservable, checkHuntersIntersection()) .subscribe({ inDanger -> if (inDanger) alarmUser() }) FILTER OUT INACCURATE LOCATION UPDATES
56. val huntersObservable = Observable .interval(5000, TimeUnit.MILLISECONDS) .flatMap { getHunters() } Observable.combineLatest( getLocation().filter { it.accuracy > 85 }, getOrientation().throttleLast(500, TimeUnit.MILLISECONDS), huntersObservable, checkHuntersIntersection()) .subscribe({ inDanger -> if (inDanger) alarmUser() }) THROTTLE ORIENTATION, TO AVOID TOO MANY COMPUTATIONS
57. One last thing. What about unsubscribing ? • Observable.subscribe() -> returns a Subscription • keep a reference to it, and call dispose() • unsubscribes from all observables (location,orientation,etc)
58. One last thing. What about unsubscribing ? • Observable.subscribe() -> returns a Subscription • keep a reference to it, and call dispose() • unsubscribes from all observables (location,orientation,etc) val subscription = Observable.combineLatest( //... .subscribe({ //... }) subscription.dispose()
59. Reactive Programming Advantages • avoid “callback hell” • a lot simpler to do “async” / “threaded” work • complex threading becomes very easy • a lot of operators and adapters • async code more expressive and clean • easy to test • RXJava, RXAndroid, RXSwift, RXJS, RXNet ...
60. Reactive Programming Disadvantages • steep learning curve • online documentation not easy to understand • easy to make mistakes and missuse • not handling subscriptions, can lead to memory leaks • might get hard to onboard people on projects using RX
61. Thank you. Questions ? • Medium : https://medium.com/@ovidiu.latcu • GitHub : https://github.com/ovy9086/ • Speaker Deck : https://speakerdeck.com/ovy9086 • Company Website : https://www.corebuild.eu/ Ovidiu Latcu - Android Tech Lead @