Downloaded 134 times
Uploaded byTimo Tuominen
RxJava Architectures on Android - Android LiveCode Berlin
Presentation slides from 19th of May 2014. Functional Reactive Programming is about moving away from traditional state management with variables and using streams of data instead. The streams can be composed and distilled in any way imaginable, allowing for a truly dynamic system. However, despite the inherent beauty of the approach, it is not a bed of roses but requires an update to the entire way of seeing software as a system.
RxJava Architectures on Android - Android LiveCode Berlin
- 1. Putting the logicwhere it should be Rx Architectures in Android #LiveCode @tehmou @futurice @BeMyAppGermany @co_up
- 2. This is nota product on sale But a new way of seeing software 05/20/14
- 3. Classical Scenario: loading aweb page » 1. User writes the url in the address bar » 2. Browser sends a request and shows a loading bar » 3. ??? » 4. Profit
- 4. Imperative Way A =0 B = A + 1 A = 2 - Place the value of 0 into variable A - Read the value of A, calculate A + 1 and place it into B - Place the value 2 into A Result: B remains untouched
- 5. Modern Scenario: Android App »User navigates within the app » Friends list is refreshed in the background » Message delivery fails (for a message sent 20 seconds ago in another screen) » Application is suddenly suspended » FarmVille request arrives and is shown as an in-app notification
- 6. Result: » Any partof any view may be updated at any time » The app is no longer a simple command line script but a complex system of multiple input and entry points
- 7. So we needjust more callbacks.. or? 7Futurice
- 8.
- 9. Observable 05/20/14 // Implemented elsewhere Observable<String>observable; Observer<String> observer = new Observer<String>() { public void onCompleted() { } public void onError(Throwable e) { } public void onNext(String s) { // Handle new value } }; observable.subscribe(observer);
- 10. Observer pattern 05/20/14 observable.onNext(“Hello World!”); observable.onComplete(); Thissends a new value to every observer that is subscribed. onNext is in FRP terms the same as setting the value of a variable.
- 11. So it’s justa pub/sub? That’s it? 05/20/14 Observable Observer
- 12. Well, kind of. Network Observable Diskstore parse cache get additional information Network again View logic UI
- 13. Network Observable Disk store parse cache getadditional information Network again View logic UIIt’s a typed data flow string Book POJO Author POJO View Model property … of pure logic
- 14. Network Observable Disk store parse cache getadditional information Network again View logic UI .. the entry points of which we know exactly. Content Provider Network
- 15. Adding new features Network Observable Disk store parsecache get additional information Network again View logic UI
- 16. Plugging non-rx thingsinto the system 1705/20/14Futurice FutuVille API Websocket Observable wrapper observable emitted onNext
- 17. Adding new features Network Observable Disk store parsecache get additional information Network again View logic UI UI state handler FutuVille
- 18. Values/events can go intothe system only from the designated entry points. that’s a period
- 19. Variable vs. Observable •Observable fills the role of a variable in FRP systems • The subscriber (observer) is expected to react consistently every time a new value is set • The new value is used to do whatever changes necessary (UI state, storage) and it is then discarded • Saving the incoming values is usually not necessary and it can be dangerous – holding state leads to bugs
- 20. History of Rx »Developed by Microsoft as Reactive Extensions » “...is a library to compose asynchronous and event-based programs using observable collections and LINQ-style query operators.” » Has been ported on most platforms and languages (except PHP) 2105/20/14 Futurice
- 21. Rx is.. » Alsoknown as Functional Reactive Programming » A way of composing (pure) functions into processing chains » A way to avoid callback hell » A very fancy event publish / listen mechanism
- 22. Characteristics of RxApps » Basic building blocks of a program become observables – not variables » Favoring push over pull (reacting to change instead of polling it) » Observables do not hold state that can be pulled, but they instead emit values whenever something changes » You can declare “pipes” or “flows” within the app that have defined entry points for data process it in a deterministic way
- 23. What is Rxgood for? » Applications nowadays are increasingly asynchronous and imperative programming is not enough for app logic » Data can come into the application from many points » … or to not come » Reactive chains make sure the correct action happens each time new data arrives » The entry points for unexpected data are clearly defined » Processing of asynchronous streams, such as throttling and composing
- 24. Goals of systemdesign » Pass immutable objects through the system » Combine elaborate data reliably » Keep all data dependencies up-to-date » Permanent subscriptions as event buses » View models for increased testability
- 25. So in whichparts of the app should we use RxJava? 26Futurice
- 26.
- 27. Complete Rx Skeleton Networklayer Content Provider Websocket Data processing DataLayer Fragment ViewModel View UI State Handler create and destroy manage events / data that require showing dialogs etc. One-off subscriptions, essentially async calls
- 28. Data Layer » Givesthe last cached value to new subscribers » Uses the network client to fetch data » Offers open subscriptions for receiving a new value whenever a data entry changes (usually identified by an Uri string) » Keeps track of all needy observers » Can refresh all data in the background
- 29. View Models » Containsall logic necessary for processing “backend data” into rendereable values » Upon subscription the latest value is immediate emitted and after that refreshed as necessary » Bindings (subscriptions) are done with weak references » Subscribe to the appropriate data sources in Data Store » Unsubscribes from everything whenever the owner is destroyed
- 30. Views » Plain layoutsand drawing code » No further processing of values received from view models
- 31. The Problems inAndroid » RxJava subscriptions create strong references – memory leaks if not unsubscribed » Unsubscribing at the right time is hard especially with nested view models » No established view model / binding structure » Rx in general forces one to think more and closes many shortcuts » Bridging the gap between native components and view models can sometimes be challenging since the views hold complex state
- 32. Why You Shoulddo It? » Cleaner code » Makes you understand where bugs come from » It feels right
- 33. Resources » Github sampleproject: https://github.com/tehmou/rx-android- architecture » My blog post: http://blog.futurice.com/top-7-tips-for-rxjava-on-android » Official RxJavaWiki: https://github.com/Netflix/RxJava/wiki » A good intro to programming RxJava on Android:http://mttkay.github.io/blog/2013/08/25/functional-reactive- programming-on-android-with-rxjava/ » Original Rx: http://msdn.microsoft.com/en-gb/data/gg577609.aspx
- 34.
- 35.
- 36.
- 37. We believe thatour values – trust, caring, transparency and continuous improvement – are the key to our happiness cycle that includes happy customers, happy people and happy end- users! We have two GPTW Institute’s Best Workplace victories in a row on European level. Futurice is the first company to ever achieve this. This enables us to recruit the best talent in the market. Futurice is the best place to work in whole Europe
- 38. » Small, efficientteams of passionate and dedicated people » Modern ways of doing, modern technologies » Short lead times, Lean mindset » Design and technology under the same roof, zero hand-overs! » Consumer grade user experience also for How we do things
- 39.