Android Reactive Programming with RxJava Mohammed Touban 

Reactive Programming • Deal with asynchronous streams of data/events • Almost anything can be a stream • Single values • UI events • Individual items from a collection 

Reactive Programming • User clicks on a View • We react by performing some logic in a click listener • Data loaded from an HTTP request • We react by displaying parsed data in a View • IOException thrown while doing I/O work • We react by displaying error message, logging error, etc. 

Reactive Programming • So…callbacks? • Yes, but there’s more! • Callbacks are the main way we handle asynchronous events • Callbacks can add up…fast 

Callback Hell • Logic may be split up across classes • Ordering of callback events can be hard to follow / visualize • Handling multiple threads can be difficult, or at best verbose • Error handling becomes verbose and reduces readability 

Using Callbacks long friendId; void start() {
 service = retrofit.create(ApiService.class);
 service.getDetails().enqueue(new Callback() {
 @Override
 public void onResponse(Call call, Response response) {
 friendId = response.body().friendId;
 getFriendDetails();
 }
 
 @Override public void onFailure(Call call, Throwable t) {…}
 });
 } private void getFriendDetails() {
 service.getFriendDetails(friendId).enqueue(new Callback() {
 @Override
 public void onResponse(Call call, Response response) {…}
 
 @Override public void onFailure(Call call, Throwable t) {…}
 });
 } 

Using Callbacks long friendId; void start() {
 service = retrofit.create(ApiService.class);
 service.getDetails().enqueue(new Callback() {
 @Override
 public void onResponse(Call call, Response response) {
 friendId = response.body().friendId;
 getFriendDetails();
 }
 
 @Override public void onFailure(Call call, Throwable t) {…}
 });
 } private void getFriendDetails() {
 service.getFriendDetails(friendId).enqueue(new Callback() {
 @Override
 public void onResponse(Call call, Response response) {…}
 
 @Override public void onFailure(Call call, Throwable t) {…}
 });
 } 

Using Callbacks long friendId; void start() {
 service = retrofit.create(ApiService.class);
 service.getDetails().enqueue(new Callback() {
 @Override
 public void onResponse(Call call, Response response) {
 friendId = response.body().friendId;
 getFriendDetails();
 }
 
 @Override public void onFailure(Call call, Throwable t) {…}
 });
 } private void getFriendDetails() {
 service.getFriendDetails(friendId).enqueue(new Callback() {
 @Override
 public void onResponse(Call call, Response response) {…}
 
 @Override public void onFailure(Call call, Throwable t) {…}
 });
 } 

Using Callbacks long friendId; void start() {
 service = retrofit.create(ApiService.class);
 service.getDetails().enqueue(new Callback() {
 @Override
 public void onResponse(Call call, Response response) {
 friendId = response.body().friendId;
 getFriendDetails();
 }
 
 @Override public void onFailure(Call call, Throwable t) {…}
 });
 } private void getFriendDetails() {
 service.getFriendDetails(friendId).enqueue(new Callback() {
 @Override
 public void onResponse(Call call, Response response) {…}
 
 @Override public void onFailure(Call call, Throwable t) {…}
 });
 } 

Using Callbacks • Stateful environment leads to side effects • Side effects aren’t inherently bad, but can be unpredictable • Following the logic is not as clear as we’d like • How can we do better? 

Functional Programming - Extreme Basics • Programming without assignments • Values are computed and shared with subsequent functions • This continues until you get your final result • No “state” 

Functional Reactive Programming • Combining reactive programming with concepts of functional programming • Gives predictable results without worrying about “side-effects” (state) • Logic for a stream is concentrated in one place • Logic for each function can still be split out where it makes sense 

Using Callbacks long friendId; void start() {
 service = retrofit.create(ApiService.class);
 service.getDetails().enqueue(new Callback() {
 @Override
 public void onResponse(Call call, Response response) {
 friendId = response.body().friendId;
 getFriendDetails();
 }
 
 @Override public void onFailure(Call call, Throwable t) {…}
 });
 } private void getFriendDetails() {
 service.getFriendDetails(friendId).enqueue(new Callback() {
 @Override
 public void onResponse(Call call, Response response) {…}
 
 @Override public void onFailure(Call call, Throwable t) {…}
 });
 } 

