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? Presented at GDG DevFest The Netherlands 2016.

1. Practical RxJava for Android
Tomáš Kypta
@TomasKypta

2. What’s RxJava?

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

4. RxJava…not sure how Android apps…

5. Typical non-reactive app
Event Source
Views Network DB …
Listener Listener Listener Listener
logic logiclogiclogic
State

6. Reactive app
Transformation
Event Source
Observable Observable Observable Observable
…
ObserverObserver
Views Network DB

7. RxJava data flow
Observable
.from(new String[]{"Hello", "Droidcon!"}) creation

8. RxJava data flow
Observable
.from(new String[]{"Hello", "Droidcon!"})
.map(new Func1<String, String>() {
@Override
public String call(String s) {
return s.toUpperCase(Locale.getDefault());
}
})
creation

9. RxJava data flow
Observable
.from(new String[]{"Hello", "Droidcon!"})
.map(new Func1<String, String>() {
@Override
public String call(String s) {
return s.toUpperCase(Locale.getDefault());
}
})
.reduce(new Func2<String, String, String>() {
@Override
public String call(String s, String s2) {
return s + ' ' + s2;
}
})
creation
transformation

10. RxJava data flow
Observable
.from(new String[]{"Hello", "Droidcon!"})
.map(new Func1<String, String>() {
@Override
public String call(String s) {
return s.toUpperCase(Locale.getDefault());
}
})
.reduce(new Func2<String, String, String>() {
@Override
public String call(String s, String s2) {
return s + ' ' + s2;
}
})
.subscribe(new Action1<String>() {
@Override
public void call(String s) {
Timber.i(s);
}
});
creation
transformation
subscription

11. Java 8 & Android
• use Retrolambda
• or jack compiler
• usable since build plugin 2.2.0

12. RxJava data flow
Observable
.from(new String[]{"Hello", "Droidcon!"})
.map(new Func1<String, String>() {
@Override
public String call(String s) {
return s.toUpperCase(Locale.getDefault());
}
})
.reduce(new Func2<String, String, String>() {
@Override
public String call(String s, String s2) {
return s + ' ' + s2;
}
})
.subscribe(new Action1<String>() {
@Override
public void call(String s) {
Timber.i(s);
}
});
creation
transformation
subscription

13. RxJava data flow with Java 8
creation
transformation
subscription
Observable
.from(new String[]{"Hello", "Droidcon!"})
.map(s -> s.toUpperCase(Locale.getDefault()))
.reduce((s,s2) -> s + ' ' + s2)
.subscribe(s -> Timber.i(s));

14. Key parts
• Observable
• Observer or Subscriber
• onNext(T)
• onCompleted()
• onError(Throwable)
• Subject

15. What is RxJava good for?
• making code simple and readable
• …with Java 8
• Async processing
• no AsyncTask, AsyncTaskLoader, …

16. Why…??

17. Async composition
• Async composition
• RxJava offers simple chaining of async operations
• eliminates callback hell

18. RxJava 1 vs. RxJava 2

19. RxJava 1 vs. RxJava 2
• RxJava 2 in RC now
• limited support in libraries
• they will coexist for some time
• different group ids
• io.reactivex vs. io.reactivex.rxjava2
• different package names
• rx vs. io.reactivex
• https://github.com/ReactiveX/RxJava/wiki/What's-different-in-2.0

20. Operators

21. Operators
• work on Observable
• return an Observable
• can be chained

22. Common mistakes
• assuming mutability
• operators return new Observable
Observable<String> observable =
Observable.from(new String[]{"Hello", "Droidcon!"});
obserable.map(s -> s.toUpperCase(Locale.getDefault()));
obserable.reduce((s,s2) -> s + ' ' + s2);

23. Common Mistakes
•assuming mutability
•operators return new Observable
Observable<String> observable =
Observable.from(new String[]{"Hello", "Droidcon!"})
.map(s -> s.toUpperCase(Locale.getDefault()))
.reduce((s,s2) -> s + ' ' + s2);

24. Marble diagrams
• RxMarbles

25. Subscription

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

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

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

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

30. CompositeSubscription
CompositeSubscription compositeSubscription
= new CompositeSubscription();

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

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

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

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

35. Bridging non-Rx APIs

