The Mayans Lost Guide to RxJava on Android

The Mayans Lost Guide to RxJava on Android

In this little journey, we are gonna see what RxJava offers to us in terms of android development. We will also learn how we can apply it to real life mobile projects by showing different examples and use cases.

12defde716586eb2d726d081a161756d?s=128

Fernando Cejas

April 25, 2015
Tweet

Transcript

  1. @fernando_cejas http://www.fernandocejas.com The Mayans Lost Guide To RxJava on Android

  2. @fernando_cejas Curious learner Meet... Android lover Software engineer Geek

  3. None
  4. #Reactive 1- of, relating to, or marked by reaction or

    reactance. 2- readily responsive to a stimulus.
  5. RxJava is a Java VM implementation of Reactive X (Reactive

    Extensions): ˝ a library for composing asynchronous and event-based programs by using observable sequences. What is RxJava?
  6. Why should we go reactive?

  7. Multithreading is always complex˝ Concurrency˝ Java Futures are Expensive to

    Compose˝ Java Futures˝ Callbacks Have Their Own Problems˝ Callbacks˝ @benjchristensen from @netflix
  8. public class FuturesA { public static void run() throws Exception

    { ExecutorService executor = new ThreadPoolExecutor(4, 4, 1, TimeUnit.MINUTES, new LinkedBlockingQueue<Runnable>()); Future<String> f1 = executor.submit(new CallToRemoteServiceA()); Future<String> f2 = executor.submit(new CallToRemoteServiceB()); System.out.println(f1.get() + " - " + f2.get()); } } https://gist.github.com/benjchristensen/4670979 #Java Futures
  9. #Java Futures https://gist.github.com/benjchristensen/4671081 public static void run() throws Exception {

    ExecutorService executor = new ThreadPoolExecutor(4, 4, 1, TimeUnit.MINUTES, new LinkedBlockingQueue<Runnable>()); try { // get f3 with dependent result from f1 Future<String> f1 = executor.submit(new CallToRemoteServiceA()); Future<String> f3 = executor.submit(new CallToRemoteServiceC(f1.get())); /* The work below can not proceed until f1.get() completes even though there is no dependency */ // also get f4/f5 after dependency f2 completes Future<Integer> f2 = executor.submit(new CallToRemoteServiceB()); Future<Integer> f4 = executor.submit(new CallToRemoteServiceD(f2.get())); Future<Integer> f5 = executor.submit(new CallToRemoteServiceE(f2.get())); System.out.println(f3.get() + " => " + (f4.get() * f5.get())); } finally { executor.shutdownNow(); } }
  10. #Java Futures https://gist.github.com/benjchristensen/4671081 public static void run4() throws Exception {

    ExecutorService executor = new ThreadPoolExecutor(4, 4, 1, TimeUnit.MINUTES, new LinkedBlockingQueue<Runnable>()); try { List<Future<?>> futures = new ArrayList<Future<?>>(); // kick off several async tasks futures.add(executor.submit(new CallToRemoteServiceA())); futures.add(executor.submit(new CallToRemoteServiceB())); futures.add(executor.submit(new CallToRemoteServiceC("A"))); futures.add(executor.submit(new CallToRemoteServiceC("B"))); futures.add(executor.submit(new CallToRemoteServiceD(1))); futures.add(executor.submit(new CallToRemoteServiceE(2))); futures.add(executor.submit(new CallToRemoteServiceE(3))); // as each completes do further work for (Future<?> f : futures) { /* this blocks so even if other futures in the list complete earlier they will wait until this one is done */ doMoreWork(f.get()); } } finally { executor.shutdownNow(); } }
  11. Multithreading is always complex˝ Concurrency˝ Java Futures are Expensive to

    Compose˝ Java Futures˝ Callbacks Have Their Own Problems˝ Callbacks˝ @benjchristensen from @netflix
  12. #Callbacks https://gist.github.com/benjchristensen/4677544 ... // get f3 with dependent result from

    f1 executor.execute(new CallToRemoteServiceA(new Callback<String>() { @Override public void call(String f1) { executor.execute(new CallToRemoteServiceC(new Callback<String>() { @Override public void call(String f3) { // we have f1 and f3 now need to compose with others System.out.println("intermediate callback: " + f3 + " => " + ("f4 * f5")); // set to thread-safe variable accessible by external scope f3Value.set(f3); latch.countDown(); } }, f1)); } })); ...
  13. Observables Subscribers Subscriptions Schedulers Operators #RxJava Guys:

  14. Observables The Observable object is who does the job. Represents

    an object that sends notifications (Provider) to a Subscriptor (Observer).
  15. Observables Add 2 missing semantics to the Observer pattern: #1:

    Emits a signal to the consumer when there is no more data available. #2: Emits a signal to the consumer when an error has occurred.
  16. Observables

  17. Observables

  18. Subscribers Subscribers provides a mechanism for receiving push- based notifications

    from Observables, and permits manual unsubscribing from these Observables.
  19. Subscribers Not an observer pattern: Observables often don't start emitting

    items until someone explicitly subscribes to them.
  20. Subscribers Observables often don't start emitting items until someone explicitly

    subscribes to them.
  21. Subscribers public class DefaultSubscriber<T> extends rx.Subscriber<T> { @Override public void

    onCompleted() { } @Override public void onError(Throwable e) { } @Override public void onNext(T t) { } }
  22. Subscriptions Subscriptions represents the link between your Observable and your

    Subscriber. #1: Subscriptions #2: CompositeSubscriptions
  23. #1: Schedulers.io() #2: Schedulers.computation() #3: Schedulers.from() Schedulers If you want

    to introduce multithreading into your cascade of Observable operators, you can do so by instructing those operators (or particular Observables) to operate on particular Schedulers.
  24. Operators Operators can be used in between the source Observable

    and the ultimate Subscriber to manipulate emitted items. You can even write your own custom operators.
  25. map() Transform the items emitted by an Observable by applying

    a function to each item.
  26. flatMap() Transforms the items emitted by an Observable into Observables,

    then flatten the emissions from those into a single Observable (no order)
  27. concatMap() Transforms the items emitted by an Observable into Observables,

    then flatten the emissions from those into a single Observable (keeps order)
  28. flatMap() vs concatMap() http://fernandocejas.com/2015/01/11/rxjava-observable-tranformation-concatmap-vs-flatmap/

  29. filter() Emits the same item it received, but only if

    it passes the boolean check (predicate).
  30. take() Emit only the first n items emitted by an

    Observable
  31. doOnNext() Allows us to add extra behavior each time an

    item is emitted.
  32. onError() is called if an exception is thrown at any

    time. Error handling The operators do not have to handle the exception.
  33. onErrorResumeNext() Instructs an Observable to emit a sequence of items

    if it encounters an error. onErrorReturn() Instructs an Observable to emit a particular item when it encounters an error. onExceptionResumeNext() Instructs an Observable to continue emitting items after it encounters an exception. retry() If a source Observable emits an error, resubscribe to it in the hopes that it will complete without error. retryWhen() If a source Observable emits an error, pass that error to another Observable to determine whether to resubscribe to the source. Error handling Operators
  34. #1: Observable and Subscriber can do anything #2: The Observable

    and Subscriber are independent of the transformational steps in between them. #3: Operators let you do anything to the stream of data. Key ideas behind RxJava http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/
  35. #1: Learning curve #2: Too many anonymous classes generated (OutOfMemory?)

    #3: Verbosity (retrolambda to the rescue?) But there are some pitfalls…
  36. #Example: Clean Architecture

  37. #Example: Clean Architecture

  38. @PerActivity public class UserListPresenter extends DefaultSubscriber<List<User>> implements Presenter { private

    UserListView viewListView; private final UseCase getUserListUseCase; @Inject public UserListPresenter(@Named("userList") UseCase getUserListUserCase, UserModelDataMapper userModelDataMapper) { this.getUserListUseCase = getUserListUserCase; } @Override public void destroy() { this.getUserListUseCase.unsubscribe(); } private void getUserList() { this.getUserListUseCase.execute(this); } ... } #Example: Reactive Presenter
  39. #Example: Reactive Presenter @PerActivity public class UserListPresenter extends DefaultSubscriber<List<User>> implements

    Presenter { ... @Override public void onCompleted() { this.hideViewLoading(); } @Override public void onError(Throwable e) { this.hideViewLoading(); this.showErrorMessage(new DefaultErrorBundle((Exception) e)); this.showViewRetry(); } @Override public void onNext(List<User> users) { this.showUsersCollectionInView(users); } }
  40. #Example: Clean Architecture

  41. #Example: UseCase public abstract class UseCase { private final ThreadExecutor

    threadExecutor; private final PostExecutionThread postExecutionThread; private Subscription subscription = Subscriptions.empty(); protected UseCase(ThreadExecutor threadExecutor, PostExecutionThread postExecutionThread) { this.threadExecutor = threadExecutor; this.postExecutionThread = postExecutionThread; } protected abstract Observable buildUseCaseObservable(); public void execute(Subscriber UseCaseSubscriber) { this.subscription = this.buildUseCaseObservable() .subscribeOn(Schedulers.from(threadExecutor)) .observeOn(postExecutionThread.getScheduler()) .subscribe(UseCaseSubscriber); } public void unsubscribe() { if (!subscription.isUnsubscribed()) subscription.unsubscribe(); } }
  42. #Example: Execution Thread /** * MainThread (UI Thread) implementation based

    on a * {@link rx.Scheduler} which will execute actions on * the Android UI thread */ @Singleton public class UIThread implements PostExecutionThread { @Inject public UIThread() {} @Override public Scheduler getScheduler() { return AndroidSchedulers.mainThread(); } }
  43. #Example: UseCase /** * This class is an implementation of

    {@link UseCase} that represents a * use case for retrieving a collection of all {@link User}. */ public class GetUserListUseCase extends UseCase { private final UserRepository userRepository; @Inject public GetUserListUseCase(UserRepository userRepository, ThreadExecutor threadExecutor, PostExecutionThread postExecutionThread) { super(threadExecutor, postExecutionThread); this.userRepository = userRepository; } @Override public Observable buildUseCaseObservable() { return this.userRepository.getUsers(); } }
  44. #Example: Clean Architecture

  45. #Example: Operator and Action public class CloudUserDataStore implements UserDataStore {

    private final RestApi restApi; private final UserCache userCache; private final Action1<UserEntity> saveToCacheAction = new Action1<UserEntity>() { @Override public void call(UserEntity userEntity) { if (userEntity != null) { CloudUserDataStore.this.userCache.put(userEntity); } } }; public CloudUserDataStore(RestApi restApi, UserCache userCache) { this.restApi = restApi; this.userCache = userCache; } @Override public Observable<List<UserEntity>> getUserEntityList() { return this.restApi.getUserEntityList(); } @Override public Observable<UserEntity> getUserEntityDetails(final int userId) { return this.restApi.getUserEntityById(userId).doOnNext(saveToCacheAction); } }
  46. #Example: Data transformation @Singleton public class UserDataRepository implements UserRepository {

    private final UserDataStoreFactory userDataStoreFactory; private final UserEntityDataMapper userEntityDataMapper; private final Func1<List<UserEntity>, List<User>> userListEntityMapper = new Func1<List<UserEntity>, List<User>>() { @Override public List<User> call(List<UserEntity> userEntities) { return UserDataRepository.this.userEntityDataMapper.transform(userEntities); } }; private final Func1<UserEntity, User> userDetailsEntityMapper = new Func1<UserEntity, User>() { @Override public User call(UserEntity userEntity) { return UserDataRepository.this.userEntityDataMapper.transform(userEntity); } }; @Override public Observable<List<User>> getUsers() { final UserDataStore userDataStore = this.userDataStoreFactory.createCloudDataStore(); return userDataStore.getUserEntityList().map(userListEntityMapper); } }
  47. #Example: Observable creation @Override public Observable<List<UserEntity>> getUserEntityList() { return Observable.create(new

    Observable.OnSubscribe<List<UserEntity>>() { @Override public void call(Subscriber<? super List<UserEntity>> subscriber) { if (isThereInternetConnection()) { try { String responseUserEntities = getUserEntitiesFromApi(); subscriber.onNext(userEntityJsonMapper.transformUserEntityCollection( responseUserEntities)); subscriber.onCompleted(); } catch (Exception e) { subscriber.onError(new NetworkConnectionException(e.getCause())); } } else { subscriber.onError(new NetworkConnectionException()); } } }); }
  48. #1: Good starting point to switch to Rx Observables. #2:

    No need to deal with threading an synchronization. #3: Very simple to wrap an http connection in an Observable How do I start with RxJava? Rx at data level
  49. #1: We can convert our events into Rx Observables How

    do I start with RxJava? Rx at view level Observable input = Observable.FromEventPattern(textView, "TextChanged") .Select(_ => textbox.Text) .Throttle(TimeSpan.FromSeconds(0.5)) .DistinctUntilChanged();
  50. #1: You will return Rx Observables in domain layer. #2:

    Be careful with side effects (Rx Schedulers other than UI Thread) How do I start with RxJava? Rx at domain level
  51. #1: By default, RxJava is synchronous. #2: onSubscribe() is executed

    separately for every new subscriber. #3: Subscriptions leak memory. Tips and Tricks #4: Read the official documentation
  52. References Reactive Programming on Android With RxJava https://mttkay.github.io/blog/2013/08/25/functional-reactive-programming-on-android-with-rxjava/ Grokking RxJava

    http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/ Reactive Programming in the Netflix API with RxJava http://techblog.netflix.com/2013/02/rxjava-netflix-api.html Rx for .NET and RxJava for Android http://futurice.com/blog/tech-pick-of-the-week-rx-for-net-and-rxjava-for-android https://github.com/android10/Android-CleanArchitecture Official Documentation https://github.com/ReactiveX/RxJava/wiki https://github.com/android10/Android-ReactiveProgramming
  53. ? ˝ Source: US Census Bureau Questions

  54. @fernando_cejas http://soundcloud.com/jobs Thanks!