Using Functional Reactive Programming void start() {
 service.getDetailsObservable()
 .flatMap(apiResponse -> service.getFriendDetailsObservable(apiResponse.friendId))
 .subscribeOn(Schedulers.io())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(friendDetails -> {…}, throwable -> {…});
 } 

Using Functional Reactive Programming void start() {
 service.getDetailsObservable()
 .flatMap(apiResponse -> service.getFriendDetailsObservable(apiResponse.friendId))
 .subscribeOn(Schedulers.io())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(friendDetails -> {…}, throwable -> {…});
 } 

Using Functional Reactive Programming void start() {
 service.getDetailsObservable()
 .flatMap(apiResponse -> service.getFriendDetailsObservable(apiResponse.friendId))
 .subscribeOn(Schedulers.io())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(friendDetails -> {…}, throwable -> {…});
 } 

Using Functional Reactive Programming void start() {
 service.getDetailsObservable()
 .flatMap(apiResponse -> service.getFriendDetailsObservable(apiResponse.friendId))
 .subscribeOn(Schedulers.io())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(friendDetails -> {…}, throwable -> {…});
 } 

Using Functional Reactive Programming void start() {
 service.getDetailsObservable()
 .flatMap(apiResponse -> service.getFriendDetailsObservable(apiResponse.friendId))
 .subscribeOn(Schedulers.io())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(friendDetails -> {…}, throwable -> {…});
 } 

Using Functional Reactive Programming void start() {
 service.getDetailsObservable()
 .flatMap(apiResponse -> service.getFriendDetailsObservable(apiResponse.friendId))
 .subscribeOn(Schedulers.io())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(friendDetails -> {…}, throwable -> {…});
 } 

Using Functional Reactive Programming • There are no assignments in the previous code sample • Logic is concise and easy to follow • Error handling is simplified • Imagine if yet another service call was needed in this chain 

Hey…I could use Callbacks without assignment void start() {
 service = retrofit.create(ApiService.class);
 Call call = service.getDetails();
 call.enqueue(new Callback() {
 @Override
 public void onResponse(Call call, Response response) {
 service.getFriendDetails(response.body().friendId).enqueue(new Callback() {
 @Override
 public void onResponse(Call call, Response response) {…}
 
 @Override public void onFailure(Call call, Throwable t) {…}
 });
 }
 
 @Override public void onFailure(Call call, Throwable t) {…}
 });
 } 

Hey…I could use Callbacks without assignment void start() {
 service = retrofit.create(ApiService.class);
 Call call = service.getDetails();
 call.enqueue(new Callback() {
 @Override
 public void onResponse(Call call, Response response) {
 service.getFriendDetails(response.body().friendId).enqueue(new Callback() {
 @Override
 public void onResponse(Call call, Response response) {
 service.getFriendMessages(response.body().id).enqueue(new Callback>() {
 @Override
 public void onResponse(Call> call, Response> response) {…}
 
 @Override public void onFailure(Call> call, Throwable t) {…}
 });
 }
 
 @Override public void onFailure(Call call, Throwable t) {…}
 });
 }
 
 @Override public void onFailure(Call call, Throwable t) {…}
 });
 } 

Using Functional Reactive Programming void stream() {
 service.getDetailsObservable()
 .flatMap(apiResponse -> service.getFriendDetailsObservable(apiResponse.friendId))
 .doOnNext(friendDetails -> {…})
 .flatMap(friendDetails -> service.getFriendMessagesObservable(friendDetails.id))
 .subscribeOn(Schedulers.io())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(friendMessages -> "", throwable -> );
 } 