36. Observable creation
• create()
• better to avoid
private Object getData() {...}
public Observable<Object> getObservable() {
return Observable.create(subscriber -> {
subscriber.onNext(getData());
subscriber.onCompleted();
});
}

37. Observable creation
• just()
private Object getData() {...}
public Observable<Object> getObservable() {
return Observable.just(getData());
} !

38. just() & defer()
• defer()
private Object getData() {...}
public Observable<Object> getObservable() {
return Observable.defer(
() -> Observable.just(getData())
);
}

39. Observable creation
• fromCallable()
• callable invoked when an
observer subscribes
private Object getData() {…}
public Observable<Object> getObservable() {
return Observable.fromCallable(new Callable<Object>() {
@Override
public String call() throws Exception {
return getData();
}
});
}

40. Observable creation from async APIs
• fromEmitter()
Observable.<Event>fromEmitter(emitter -> {
Callback listener = new Callback() {
@Override
public void onSuccess(Event e) {
emitter.onNext(e);
if (e.isLast()) emitter.onCompleted();
}
@Override
public void onFailure(Exception e) {
emitter.onError(e);
}
};
AutoCloseable c = api.someAsyncMethod(listener);
emitter.setCancellation(c::close);
}, BackpressureMode.BUFFER);

41. Subject

42. Subject
• Observable & Observer
• bridge between non-Rx API

43. Subject
// consume
anObservable.subscribe(aSubject);
// produce
aSubject.subscribe(aSubscriber);

44. Subject
// bridging & multicasting
aSubject.subscribe(subscriber1);
aSubject.subscribe(subscriber2);
aSubject.onNext(item1);
aSubject.onNext(item2);
aSubject.onNext(item2);
aSubject.onCompleted()

45. Subject
• stateful
• terminal state
• don’t pass data after onComplete() or
onError()

46. Subject
• AsyncSubject
• BehaviorSubject
• ReplaySubject
• PublishSubject
• SerializedSubject

47. RxRelay

48. RxRelay
• safer cousin of Subject
• https://github.com/JakeWharton/RxRelay

49. RxRelay
• Relay = Subject - onComplete() - onError()
• Relay = Observable & Action1
• call() instead of onNext()

50. Subject vs. RxRelay
• Subject
• stateful
• Relay
• stateless

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

52. Threading

53. Threading
• Parts of a data flow can run on different threads!
• Threading in RxJava defined by Schedulers

54. Schedulers
• computation()
• io()
• newThread()
• from(Executor)

55. Android Schedulers
• mainThread()
• from(Looper)

56. Threading
• operators have their default Schedulers
• check Javadoc!

57. Threading
• just()
• current thread
• delay(long, TimeUnit)
• computation() thread

58. Threading
• subscribeOn(Scheduler)
• subscribes to Observable on the Scheduler
• observeOn(Scheduler)
• Observable emits on the Scheduler

59. subscribeOn()
• multiple calls useless
• only the first call works!
• for all operators

60. observeOn()
• can be called multiple times
• changes Scheduler downstream

61. Side effect methods

62. Side effect methods
• doOnNext()
• doOnError()
• doOnCompleted()
• doOnSubscribe()
• doOnUnsubscribe()
• …

63. Async composition

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

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

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

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

68. Async composition

69. Android & RxJava

70. Android Lifecycle
• few complications
• continuing subscription during configuration
change
• memory leaks

71. Android Lifecycle
• continuing subscription during configuration
change
• replay()
• don’t use cache()

72. Android Lifecycle
• memory leaks
• bind to Activity/Fragment lifecycle
• use RxLifecycle

73. RxLifecycle

74. RxLifecycle
• auto unsubscribe based on Activity/Fragment
lifecycle
myObservable
.compose(
RxLifecycle.bindUntilEvent(
lifecycleObservable, ActivityEvent.DESTROY
)
)
.subscribe(…);
myObservable
.compose(RxLifecycle.bindActivity(lifecycleObs))
.subscribe(…);

75. RxLifecycle
• How to obtain ActivityEvent or
FragmentEvent?
A. rxlifecycle-components + subclass
RxActivity, RxFragment
B. Navi + rxlifecycle-navi
C. Write it yourself

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

77. RxLifecycle & Navi

