RxJava - Be Creative with Reactive

"RxJava - Be Creative with Reactive", talk delivered in DevFest Ahmedabad 2016
http://devfest.gdgahmedabad.com/

RxJava is very powerful tool which helps Android code to understand and maintain very easily. Using RxJava, application can be created with lesser bug. With RxJava many complex tasks can be accomplished easily and without errors. As RxJava is new for Android developer, they might have questions like Why? How? When? In this talk, audience will have very useful RxJava information with example of implementing in Application.

Transcript

2. Background Why do you need Asynchronous work? What is state of Async in Android?
3. Tools for Async work • AsyncTask • Future • Event Bus • Observable
4. Ways to Evaluate • When they run? • How they run? • What they impact
5. AsyncTask • Must be Explicitly started • Work can not be modified or composed • Data is output via side effects Love it? Hate it?
6. Example private class SomeTask extends AsyncTask < ParamType, ProgressType, ResultType > { protected ResultType doInBackground(ParamType...params) { /**Some code*/ } protected void onPostExecute(ResultType result) { /**Some code*/ } } new SomeTask().execute(params);
8. Asynchronous Ideals • Explicit Execution • Easy Thread management • Easily Transformation • As few side effect as possible
9. Benefits • Create async tasks without needing to execute them immediately Explicit Execution
10. Benefits • Easy assign code to proper thread • Clearly understand which thread code is running on (readability) Easy Thread Management
11. Benefits • Async tasks are often interdependent • Direct chaining means less room for error Easy Transformation
12. Benefits • Code is easy to trace, and easy to reason about Minimize side effects
14. Rx : Reactive Extension
15. RX • is Explicitly started • makes it easy to determine which thread work is performed on • is incredibly easy to transform and combine • has a lesser degree of side effects than many alternatives
18. RX = Observable + LINQ + SCHEDULERS
19. RX = Observable + LINQ + SCHEDULERS represent asynchronous data streams
20. RX = Observable + LINQ + SCHEDULERS query & combine asynchronous data streams with operators
21. RX = Observable + LINQ + SCHEDULERS manage concurrency
22. Observables • Streams of data • Pull based • Create, store, pass around • Abstract away threading, synchronization, concurrency, etc
23. Observables Observable.just("Hello GDGAhmedabad!"); 1 . Put data in 2 . Get data out
24. Observables Stream Stream Stream 1 . Put data in 2 . Get data out
25. Observables 1. Give me the next piece of data! 2. Is there any more data left to process? 3. Did any errors happen that I should know about? What do we need?
26. Observables 1. Give me the next piece of data! = onNext() 2. Is there any more data left to process? 3. Did any errors happen that I should know about? What do we need?
27. Observables 1. Give me the next piece of data! = onNext() 2. Is there any more data left to process? = onComplate() 3. Did any errors happen that I should know about? What do we need?
28. Observables 1. Give me the next piece of data! = onNext() 2. Is there any more data left to process? = onComplate() 3. Did any errors happen that I should know about? = onError() What do we need?
30. Quiz Time What does this stream look like? s.onNext(2); s.onNext(3); s.onComplete();
31. Quiz Time s.onNext(2); s.onNext(3); s.onComplete(); What does this stream look like?  2  3  X
32. Quiz Time What does this stream look like? s.onNext(“Hello”); s.onNext(“GDG”); s.onNext(“Ahmedabad”); s.onComplete();
33. Quiz Time What does this stream look like?  Hello  GDG Ahmedabad  X s.onNext(“Hello”); s.onNext(“GDG”); s.onNext(“Ahmedabad”); s.onComplete();
34. Remember LINQ?
35. Operators • Combining data • Filtering/reducing data • Transforming data
36. Observable.just(1, 2, 3, 4, 5, 6) .map(new Func1<Integer, Integer>() { @Override public Integer call(Integer value) { return value + 1; } }); Operators
37. Retrolambda Observable.just(1,2,3,4,5,6) .map(value -> value + 1 );
38. Operators Observable.just(1, 2, 3, 4, 5, 6) .filter(new Func1<Integer, Boolean>() { @Override public Boolean call(Integer value) { return value % 2 == 1; } });
39. Retrolambda Observable.just(1,2,3,4,5,6) .filter(num -> num % 2 == 0);
41. Lastly, Schedulers
42. Start Listening Without Subscribe, nothing happen
43. Subscribe Basics • Subscribers can take different numbers of functions • Best practice: Always pass onError() • Use subscribeOn() and observeOn() to assign to thread
44. Observable<Integer> observable = Observable.just(1,2,3,4,5); Subscription subscriber = observable.subscribe(new Subscriber<Integer>() { @Override public void onCompleted() { } @Override public void onError(Throwable e) {} @Override public void onNext(Integer integer) { Log.d("GDG","onNext : " + integer); } });
45. Observable.just(1,2,3,4,5,6) .subscribe(next -> { Log.d("GDG","Element : " + next); }); //Output Element : 1 Element : 2 Element : 3… Subscribe Basics
46. Subscribe Basics Observable.just(“GDG",“Ahmedabad“,”DevFest16”) .subscribe(next -> { Log.d("Home",“Element : " + next); });
47. Output Element : GDG Element : Ahmedabad Element : DevFest16
48. Subscribe Basics Observable.just(1,2,3,4) .map( num -> num + 2 ) .subscribe(next -> { Log.d("GDG","Element : " + next); });
49. Output Element : 3 Element : 4 Element : 5 Element : 6
50. Subscribe Basics • .subscribe returns a Subscription • Unsurprisingly, you can unsubscribe any time
51. Subscribe Basics Subscription subscription = Observable.just(1) .subscribe(next -> { Log.d("Home","Element : " + next); }); subscription.unsubscribe();
52. What about Threads? • subscribeOn • observeOn
54. subscribeOn Observable.just(1,2,3) .subscribe(next -> Log.d("Home", "Element : "+ next + " Thread : " + Thread.currentThread().getName())); Element : 1 on thread : main Element : 2 on thread : main Element : 3 on thread : main
55. subscribeOn Observable.just(1,2,3) .subscribeOn(Schedulers.io()) .subscribe(next -> Log.d(“GDG", "Element : " + next + " on thread : " + Thread.currentThread().getName())); Element : 1 on thread : RxIoScheduler-2 Element : 2 on thread : RxIoScheduler-2 Element : 3 on thread : RxIoScheduler-2
56. subscribeOn Observable<Integer> source = Observable.range(1,3); source.map(i -> i * 100) .doOnNext(i -> print("Emitting " + I + " on thread " + Thread.currentThread().getName())) .observeOn(Schedulers.computation()) .map(i -> i * 10) .subscribe(i -> print("Received " + i + " on thread " + Thread.currentThread().getName()));
57. subscribeOn - output Emitting 100 on thread main Emitting 200 on thread main Emitting 300 on thread main Received 1000 on thread RxComputationScheduler-3 Received 2000 on thread RxComputationScheduler-3 Received 3000 on thread RxComputationScheduler-3
58. Love it! Question?
59. References • https://realm.io/news/intro-to-rxjava • https://twitter.com/RunChristinaRun • https://github.com/ReactiveX/RxJava • https://github.com/evant/gradle-retrolambda • https://www.captechconsulting.com/blogs/getting-started-with-rxjava-and- android
60. Technology Team Lead Chintan Rathod Syx Automations Pvt. Ltd Event Organizer GDG Ahmedabad Follow +chintanrathod16 @chintanrathod16 Blog www.chintanrathod.com