Using Functional Reactive Programming void stream() {
 service.getDetailsObservable()
 .flatMap(apiResponse -> service.getFriendDetailsObservable(apiResponse.friendId))
 .doOnNext(friendDetails -> {…})
 .flatMap(friendDetails -> service.getFriendMessagesObservable(friendDetails.id))
 .subscribeOn(Schedulers.io())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(friendMessages -> "", throwable -> );
 } 

Reactive Extensions (Rx) • Framework developed by Microsoft • Many implementations of it across most popular languages • Rx.NET, RxJS, RxCpp, RxPy, UniRx (Unity C#), RxSwift, RxJava, RxKotlin 

RxJava • Ported by Netflix • Version 1 was released in Nov 18, 2014 after 2 years of development • Version 2 is currently stable 

RxJava • Extremely easy threading • Large amount of operators to transform your stream of data • Simplified error handling 

RxJava • Steep learning curve • Going beyond AsyncTask replacement requires new mindset • Difficult to get yourself to “think reactive” • Easy to drop in piece-by-piece 

RxJava • Observables • Observers • Operators 

RxJava - Observables • Object that can be subscribed to by an Observer • Emits item(s) • Building block of the stream 

RxJava - Observers • Subscribe to Observables • Three methods • onNext • onComplete • onError 

RxJava - Observers • onNext - every emitted item from an Observable • onComplete - Observable finished emitting • onError - error thrown at any point in Observable chain 

RxJava - Observers Observable.just("Hello")
 .subscribe(new Action1() {
 @Override public void call(String s) {
 Log.d("TAG", s); // Logs "Hello"
 }
 }, new Action1() {
 @Override public void call(Throwable throwable) {
 Log.e("TAG", "Error in Observable chain", throwable);
 }
 }, new Action0() {
 @Override public void call() {
 Log.d("TAG", "Observable finished emitting items");
 }
 }); 

RxJava - Observers Observable.just("Hello")
 .subscribe(new Action1() {
 @Override public void call(String s) {
 Log.d("TAG", s); // Logs "Hello"
 }
 }, new Action1() {
 @Override public void call(Throwable throwable) {
 Log.e("TAG", "Error in Observable chain", throwable);
 }
 }, new Action0() {
 @Override public void call() {
 Log.d("TAG", "Observable finished emitting items");
 }
 }); 

RxJava - Observers Observable.just("Hello")
 .subscribe(new Action1() {
 @Override public void call(String s) {
 Log.d("TAG", s); // Logs "Hello"
 }
 }, new Action1() {
 @Override public void call(Throwable throwable) {
 Log.e("TAG", "Error in Observable chain", throwable);
 }
 }, new Action0() {
 @Override public void call() {
 Log.d("TAG", "Observable finished emitting items");
 }
 }); 

RxJava - Observers Observable.just("Hello")
 .subscribe(new Action1() {
 @Override public void call(String s) {
 Log.d("TAG", s); // Logs "Hello"
 }
 }, new Action1() {
 @Override public void call(Throwable throwable) {
 Log.e("TAG", "Error in Observable chain", throwable);
 }
 }, new Action0() {
 @Override public void call() {
 Log.d("TAG", "Observable finished emitting items");
 }
 }); 

RxJava - Observers Observable.just("Hello")
 .subscribe(new Action1() {
 @Override public void call(String s) {
 Log.d("TAG", s); // Logs "Hello"
 }
 }, new Action1() {
 @Override public void call(Throwable throwable) {
 Log.e("TAG", "Error in Observable chain", throwable);
 }
 }, new Action0() {
 @Override public void call() {
 Log.d("TAG", "Observable finished emitting items");
 }
 }); 

RxJava - Observers Observable.just("Hello")
 .subscribe(s -> Log.d("TAG", s),
 throwable -> Log.e("TAG", "Error in Observable chain", throwable),
 () -> Log.d("TAG", "Observable finished emitting items")); 

RxJava - Observers Observable.just("Hello")
 .subscribe(s -> Log.d("TAG", s),
 throwable -> Log.e("TAG", "Error in Observable chain", throwable)); 

RxJava - Observers Observable.just("Hello")
 .subscribe(s -> Log.d("TAG", s)); 

RxJava - Observables • The building block of the chain • Operators for most any transformation you want to do • In charge of calling onNext/onComplete/onError • In charge of handling back pressure* 

RxJava - Subjects public abstract class Subject extends Observable implements Observer • Observable and Observer • Good for bridging non-reactive API • Can act like a more explicit event bus 

RxJava - Subjects public class NetworkChangeReceiver extends BroadcastReceiver {
 
 @Inject BehaviorSubject wifiSubject;
 
 @Override public void onReceive(Context context, Intent intent) {
 /* */
 boolean wifi = networkInfo.getType() == ConnectivityManager.TYPE_WIFI;
 wifiSubject.onNext(wifi);
 }
 } public class UploadService extends Service {
 
 @Inject BehaviorSubject wifiSubject;
 
 @Override public int onStartCommand(Intent intent, int flags, int startId) { /* */
 wifiSubject.subscribe(isWifi -> {
 if (isWifi) {
 startUpload();
 } else {
 pauseUpload();
 }
 });
 return super.onStartCommand(intent, flags, startId);
 }
 /* */
 } 

RxJava - Subjects public class NetworkChangeReceiver extends BroadcastReceiver {
 
 @Inject BehaviorSubject wifiSubject;
 
 @Override public void onReceive(Context context, Intent intent) {
 /* */
 boolean wifi = networkInfo.getType() == ConnectivityManager.TYPE_WIFI;
 wifiSubject.onNext(wifi);
 }
 } public class UploadService extends Service {
 
 @Inject BehaviorSubject wifiSubject;
 
 @Override public int onStartCommand(Intent intent, int flags, int startId) {
 /* */
 wifiSubject.subscribe(isWifi -> {
 if (isWifi) {
 startUpload();
 } else {
 pauseUpload();
 }
 });
 return super.onStartCommand(intent, flags, startId);
 }
 /* */
 } 

RxJava - Subjects public class NetworkChangeReceiver extends BroadcastReceiver {
 
 @Inject BehaviorSubject wifiSubject;
 
 @Override public void onReceive(Context context, Intent intent) {
 /* */
 boolean wifi = networkInfo.getType() == ConnectivityManager.TYPE_WIFI;
 wifiSubject.onNext(wifi);
 }
 } public class UploadService extends Service {
 
 @Inject BehaviorSubject wifiSubject;
 
 @Override public int onStartCommand(Intent intent, int flags, int startId) {
 /* */
 wifiSubject.subscribe(isWifi -> {
 if (isWifi) {
 startUpload();
 } else {
 pauseUpload();
 }
 });
 return super.onStartCommand(intent, flags, startId);
 }
 /* */
 } 

RxJava - Operators • Can transform observable stream • Can give access to emitted items at any point in the stream • Can specify Schedulers to run on 

RxJava - Operators • subscribeOn / observeOn getStringObservable()
 .subscribeOn(Schedulers.io())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(textView::setText); 

RxJava - Operators • map • flatMap • zip / zipWith • combineLatest • filter • doOnNext 

RxJava - Marble Diagrams 

RxJava - Where to Start • AsyncTask replacement • Retrofit requests • List filtering* 

Async Task RxJava ComputationTask computationTask = new ComputationTask(this);
 computationTask.execute("input"); /** **/ class ComputationTask extends AsyncTask {
 
 private final SearchMessagesTask.SearchListener listener;
 
 ComputationTask(SearchMessagesTask.SearchListener listener) {
 this.listener = listener;
 }
 
 @Override protected Long doInBackground(String... params) {
 return longRunningFunction(params[0]);
 }
 
 @Override protected void onPostExecute(Long result) {
 listener.computationCompleted(result);
 }
 } Observable.fromCallable(() -> longRunningFunction(“input”))
 .subscribeOn(Schedulers.computation())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(this::computationCompleted); 

Async Task RxJava ComputationTask computationTask = new ComputationTask(this);
 computationTask.execute("input"); /** **/ class ComputationTask extends AsyncTask {
 
 private final SearchMessagesTask.SearchListener listener;
 
 ComputationTask(SearchMessagesTask.SearchListener listener) {
 this.listener = listener;
 }
 
 @Override protected Long doInBackground(String... params) {
 return longRunningFunction(params[0]);
 }
 
 @Override protected void onPostExecute(Long result) {
 listener.computationCompleted(result);
 }
 } Observable.fromCallable(() -> longRunningFunction(“input”))
 .subscribeOn(Schedulers.computation())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(this::computationCompleted); 

Async Task RxJava SearchMessagesTask task = new SearchMessagesTask(this, allMessages);
 task.execute("Dinner"); /** **/ class SearchMessagesTask extends AsyncTask> {
 
 private final SearchListener listener;
 private final List allMessages;
 
 SearchMessagesTask(SearchListener listener, List allMessages) {
 this.listener = listener;
 this.allMessages = allMessages;
 }
 
 @Override protected List doInBackground(String... params) {
 String searchTerm = params[0];
 List messages = new ArrayList<>();
 for (Test.Message message : allMessages) {
 if (message.body.contains(searchTerm)) {
 messages.add(message);
 }
 }
 return messages;
 }
 
 @Override protected void onPostExecute(List messages) {
 listener.onSearchCompleted(messages);
 }
 } Observable.from(allMessages)
 .filter(message -> message.body.contains("Dinner"))
 .toList()
 .subscribeOn(Schedulers.computation())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(this::displayMessages); 

Async Task RxJava SearchMessagesTask task = new SearchMessagesTask(this, allMessages);
 task.execute("Dinner"); /** **/ class SearchMessagesTask extends AsyncTask> {
 
 private final SearchListener listener;
 private final List allMessages;
 
 SearchMessagesTask(SearchListener listener, List allMessages) {
 this.listener = listener;
 this.allMessages = allMessages;
 }
 
 @Override protected List doInBackground(String... params) {
 String searchTerm = params[0];
 List messages = new ArrayList<>();
 for (Test.Message message : allMessages) {
 if (message.body.contains(searchTerm)) {
 messages.add(message);
 }
 }
 return messages;
 }
 
 @Override protected void onPostExecute(List messages) {
 listener.onSearchCompleted(messages);
 }
 } Observable.from(allMessages)
 .filter(message -> message.body.contains("Dinner"))
 .toList()
 .subscribeOn(Schedulers.computation())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(this::displayMessages); 

Async Task RxJava SearchMessagesTask task = new SearchMessagesTask(this, allMessages);
 task.execute("Dinner"); /** **/ class SearchMessagesTask extends AsyncTask> {
 
 private final SearchListener listener;
 private final List allMessages;
 
 SearchMessagesTask(SearchListener listener, List allMessages) {
 this.listener = listener;
 this.allMessages = allMessages;
 }
 
 @Override protected List doInBackground(String... params) {
 String searchTerm = params[0];
 List messages = new ArrayList<>();
 for (Test.Message message : allMessages) {
 if (message.body.contains(searchTerm)) {
 messages.add(message);
 }
 }
 return messages;
 }
 
 @Override protected void onPostExecute(List messages) {
 listener.onSearchCompleted(messages);
 }
 } Observable.from(allMessages)
 .filter(message -> message.body.contains("Dinner"))
 .toList()
 .subscribeOn(Schedulers.computation())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(this::displayMessages); 

Async Task RxJava SearchMessagesTask task = new SearchMessagesTask(this, allMessages);
 task.execute("Dinner"); /** **/ class SearchMessagesTask extends AsyncTask> {
 
 private final SearchListener listener;
 private final List allMessages;
 
 SearchMessagesTask(SearchListener listener, List allMessages) {
 this.listener = listener;
 this.allMessages = allMessages;
 }
 
 @Override protected List doInBackground(String... params) {
 String searchTerm = params[0];
 List messages = new ArrayList<>();
 for (Test.Message message : allMessages) {
 if (message.body.contains(searchTerm)) {
 messages.add(message);
 }
 }
 return messages;
 }
 
 @Override protected void onPostExecute(List messages) {
 listener.onSearchCompleted(messages);
 }
 } Observable.from(allMessages)
 .filter(message -> message.body.contains("Dinner"))
 .toList()
 .subscribeOn(Schedulers.computation())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(this::displayMessages); 

Callback Observable service.getDetails().enqueue(new Callback() {
 @Override
 public void onResponse(Call call, Response response) {
 handleResponse(response.body());
 }
 
 @Override public void onFailure(Call call, Throwable t) {
 handleError(t);
 }
 }); service.getDetailsObservable()
 .subscribeOn(Schedulers.io())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(this::handleResponse, this::handleError); 

Callback Observable service.getDetails().enqueue(new Callback() {
 @Override
 public void onResponse(Call call, Response response) {
 handleResponse(response.body());
 }
 
 @Override public void onFailure(Call call, Throwable t) {
 handleError(t);
 }
 }); service.getDetailsObservable()
 .subscribeOn(Schedulers.io())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(this::handleResponse, this::handleError); 

Callback Observable service.getDetails().enqueue(new Callback() {
 @Override
 public void onResponse(Call call, Response response) {
 handleResponse(response.body());
 }
 
 @Override public void onFailure(Call call, Throwable t) {
 handleError(t);
 }
 }); service.getDetailsObservable()
 .subscribeOn(Schedulers.io())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(this::handleResponse, this::handleError); 

Callback Observable service.getDetails().enqueue(new Callback() {
 @Override
 public void onResponse(Call call, Response response) {
 handleResponse(response.body());
 }
 
 @Override public void onFailure(Call call, Throwable t) {
 handleError(t);
 }
 }); service.getDetailsObservable()
 .subscribeOn(Schedulers.io())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(this::handleResponse, this::handleError); retrofit = new Retrofit.Builder()
 .baseUrl("")
 .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
 .build(); implementation ‘com.squareup.retrofit2:adapter-rxjava:x.y.z’ 

For Loop Observable List filteredList = new ArrayList(); for (Integer integer : integers) {
 if (integer % 3 == 0) {
 filteredList.add(integer);
 }
 }
 return filteredList; Observable.from(integers)
 .filter(integer -> integer % 3 == 0)
 .toList()
 .subscribe(filteredList -> {}); 

Observable fromScratchUploadObservable() { return Observable.just(videoToUpload.videoFile.getUri()) .flatMap(vimeoUploadInformationObservableFactory::get) .flatMap(uploadFromScratchObservableFactory.get()) .flatMap(closeUploadTicket()) .flatMap(updateVideoMetaData()) .map(saveToBuilderTrend()) .subscribeOn(Schedulers.io()); } Observable resumeUploadObservable() { return Observable.just(videoToUpload.vimeoUploadInfo) .flatMap(resumeObservableFactory::get) .flatMap(closeUploadTicket()) .flatMap(updateVideoMetaData()) .map(saveToBuilderTrend()) .subscribeOn(Schedulers.io()); } 

Helpful links RxJava Introduction Grokking RxJava series (Dan Lew) http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/ RxJava Advanced Demystifying RxJava Subscribers (Jake Wharton) https://vimeo.com/144812843 Rx Libraries Common RxJava Mistakes (Dan Lew) https://www.youtube.com/watch?v=QdmkXL7XikQ RxJava https://github.com/ReactiveX/RxJava RxAndroid https://github.com/ReactiveX/RxAndroid RxBinding https://github.com/JakeWharton/RxBinding RxRelay https://github.com/JakeWharton/RxRelay Loading data from multiple sources (Dan Lew) http://blog.danlew.net/2015/06/22/loading-data-from-multiple-sources-with-rxjava/ Learning RxJava by example (Kaushik Gopal) https://www.youtube.com/watch?v=k3D0cWyNno4 RxKotlin https://github.com/ReactiveX/RxKotlin