Lecture on Reactive programming on Android, mDevCamp 2016. A practical guide to using RxJava on Android. Tips for improving your app architecture with reactive programming. What are the advantages and disadvantages of using RxJava over standard architecture? And how to connect with other popular Android libraries?

1. Reactive programming on Android
Tomáš Kypta

2. What’s RxJava

3. What’s RxJava
▪ combination of
– observer pattern
– iterator pattern
– functional programming
▪ composable data flow
▪ push concept

4. Key Parts
▪ Observable
▪ Observer, Subscriber
▪ Subject

5. Key Methods
▪ onNext(T)
▪ onCompleted()
▪ onError(Throwable)

6. Key Methods
▪ subscribers can be replaced with Action parameters
someObservable.subscribe(
onNextAction,
onErrorAction,
onCompleteAction
);

7. Key Methods
▪ we often ignore onError() and onComplete()
▪ risk of crashes when error occurs
someObservable.subscribe(
onNextAction
);

8. What is RxJava good for?
▪ Async processing
– AsyncTask
– AsyncTaskLoader
– …

9. What is RxJava good for?
▪ Async composition
– nested API calls
– AsyncTask callback hell
– There’s no way to do it right!

10. What is RxJava good for?
▪ Testability

11. Pros & Cons
▪ powerful tool
▪ conceptually difficult
– there are some tricky parts

12. RxJava & app architecture
▪ suitable both for MVP and MVVM

13. Example
Observable.just("Hello, world!")
.subscribe(new Action1<String>() {
@Override
public void call(String s) {
Timber.d(s);
}
});

14. Example
Observable.just("Hello, world!")
.subscribe(new Subscriber<String>() {
@Override
public void onCompleted() {…}
@Override
public void onError(Throwable e) {…}
@Override
public void onNext(String s) {
Timber.d(s);
}
});

15. Retrolambda
▪ Enables Java 8 lambdas on Android

16. Tip #1 - use Retrolambda
Observable.just("Hello, world!")
.subscribe(s -> Timber.d(s));
Observable.just("Hello, world!")
.subscribe(new Action1<String>() {
@Override
public void call(String s) {
Timber.d(s);
}
});

17. Observer vs. Subscriber
?
myObservable
.subscribe(new Observer<String>() {
@Override
public void onCompleted() {}
@Override
public void onError(Throwable e) {}
@Override
public void onNext(String s) {}
});
myObservable
.subscribe(new Subscriber<String>() {
@Override
public void onCompleted() {}
@Override
public void onError(Throwable e) {}
@Override
public void onNext(String s) {}
});

18. Observer vs. Subscriber
▪ simpler unsubscribe() with
Subscriber
myObservable
.subscribe(new Subscriber<String>() {
@Override
public void onCompleted() {
unsubscribe();
}
@Override
public void onError(Throwable e) {}
@Override
public void onNext(String s) {}
});

19. Operators

20. Operators
▪ creation
▪ filtering
▪ combining
▪ transforming
▪ …

21. Understanding operators
▪ marble diagrams
▪ RxMarbles
– rxmarbles.com
– Android app

22. Observable Creation
▪ create()
▪ from()
▪ just()

23. Observable Creation
▪ corner cases
▪ empty()
▪ never()
▪ error()

24. Filtering
▪ filter()
▪ takeLast()
▪ take()

25. Filtering
▪ first(), take(int)
▪ skip()
▪ distinct()
▪ …

26. Combining
▪ merge()
▪ zip()

27. Transforming
▪ map()
▪ flatMap()
▪ concatMap()

28. map vs. flatMap vs. concatMap
▪ map
– A -> B
– one in, one out
▪ flatMap
– A -> Observable<B>
– map + flatten
▪ concatMap
– ordered flatMap

29. Aggregate
▪ concat()
▪ reduce

30. Operators
▪ and there’s much more …

31. Example
Observable.from(myUrls)

32. Example
Observable.from(myUrls)
.filter(url -> url.endsWith(".cz"))

33. Example
Observable.from(myUrls)
.filter(url -> url.endsWith(".cz"))
.flatMap(url ->
Observable.just(getHttpStatus(url)))

34. Example
Observable.from(myUrls)
.filter(url -> url.endsWith(".cz"))
.flatMap(url ->
Observable.just(getHttpStatus(url)))
.take(5)

35. Example
Observable.from(myUrls)
.filter(url -> url.endsWith(".cz"))
.flatMap(url ->
Observable.just(getHttpStatus(url)))
.take(5)
.subscribe(s -> Timber.i(String.valueOf(s)));

36. Threading

37. Threading
▪ subscribeOn(Scheduler)
▪ subscribes to Observable on the Scheduler
▪ observeOn(Scheduler)
▪ Observable emits on the Scheduler

38. Schedulers

39. Schedulers
▪ computation()
▪ io()
▪ newThread()
▪ from(Executor)

