Get out of my thread (Programando en diferido)

One big problem in Android working with Android is to implement long time running tasks. In this talk we review and compare some libraries to resolve this problem. AnsyncTask? RxJava? Agera? JDeferred? which is the winner? perfomance issues? learn curve? when use each one?

Transcript

1. Programando en diferido (Get out of my thread) Jorge Juan Barroso Carmona jorge@karumi.com @flipper83 +JorgeJBarroso Android expert android GDE
2. Basho. Poet Karumi is the beauty of ordinary things spoken of in a simple way.
3. Miguel Noguera
4. Reactive Manifesto
5. Mem Cache Responsive
6. Mem Cache Resilient
7. Mem Cache Elastic
8. Mem Cache Message Driven
9. Mem Cache The manifesto is not concrete
10. Adam Tornhill “First, solve the problem. Then, write the code.” John Johnson.
11. Adam Tornhill
12. Async Task
13. Mem Cache Really close to the UI Thread and to the framework.
14. Mem Cache 
 task.execute()
 vs
 task.executeOnExecutor (AsyncTask.THREAD_POOL_EXECUTOR)
15. Mem Cache 
 Problems changing orientation.
16. Mem Cache
17. Priority Job Queue
18. Mem Cache Producer - consumer approach.
19. Mem Cache Priorities, group, delay, store … jobs
20. Mem Cache Need consumers configuration.
21. Mem Cache
22. Mem Cache We need to find a way to notify responders. Buses? callbacks? post on handler?
23. Mem Cache “Callback hell” if we need coordinate a lot of Jobs.
24. Promises (JDeferred)
25. Mem Cache Future and Promises
26. Mem Cache We can choose execution and responses thread with ExecutionServices and ExecutionScope.
27. Mem Cache
28. Mem Cache We can coordinate promises. DeferredManager dm = new DefaultDeferredManager(); Promise p1, p2, p3; // initialize p1, p2, p3 dm.when(p1, p2, p3) .done(…) .fail(…)
29. Mem Cache We can do operations over the promises. Filter (Map) Deferred d = …; Promise p = d.promise(); Promise filtered = p.then(new DoneFilter<Integer, Integer>() { public Integer filterDone(Integer result) return result * 10; } });
30. Agera
31. Mem Cache Agera is a set of classes and interfaces to help write functional, asynchronous, and reactive applications for Android.
32. Mem Cache apiRepository = Repositories
 .repositoryWithInitialValue (Result.<ApiResponse>absent())
 .observe()
 .onUpdatesPerLoop()
 .goTo(Executors.newSingleThreadExecutor())
 .thenGetFrom(apiSupplier)
 .compile();
33. apiRepository.addUpdatable(this); 
 apiRepository.removeUpdatable(this); You need link this methods to the Android lifecycle.
34. Mem Cache swipeRefreshLayout.setOnRefreshListener(refresh Observable); apiRepository = Repositories
 .repositoryWithInitialValue (Result.<ApiResponse>absent())
 .observe(refreshObservable)
 .onUpdatesPerLoop()
 .goTo(Executors.newSingleThreadExecutor())
 .thenGetFrom(apiSupplier)
 .compile();
35. Mem Cache listAdapter = RepositoryAdapter.repositoryAdapter() .add(tweetsRepository, new RowPresenter()) .build();
 It is easy to couple to framework.
36. Mem Cache Only have a few composition methods. Merge and transform. Difficult coordinate more than two observables.
37. Mem Cache Poor documentation and samples.
38. RxJava
39. Mem Cache Combination of the best ideas from the Observer pattern, the Iterator pattern, and functional programming
40. Mem Cache You need to change your mind. You “observe” changes, don’t invoke it.
41. A lot of “Operators” that allow combination observables. Example: Zip
42. You decide in which thread your observable will emit the stream of data (onNext() on Subscriber). .subscribeOn(Schedulers.newThread()) You deciden in which thread Observables will execute their job. .observeOn(AndroidSchedulers.mainThread())
44. It has a steep learning curve. Take time to understand the paradigma change and learn the operators.
45. Debugging can be hell. Frodo is your friend.
46. Cold vs Hot observables Defer vs Publish
47. Karumi Recommends
48. Mem Cache Get out from UI thread ASAP
49. Mem Cache Apps are really dependent on state. Blocking threads.
50. Mem Cache Be careful with the number of threads that your are creating. A big number of threads can overkill the system.
51. Mem Cache I don’t appreciate a big impact to the memory or to garbage collector.
52. Adam Tornhill “Sometimes abstraction and encapsulation are at odds with performance — although not nearly as often as many developers believe — but it is always a good practice first to make your code right, and then make it fast.” Brian Goetz. Java Concurrency in Prac.
53. Readability is the must important thing always Observable<List<User>> usersDb = db.getUsers().subscribeOn(Schedulers.newThread()); Observable<List<User>> users = apiRest.getUsers().subscribeOn(Schedulers.newThread()); Observable<Map<String, Integer>> likeCountPerUser = apiRest.getLikes(); Observable<List<User>> obs = Observable.zip(users, likeCountPerUser, (users, likes) -> { for (User user: users) { if (likes.containsKey(user.getId())) { user.setNumLikes (likes.get(user.getId())); } } return users; }).merge(userDb); return obs;
54. Readability is the must important thing always List<User> usersDb = db.getUsers(); List<User> users = apiRest.getUsers(); Map<String, Integer> likeCountPerUser = apiRest.getLikes(); for (User user: users) { if (likes.containsKey(user.getId())) { user.setNumLikes(likes.get(user.getId())); } } List<User> usersFinal = new ArrayList<>(); usersFinal.addAll(users); usersFinal.addAll(usersDb); return usersFinal;
55. Bibliography They’re the cracks! Java Concurrency in Prac. Brian Goetz http://www.reactivemanifesto.org/ http://reactivex.io/ https://github.com/jdeferred/jdeferred https://github.com/BoltsFramework/Bolts-Android https://github.com/android10/frodo https://github.com/flipper83/trabajando-en-diferido Thanks to Pedro V Gomez, Fernando Cejas, Nuria Ruiz and karumi team for their support.
56. Find me I am very social! jorge@karumi.com @flipper83 +JorgeJBarroso Questions?