As presented in droidcon Tel Aviv 2018: http://il.droidcon.com

2. @orEssel
Ahalan

3. Android architecture AND architecture components
Mvvm
Building Mvvm with AAC
Saving UI state

4. Chaos

5. Mvvm
Part 1
• Design pattern
• Separation of concerns
• Components
• Communication
• Multiple definitions

6. Model - View - ViewModel
Holds Ui data, and exposes it via event / data streams (RX)
Abstracts the data source
Mvvm

7. Mvvm
Model - View - ViewModel
observes data from the viewModel
Display data
Delegates user actions to the viewModel
Dumb - No logic allowed!

8. Mvvm
Model - View - ViewModel
Holds ready to consume data, and exposes it to the consumer
Does not care who consumes its data.
Get user actions from view, and applies domain logic

9. View ViewModel Model
•ViewModel does not know the view/consumer of the data
•It encourages event driven/reactive programming
•View notify the viewModel about events
•Many to one relationship

10. •ViewModel does not know the view/consumer of the data
•It encourages event driven/reactive programming
•View notify the viewModel about events
•Many to one relationship
View ViewModel Model

11. •ViewModel does not know the view/consumer of the data
•It encourages event driven/reactive programming
•View notifies the viewModel about events
•Many to one relationship
View ViewModel Model

12. •ViewModel does not know the view/consumer of the data
•It encourages event driven/reactive programming
•View notify the viewModel about events
•Many to one relationship
View ViewModel Model

13. • Separation of concerns
• Clear and concise
• Communication
• Multiple definitions
This is the MVVM pattern

14. Android Architecture
Components
A collection of libraries that help you design robust,
testable, and maintainable apps
Part 2

15. • LifeCycle
• Live Data
• ViewModel
• Room
• Paging Library
• Navigation
• Work Manager
• Data binding

16. Recommended app architecture

17. Motivation

18. Problems
•Memory constraints
•Referring destroyed ui - memory leaks
•App moves from foreground - incoming phone call
•Configuration changes - rotation
Android designed to multitask
Let’s address those problems with AAC

19. lifeCycle awareness
LifeCycle-aware components perform actions in response to a
change in the lifecycle status of another component

21. LifeCycle
Holds the information about the lifecycle state of a component and
allows other objects to observe this state
We could approach this set of EVENTS and STATES as a
graph data structure.

22. LifeCycle
Event
ON_CREATE
ON_START
ON_PAUSE
ON_RESUME
ON_STOP
ON_DESTROY
ON_ANY
State
INITIALISEZED
CREATED
STARTED
RESUMED
DESTROYED

23. getLifecycle() : Lifecycle
AppCompatActivity
Fragment
ProcessLifeCycleOwner
LifeCycleService
LifeCycleOwner

37. ProcessLifecycleOwner
”Composite of all of your activities“
OnCreate - will be triggered only once.
OnDestroy will not be triggered.

38. class MyAmazingObserver : LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun startDoSomething() {
//bla bla
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
fun stopDoSomething() {
//bla bla
}
}
LifeCycleObserver

39. class MyAmazingObserver : LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun startDoSomething() {
//bla bla
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
fun stopDoSomething() {
//bla bla
}
}
lifecycle.addObserver(MyAmazingObserver())
LifeCycleObserver

40. class MyAmazingObserver : LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun startDoSomething() {
lifeCycle.currentState.isAtLeast(Resumed)
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
fun stopDoSomething() {
//bla bla
}
}
lifecycle.addObserver(MyAmazingObserver())
LifeCycleObserver

41. LiveData
liveData, is a data holder class, which is lifeCycle aware.
It holds values, and allow them to be observed.
Emit events only if the observer is active!

42. Observer of LiveData is ACTIVE, if its Lifecycle.State is STARTED/
RESUMED. Otherwise, its considered as INACTIVE
val liveData : LiveData<String> = …
liveData.observe(this, Observer {
//bla bla
})
LiveData is LifeCycleAware
If observer will be destroyed - it will be removed
When LifeCycleOwner will return to ACTIVE state - it will be updated

43. MutableLiveData - update liveData objects
class MainViewModel : ViewModel() {
private val username = MutableLiveData<String>()
val userName: LiveData<String> get() = _username
fun updateUserNameMainThread() {
username.value = "Or Main Thread" // kotlin's setValue()
}
fun updateUserNameBackgroundThread() {
username.postValue("Or Background Thread!")
}
}
LiveData is immutable.

44. MediatorLiveData
Combining multiple LiveDataSources
private val networkErrors: LiveData<String> = ...
private val userUpdates: LiveData<User> = ...
val displayMessage = MediatorLiveData<String>()
displayMessage.addSource(userUpdates) { user ->
displayMessage.postValue("User ${user.name} added")
}
displayMessage.addSource(networkErrors) { errorMessage ->
displayMessage.postValue("Error $errorMessage")
}

45. Transformations.Map
Maybe we want to apply some FUNCTION on each emission.
val userLiveData: LiveData<User> = UserLiveData()
val userName: LiveData<String> =
Transformations.map(userLiveData) {
user -> "${user.name} ${user.lastName}"
}

46. Transformations.Map
Maybe we want to apply some FUNCTION on each emission.
This function, would be calculated on UI thread, in a lazy way
val userLiveData: LiveData<User> = UserLiveData()
val userName: LiveData<String> =
Transformations.map(userLiveData) {
user -> "${user.name} ${user.lastName}"
}

47. LiveData
• Ensures your UI matches your data state
• No memory leaks
• No crashes due to stopped activities
• No more manual lifeCycle handling
• Always up to date data
• Proper configuration changes

48. LifeCycle Aware - super power!
Survive configuration changes - super power!
Store and manage UI related data
Android’s ViewModel

49. viewModel
View
(activity/fragment)
Ui data
LiveData

50. viewModel
View
(activity/fragment)
Ui data
LiveData

51. viewModel
View
(activity/fragment)
new view
(activity/fragment)
Ui data
LiveData

53. We solved most of our problems - except for….

54. Saving Ui state
Part 3 - hold tight, it’s short!

55. Process death
• Empty processes
• Background processes
• Service processes
• Visible processes
• Foreground processes

56. onSavedInstanceState
• Smallest amount of data needed to restore ui state

57. onSavedInstanceState
• Smallest amount of data needed to restore ui state
• Search term for list of objects, such as conversations

58. • swipe away from multitask view
• Navigate back
• Explicit call to finish()
More death options
The user will not expect the ui to restore it’s state after they
have occurred.

59. Mvvm using Android architecture components
• Survive configuration changes
• LifeCycle aware
• Separation of concerns
• Reactive

60. Questions?
Thank you very much for listening!

61. @orEssel

62. Appendix
Guide to app architecture - https://developer.android.com/jetpack/docs/guide
Lecture by Lyla Fujiwara - https://www.youtube.com/watch?v=BofWWZE1wts
Lecture by Florina Muntenescu - https://www.youtube.com/watch?v=U6Lgym1XEBI
Android JetPack - https://developer.android.com/jetpack/
Architecture components - https://developer.android.com/topic/libraries/architecture/
Mvvm on Android - https://medium.com/upday-devs/android-architecture-patterns-part-3-model-view-viewmodel-e7eeee76b73b
Reactive architecture - https://medium.com/insiden26/reactive-clean-architecture-with-android-architecture-
components-685a6682e0ca