78. Navi
• https://github.com/trello/navi
• better listeners for Activity/Fragment events
• decoupling code from Activity/Fragment
naviComponent.addListener(Event.CREATE,
new Listener<Bundle>() {
@Override public void call(Bundle bundle) {
setContentView(R.layout.main);
}
}
);

79. • converting lifecycle callbacks into Observables!
RxNavi
RxNavi
.observe(naviComponent, Event.CREATE)
.subscribe(bundle -> setContentView(R.layout.main));

80. RxLifecycle & Navi
public class MyActivity extends NaviActivity {
private final ActivityLifecycleProvider provider
= NaviLifecycle.createActivityLifecycleProvider(this);
}

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

82. RxLifecycle & custom solution
public class MainActivityFragment extends Fragment {
BehaviorSubject<FragmentEvent> mLifecycleSubject =
BehaviorSubject.create();
}

83. RxLifecycle & custom solution
public class MainActivityFragment extends Fragment {
BehaviorSubject<FragmentEvent> mLifecycleSubject =
BehaviorSubject.create();
@Override public void onPause() {
super.onPause();
Timber.i("onPause");
mLifecycleSubject.onNext(FragmentEvent.PAUSE);
}
}

84. public class MainActivityFragment extends Fragment {
BehaviorSubject<FragmentEvent> mLifecycleSubject =
BehaviorSubject.create();
@Override public void onPause() {
super.onPause();
Timber.i("onPause");
mLifecycleSubject.onNext(FragmentEvent.PAUSE);
}
@Override public void onResume() {
super.onResume();
myObservable // e.g. UI events Observable
.compose(
RxLifecycle
.bindUntilEvent(mLifecycleSubject, FragmentEvent.PAUSE))
.doOnUnsubscribe(() -> Timber.i("onUnsubscribe"))
.subscribe(…);
}
}
RxLifecycle & custom solution

85. RxBinding

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

87. RxBinding
RxTextView.textChanges(vEtSearch)
.observeOn(Schedulers.io())
.flatMap(s -> mApiService.search(s.toString()))
.subscribe(
response -> Timber.i("Count: " + response.totalCount())
);

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

89. RxBinding
RxTextView.textChanges(vEtSearch)
.debounce(2, TimeUnit.SECONDS)
.observeOn(Schedulers.io())
.flatMap(s -> mApiService.search(s.toString()))
.flatMap(response -> Observable.from(response.getItems())
.subscribe(
s -> Timber.i("item: " + s)
);

90. Retrofit

91. Retrofit
• sync or async API (Retrofit 2)
@GET("group/{id}/users")
Call<List<User>> groupList(@Path("id") int groupId);
@GET("group/{id}/users")
Observable<List<User>> groupList(@Path("id") int groupId);
• reactive API

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

93. Retrofit
RxTextView.textChanges(vEtSearch)
.debounce(2, TimeUnit.SECONDS)
.observeOn(Schedulers.io())
.flatMap(s ->
mApiService.search(s.toString())
)
.flatMap(list -> Observable.from(list))
.subscribe(
s -> Timber.i("item: " + s)
);

94. Retrofit
RxTextView.textChanges(vEtSearch)
.debounce(2, TimeUnit.SECONDS)
.observeOn(Schedulers.io())
.flatMap(s ->
mApiService.search(s.toString())
)
.flatMap(list -> Observable.from(list))
.subscribe(
s -> Timber.i("item: " + s)
);

95. RxJava & SQLite
• use SQLBrite
• wrapper around SQLiteOpenHelper and
ContentResolver
SqlBrite sqlBrite = SqlBrite.create();
BriteDatabase db = sqlBrite
.wrapDatabaseHelper(openHelper, Schedulers.io());
Observable<Query> users = db
.createQuery("users", "SELECT * FROM users");

96. References
• https://github.com/ReactiveX/RxJava
• https://github.com/ReactiveX/RxAndroid
• https://github.com/JakeWharton/RxRelay
• https://github.com/trello/RxLifecycle
• https://github.com/trello/navi
• https://github.com/JakeWharton/RxBinding
• https://github.com/square/retrofit
• https://github.com/square/sqlbrite
• advanced RxJava blog https://akarnokd.blogspot.com
• http://slides.com/yaroslavheriatovych/frponandroid

97. Q&A