40. computation() vs. io()
▪ io()
– unbounded thread pool
– I/O operations
▪ computation()
– bounded thread pool
– CPU intensive computational work

41. AndroidSchedulers
▪ mainThread()
▪ from(Looper)

42. subscribeOn()
▪ subscribeOn()
– multiple calls useless
– only the first call works!
– for all operators

43. observeOn()
▪ can be called multiple times

44. Threading
▪ operators have default Schedulers
▪ check Javadoc for it

45. Threading
▪ range()
– no preference, uses current thread
▪ interval()
– computation() thread

46. Threading
▪ just()
– current thread
▪ delay(long, TimeUnit)
– computation() thread

47. Observable methods
▪ extra actions
▪ doOnNext()
▪ doOnError()
▪ doOnSubscribe()
▪ doOnUnsubscribe()
▪ …

48. Async composition
apiEndpoint.login()

49. Async composition
apiEndpoint.login()
.doOnNext(accessToken ->
storeCredentials(accessToken))

50. Async composition
apiEndpoint.login()
.doOnNext(accessToken ->
storeCredentials(accessToken))
.flatMap(accessToken ->
serviceEndpoint.getUser())

51. Async composition
apiEndpoint.login()
.doOnNext(accessToken ->
storeCredentials(accessToken))
.flatMap(accessToken ->
serviceEndpoint.getUser())
.flatMap(user ->
serviceEndpoint.getUserContact(user.getId()))

52. Subscription

53. Subscription
Subscription s = mAppInfoProvider.getAppsObservable()
.subscribe(
appInfo -> Timber.i(appInfo.getPackageName()
);

54. Subscription
Subscription s = mAppInfoProvider.getAppsObservable()
.subscribe(
appInfo -> Timber.i(appInfo.getPackageName()
);
s.unsubscribe();

55. Subscription
Subscription s = mAppInfoProvider.getAppsObservable()
.subscribe(
appInfo -> Timber.i(appInfo.getPackageName()
);
s.unsubscribe();
Timber.i("unsubscribed: " + s.isUnsubscribed());

56. CompositeSubscription
CompositeSubscription compositeSubscription
= new CompositeSubscription();
compositeSubscription.add(subscription);

57. CompositeSubscription
CompositeSubscription compositeSubscription
= new CompositeSubscription();
compositeSubscription.add(subscription);
compositeSubscription.unsubscribe();

58. CompositeSubscription
CompositeSubscription compositeSubscription
= new CompositeSubscription();
compositeSubscription.add(subscription);
compositeSubscription.unsubscribe();
compositeSubscription.clear();

59. Bridging non-Rx APIs

60. Bridging non-Rx APIs
▪ just()
private Object getData() {...}
public Observable<Object> getObservable() {
return Observable.just(getData());
}

61. Tip #2 - defer()
▪ use defer() to avoid immediate execution
private Object getData() {...}
public Observable<Object> getObservable() {
return Observable.defer(
() -> Observable.just(getData())
);
}

62. Subjects

63. Subjects
▪ Observable & Observer
▪ bridge between non-Rx API
▪ stateful
– terminal state
▪ don’t pass data after onComplete()/onError()

64. Subjects
▪ cannot be reused
– always create a new instance when subscribing to an
Observable

65. Subjects
▪ AsyncSubject
▪ BehaviorSubject
▪ ReplaySubject
▪ PublishSubject
▪ SerializedSubject

66. Subjects
Subject subject = …
subject.subscribe(subscriber);
subject.onNext(A);
subject.onNext(B);

67. AsyncSubject
▪ last item, after Observable completes

68. BehaviorSubject
▪ emits most recent and all subsequent items

69. PublishSubject
▪ emits only subsequent items

70. ReplaySubject
▪ emit all the items

71. RxRelay

72. RxRelay
▪ https://github.com/JakeWharton/RxRelay
▪ Relay = Observable & Action1
▪ call()
▪ Relay = Subject - onComplete() - onError()

73. RxRelay
▪ Subject
▪ stateful
▪ Relay
▪ stateless

74. RxRelay
Relay relay = …
relay.subscribe(observer);
relay.call(A);
relay.call(B);

75. RxRelay
▪ BehaviorRelay
▪ PublishRelay
▪ ReplayRelay
▪ SerializedRelay

76. Android Lifecycle
▪ problems
▪ continuing Subscription during configuration change
▪ memory leaks

77. Android Lifecycle
▪ continuing Subscription during configuration change
▪ cache()
▪ replay()

78. Android Lifecycle
▪ memory leaks
▪ bind to Activity/Fragment lifecycle
▪ RxLifecycle

79. RxLifecycle

80. RxLifecycle
▪ auto unsubscribe based on Activity/Fragment lifecycle
myObservable
.compose(RxLifecycle.bindUntilEvent(lifecycle,
ActivityEvent.DESTROY))
.subscribe();
myObservable
.compose(RxLifecycle.bindActivity(lifecycle))
.subscribe();

81. RxLifecycle
▪ obtain ActivityEvent or FragmentEvent by:
A. rxlifecycle-components + subclass RxActivity, RxFragment
B. Navi + rxlifecycle-navi
C. Write it yourself

82. RxLifecycle
public class MyActivity extends RxActivity {
@Override
public void onResume() {
super.onResume();
myObservable
.compose(bindToLifecycle())
.subscribe();
}
}

83. RxLifecycle
public class MyActivity extends NaviActivity {
private final ActivityLifecycleProvider provider
= NaviLifecycle.createActivityLifecycleProvider(this);
@Override
public void onResume() {
super.onResume();
myObservable
.compose(provider.bindToLifecycle())
.subscribe(…);
}
}

84. Navi
naviComponent.addListener(Event.CREATE,
new Listener<Bundle>() {
@Override public void call(Bundle bundle) {
setContentView(R.layout.main);
}
}
);

85. RxNavi
RxNavi.observe(naviComponent, Event.CREATE)
.subscribe(bundle -> setContentView(R.layout.main));

86. RxLifecycle
public class MainActivityFragment extends Fragment {
BehaviorSubject<FragmentEvent> mLifecycleSubject = BehaviorSubject.create();

87. RxLifecycle
public class MainActivityFragment extends Fragment {
BehaviorSubject<FragmentEvent> mLifecycleSubject = BehaviorSubject.create();
@Override public void onResume() {
super.onResume();
RxView.clicks(vBtn)
.compose(RxLifecycle.bindUntilEvent(mLifecycleSubject, FragmentEvent.PAUSE))
.doOnUnsubscribe(() -> Timber.i("onUnsubscribe"))
.subscribe(…);
}
}

88. RxLifecycle
public class MainActivityFragment extends Fragment {
BehaviorSubject<FragmentEvent> mLifecycleSubject = BehaviorSubject.create();
@Override public void onResume() {
super.onResume();
RxView.clicks(vBtn)
.compose(RxLifecycle.bindUntilEvent(mLifecycleSubject, FragmentEvent.PAUSE))
.doOnUnsubscribe(() -> Timber.i("onUnsubscribe"))
.subscribe(…);
}
@Override public void onPause() {
super.onPause();
Timber.i("onPause");
mLifecycleSubject.onNext(FragmentEvent.PAUSE);
}
}

89. RxBinding

90. RxBinding
▪ binding for UI widgets

91. RxBinding
RxView.clicks(vBtnSearch)
.subscribe(
v -> {
Intent intent = new Intent(getActivity(),
SearchActivity.class);
startActivity(intent);
}
);

92. RxBinding
RxTextView.textChanges(vEtSearch)
.subscribe(
response -> Timber.i("Count: " + response.totalCount())
);

93. RxBinding
RxTextView.textChanges(vEtSearch)
.debounce(2, TimeUnit.SECONDS)
.subscribe(
response -> Timber.i("Count: " + response.totalCount())
);

94. RxBinding
RxTextView.textChanges(vEtSearch)
.debounce(2, TimeUnit.SECONDS)
.observeOn(Schedulers.io())
.flatMap(s -> mApiService.search(s.toString()))
.subscribe(
response -> Timber.i("Count: " + response.totalCount())
);

95. RxBinding
▪ compile ‘com.jakewharton.rxbinding:rxbinding:0.4.0'
▪ compile ‘com.jakewharton.rxbinding:rxbinding-support-v4:0.4.0'
▪ compile ‘com.jakewharton.rxbinding:rxbinding-appcompat-v7:0.4.0'
▪ compile ‘com.jakewharton.rxbinding:rxbinding-design:0.4.0'
▪ compile ‘com.jakewharton.rxbinding:rxbinding-recyclerview-v7:0.4.0'
▪ compile 'com.jakewharton.rxbinding:rxbinding-leanback-v17:0.4.0'

96. Retrofit

97. Retrofit
▪ sync or async API
@GET("group/{id}/users")
Call<List<User>> groupList(@Path("id") int groupId);

98. Retrofit
▪ reactive API
@GET("group/{id}/users")
Observable<List<User>> groupList(@Path("id") int groupId);

99. Retrofit
– onNext() with Response, then onComplete()
– onError() in case of error
@GET("/data")
Observable<Response> getData(
@Body DataRequest dataRequest);

100. Retrofit
RxTextView.textChanges(vEtSearch)
.debounce(2, TimeUnit.SECONDS)
.observeOn(Schedulers.io())
.flatMap(s -> mApiService.search(s.toString()))
.subscribe(
response -> Timber.i("Count: " + response.totalCount())
);

101. SQLBrite

102. THE END