As presented at droidcon Tel Aviv 2019 http://il.droidcon.com

1. 1
LiveData
on Steroids
Taking LiveData to the next level
Giora Shevach &
Shahar Ben Moshe

3. LiveData<>

4. 4
● Observable data holder
LiveData (vanilla)

5. 5
LiveData (vanilla)
● Observable data holder
● Lifecycle-aware
○ Auto handling of lifecycle-related stuff
○ Avoids stupid crashes
○ Avoids memory leaks
○ App doesn’t do more work than it

6. 6
LiveData (vanilla)
● Observable data holder
● Lifecycle-aware
○ Auto handling of lifecycle-related stuff
○ Avoids stupid crashes
○ Avoids memory leaks
○ App doesn’t do more work than it

7. 7

8. 8

9. class WeatherDashboardActivity : Activity() {
private lateinit viewModel: WeatherDashboardViewModel
override fun onCreate(savedInstanceState: Bundle) {
super.onCreate(savedInstanceState)
viewModel = ViewModelProviders.of(this)
.get(WeatherDashboardViewModel::java.class)
observeWeather()
}
private fun observeWeather() {
viewModel.weather.observe(this, Observer { // it: Weather
showTemperatureInBig(it.temperature)
})
}
}
class WeatherDashboardViewModel : ViewModel {
val weather: LiveData<Weather> = weatherRepo.weather
}
class WeatherRepo {
val weather = MutableLiveData<Weather>()
// code to manipulate weather
}

10. class WeatherDashboardActivity : Activity() {
private lateinit viewModel: WeatherDashboardViewModel
override fun onCreate(savedInstanceState: Bundle) {
super.onCreate(savedInstanceState)
viewModel = ViewModelProviders.of(this)
.get(WeatherDashboardViewModel::java.class)
observeWeather()
}
private fun observeWeather() {
viewModel.weather.observe(this, Observer { // it: Weather
showTemperatureInBig(it.temperature)
})
}
}
class WeatherDashboardViewModel : ViewModel {
val weather: LiveData<Weather> = weatherRepo.weather
}
class WeatherRepo {
val weather = MutableLiveData<Weather>()
// code to manipulate weather
}

11. class WeatherDashboardActivity : Activity() {
private lateinit viewModel: WeatherDashboardViewModel
override fun onCreate(savedInstanceState: Bundle) {
super.onCreate(savedInstanceState)
viewModel = ViewModelProviders.of(this)
.get(WeatherDashboardViewModel::java.class)
observeWeather()
}
private fun observeWeather() {
viewModel.weather.observe(this, Observer { // it: Weather
showTemperatureInBig(it.temperature)
})
}
}
class WeatherDashboardViewModel : ViewModel {
val weather: LiveData<Weather> = weatherRepo.weather
}
class WeatherRepo {
val weather = MutableLiveData<Weather>()
// code to manipulate weather
}

12. class WeatherDashboardActivity : Activity() {
private lateinit viewModel: WeatherDashboardViewModel
override fun onCreate(savedInstanceState: Bundle) {
super.onCreate(savedInstanceState)
viewModel = ViewModelProviders.of(this)
.get(WeatherDashboardViewModel::java.class)
observeWeather()
}
private fun observeWeather() {
viewModel.weather.observe(this, Observer { // it: Weather
showTemperatureInBig(it.temperature)
})
}
}
class WeatherDashboardViewModel : ViewModel {
val weather: LiveData<Weather> = weatherRepo.weather
}
class WeatherRepo {
val weather = MutableLiveData<Weather>()
// code to manipulate weather
}

13. class WeatherDashboardActivity : Activity() {
private lateinit viewModel: WeatherDashboardViewModel
override fun onCreate(savedInstanceState: Bundle) {
super.onCreate(savedInstanceState)
viewModel = ViewModelProviders.of(this)
.get(WeatherDashboardViewModel::java.class)
observeWeather()
}
private fun observeWeather() {
viewModel.weather.observe(this, Observer { // it: Weather
showTemperatureInBig(it.temperature)
})
}
}
class WeatherDashboardViewModel : ViewModel {
val weather: LiveData<Weather> = weatherRepo.weather
}
class WeatherRepo {
val weather = MutableLiveData<Weather>()
// code to manipulate weather
}

14. LiveData - where it falls short

15. 15
WeatherDashboardActivity
viewModel.weather.observe(...)
WeatherDashboardViewModel
val weather: LiveData<Weather> = weatherRepo.weather
WeatherRepo
val weather = MutableLiveData<Weather>()
fun fetchNewWeather() {
// do some network stuff…
weather.value = networkResponse.data
}
AppLifecycleObserver
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun onForeground() {
weatherRepo.fetchNewWeather()
}
val weatherError = MutableLiveData<Exception>()
val weatherError = weatherRepo.weatherError
viewModel.weatherError.observe(...)

16. fun observeWeatherAndOtherThingsAsWell() {
viewModel.weather.observe(this, Observer { weather -> // : Weather
viewModel.weatherError.observe(this, Observer { weatherError -> // : Exception
viewModel.weatherLoading.observe(this, Observer {weatherLoading -> // : Boolean
if (weatherError != null && weatherError.data != lastError) {
showErrorMessage()
lastError = weatherError.data
} else {
if (weatherLoading) {
showLoader()
} else {
if (weather != null) {
showTemperatureInBig(weather.temperature)
} else {
showErrorMessage()
}
}
}
})
})
})

17. Stateful.Live.Data

19. 19
StatefulLiveData
⬢ How we built it
⬢ How to use it
⬢ How it solves common scenarios in daily app operation
⬢ Integration in existing code & libraries
⬢ Super powers

20. 20
❏ Get updates upon data changes
❏ Be lifecycle-aware
❏ Support every data type
❏ Know when the data is retrieved successfully and ready to
use
❏ Know when the data is loading, and supply some partial data
❏ Know when an error occurred, and know what the error is
Requirements
StatefulLiveData

21. StatefulData
abstract class StatefulData<T> {
class Success<T>(val data: T) : StatefulData<T>()
class Error<T>(val throwable: Throwable) : StatefulData<T>()
class Loading<T>(val loadingData: Any?) : StatefulData<T>()
}
❏ Get updates upon data changes
❏ Be lifecycle-aware
❏ Support every data type
❏ Know when the data is retrieved successfully and ready to use
❏ Know when the data is loading, and supply some partial data
❏ Know when an error occurred, and know what the error is

22. StatefulData
abstract class StatefulData<T> {
class Success<T>(val data: T) : StatefulData<T>()
class Error<T>(val throwable: Throwable) : StatefulData<T>()
class Loading<T>(val loadingData: Any?) : StatefulData<T>()
}
❏ Get updates upon data changes
❏ Be lifecycle-aware
✓ Support every data type
✓ Know when the data is retrieved successfully and ready to use
✓ Know when the data is loading, and supply some partial data
✓ Know when an error occurred, and know what the error is

23. StatefulLiveData
LiveData<StatefulData<T>>
typealias StatefulLiveData<T> = LiveData<StatefulData<T>>
typealias MutableStatefulLiveData<T> = MutableLiveData<StatefulData<T>>
typealias MediatorStatefulLiveData<T> = MediatorLiveData<StatefulData<T>>

25. WeatherDashboardActivity
viewModel.weather.observe(...)
WeatherDashboardViewModel
val weather: LiveData<Weather> = weatherRepo.weather
WeatherRepo
val weather = MutableLiveData<Weather>()
fun fetchNewWeather() {
// do some network stuff…
weather.value = networkResponse.data
}
AppLifecycleObserver
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun onForeground() {
weatherRepo.fetchNewWeather()
}
val weatherError= MutableLiveData<Exception>()
val weatherError= weatherRepo.weatherError
viewModel.weatherError.observe(...)

26. WeatherDashboardActivity
viewModel.weather.observe(...)
WeatherDashboardViewModel
val weather: StatefulLiveData<Weather> =
weatherRepo.weather
WeatherRepo
val weather = MutableStatefulLiveData<Weather>()
fun fetchNewWeather() {
// do some network stuff…
weather.value = networkResponse.data
}
AppLifecycleObserver
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
fun onForeground() {
weatherRepo.fetchNewWeather()
}

27. class WeatherDashboardActivity : Activity()
private fun observeWeather() {
viewModel.weather.observe(this, Observer { //it: StatefulData<Weather>
When (it) {
is Success -> { // it.data: Weather
showTemperatureInBig(it.data.temperature)
}
is Loading -> { // it.loadingData: Any?
showLocationName(it.loadingData as? String)
showLoader()
}
is Error -> { // it.throwable: Throwable
showErrorMessage()
log(it.throwable)
}
}
})
}
}

28. class WeatherDashboardActivity : Activity()
private fun observeWeather() {
viewModel.weather.observe(this, Observer { //it: StatefulData<Weather>
When (it) {
is Success -> { // it.data: Weather
showTemperatureInBig(it.data.temperature)
}
is Loading -> { // it.loadingData: Any?
showLocationName(it.loadingData as? String)
showLoader()
}
is Error -> { // it.throwable: Throwable
showErrorMessage()
log(it.throwable)
}
}
})
}
}

29. class WeatherDashboardActivity : Activity()
private fun observeWeather() {
viewModel.weather.observe(this, Observer { //it: StatefulData<Weather>
When (it) {
is Success -> { // it.data: Weather
showTemperatureInBig(it.data.temperature)
}
is Loading -> { // it.loadingData: Any?
showLocationName(it.loadingData as? String)
showLoader()
}
is Error -> { // it.throwable: Throwable
showErrorMessage()
log(it.throwable)
}
}
})
}
}

30. class WeatherDashboardActivity : Activity()
private fun observeWeather() {
viewModel.weather.observe(this, Observer { //it: StatefulData<Weather>
When (it) {
is Success -> { // it.data: Weather
showTemperatureInBig(it.data.temperature)
}
is Loading -> { // it.loadingData: Any?
showLocationName(it.loadingData as? String)
showLoader()
}
is Error -> { // it.throwable: Throwable
showErrorMessage()
log(it.throwable)
}
}
})
}
}

31. 31
It’s
Alive!!
(Data)

32. Simple State Observation

33. class WeatherDasboardActivity : Activity() {
private fun observeWeather() {
viewModel.weather.observe(this, Observer { //it: StatefulData<Weather>
When (it) {
is Success -> showTemperatureInBig(it.data.temperature) // it.data: Weather
is Loading -> {
showLocationName(it.loadingData as? String) // it.loadingData: Any?
showLoader()
}
is Error -> {
showErrorMessage()
log(it.throwable) // it.throwable: Throwable
}
}
})
}
}

34. 34
observeSuccess
class WeatherDasboardActivity : Activity() {
private fun observeWeather() {
viewModel.weather.observeSuccess(this, Observer { //it: Weather
showTemperatureInBig(it.temperature)
})
}
}

35. 35
observeLoading, observeError
class WeatherDasboardActivity : Activity() {
private fun observeWeather() {
viewModel.weather.observeLoading(this, Observer { //it: Any?
showLocationName(it as? String)
showLoader()
})
}
}
class WeatherDasboardActivity : Activity() {
private fun observeWeather() {
viewModel.weather.observeError(this, Observer { //it: Throwable
showErrorMessage()
log(it)
})
}
}

36. Flexible Observation

37. class WeatherDasboardActivity : Activity() {
private fun observeWeather() {
viewModel.weather.observe(this, Observer { //it: StatefulData<Weather>
When (it) {
is Success -> showTemperatureInBig(it.data.temperature) // it.data: Weather
is Loading -> {
showLocationName(it.loadingData as? String) // it.loadingData: Any?
showLoader()
}
is Error -> {
showErrorMessage()
log(it.throwable) // it.throwable: Throwable
}
}
})
}
}

38. class WeatherDasboardActivity : Activity() {
private fun observeWeather() {
viewModel.weather.subscribe(this)
.onSuccess{ // it: Weather
showTemperatureInBig(it.temperature)
}
.onError{ // it: Throwable
showErrorMessage()
log(it)
}
.observe()
}
}

39. class WeatherDasboardActivity : Activity() {
private fun observeWeather() {
viewModel.weather.subscribe(this)
.onSuccess{ // it: Weather
showTemperatureInBig(it.temperature)
}
.onError{ // it: Throwable
showErrorMessage()
log(it)
}
.observe()
}
}

40. class WeatherDasboardActivity : Activity() {
private fun observeWeather() {
viewModel.weather.subscribe(this)
.onSuccess{ // it: Weather
showTemperatureInBig(it.temperature)
}
.onError{ // it: Throwable
showErrorMessage()
log(it)
}
.observe()
}
}

41. class WeatherDasboardActivity : Activity() {
private fun observeWeather() {
viewModel.weather.subscribe(this)
.onSuccess{ // it: Weather
showTemperatureInBig(it.temperature)
}
.onError{ // it: Throwable
showErrorMessage()
log(it)
}
.observe()
}
}

42. class WeatherDasboardActivity : Activity() {
private fun observeWeather() {
viewModel.weather.subscribe(this)
.onSuccess{ // it: Weather
showTemperatureInBig(it.temperature)
}
.onError{ // it: Throwable
showErrorMessage()
log(it)
}
.observe()
}
}

44. 44
Transformations.Map
class MyViewModel() : ViewModel() {
val temperature: StatefulLiveData<Temperature> = repo.weather.map { // it : Weather
It.temperature ^map
}
}

45. 45
Transformations.Map
class MyViewModel() : ViewModel() {
val temperature: StatefulLiveData<Temperature> = repo.weather.map { // it : Weather
It.temperature ^map
}
}
Transformations.SwitchMap
class MyViewModel() : ViewModel() {
val radarImage: StatefulLiveData<List<RadarImage>> =
repo.weather.switchMap { // it : Weather
repo.getRadarImages(it.latLng) // ^switchMap
}
}

46. 46
class MyViewModel() : ViewModel() {
val temperature: StatefulLiveData<Temperature> =
repo.weather.map(myCoroutineScope) { // it : Weather
It.temperature ^map
}
}
Transformations.MapWithCoroutine

47. Stateful.Live.Data.Mediators

48. 48
typealias MediatorStatefulLiveData<T> = MediatorLiveData<StatefulData<T>>
StatefulLiveDataMediator

49. 49
typealias MediatorStatefulLiveData<T> = MediatorLiveData<StatefulData<T>>
StatefulLiveDataMediator
class MyViewModel() : ViewModel() {
val fusedForecast = MediatorStatefulLiveData<Forecast>().apply {
addSource(repo.todayForecast) { // it: Forecast
// handle data
}
addSource(repo.tomorrowForecast) { // it: StatefulData<Forecast>
// handle stateful data
}
}
}

51. 51
class WeatherDashboardViewModel : ViewModel() {
private val vanillaWeather: LiveData<Weather> =
repo.weather.mapToLiveData()
}
mapToLiveData

52. 52
mapToLiveData
class WeatherDasboardViewModel : ViewModel() {
private val vanillaWeather: LiveData<Weather> = repo.weather
.mapToLiveData(errorMapFunction = { // it : Throwable
return Weather()
})
}
fun <T> StatefulLiveData<T>.mapToLiveData(
errorMapFunction: (Throwable) -> T? = { _ -> null },
loadingMapFunction: (Any?) -> T? = { _ -> null },
fallbackMapFunction: () -> T? = { null }
): LiveData<T>

53. Put

54. 54
Put
fun <T> MutableStatefulLiveData<T>.putData(data: T)
fun <T> MutableStatefulLiveData<T>.putLoading(loadingData: Any?)? = null)
fun <T> MutableStatefulLiveData<T>.putError(error: Throwable)

55. 55
Put
fun <T> MutableStatefulLiveData<T>.putData(data: T)
fun <T> MutableStatefulLiveData<T>.putLoading(loadingFunction: (() -> Any?)? = null)
fun <T> MutableStatefulLiveData<T>.putError(error: Throwable)

56. loadingData

57. 57
class WeatherDasboardViewModel : ViewModel() {
private val mutableWeather = MutableStatefulLiveData<Weather>()
private fun setWeatherLoading() {
mutableWeather.putLoading() //loadingData = null
mutableWeather.putLoading(”Please wait...”) // loadingData: String
mutableWeather.putLoading(53) // loadingData: Int - show % progress
mutableWeather.putLoading(oldWeather) // loadingData: Weather
}
}
loadingData

58. 58
class WeatherDasboardViewModel : ViewModel() {
private val mutableWeather = MutableStatefulLiveData<Weather>()
private fun setWeatherLoading() {
mutableWeather.putLoading() //loadingData = null
mutableWeather.putLoading(”Please wait...”) // loadingData: String
mutableWeather.putLoading(53) // loadingData: Int - show % progress
mutableWeather.putLoading(oldWeather) // loadingData: Weather
}
}
loadingData

59. 59
class WeatherDasboardViewModel : ViewModel() {
private val mutableWeather = MutableStatefulLiveData<Weather>()
private fun setWeatherLoading() {
mutableWeather.putLoading() //loadingData = null
mutableWeather.putLoading(”Please wait...”) // loadingData: String
mutableWeather.putLoading(53) // loadingData: Int - show % progress
mutableWeather.putLoading(oldWeather) // loadingData: Weather
}
}
loadingData

60. 60
class WeatherDasboardViewModel : ViewModel() {
private val mutableWeather = MutableStatefulLiveData<Weather>()
private fun setWeatherLoading() {
mutableWeather.putLoading() //loadingData = null
mutableWeather.putLoading(”Please wait...”) // loadingData: String
mutableWeather.putLoading(53) // loadingData: Int - show % progress
mutableWeather.putLoading(oldWeather) // loadingData: Weather
}
}
loadingData

61. 61
fun <T> LiveData<T>.observeOnce(
observer: Observer<T>,
retainForLoadingState: Boolean = true)
observeOnce

63. 63
Stateful.Live.Data.Call.Adapter
fun createClient(baseUrl: String): Retrofit {
return Retrofit
.Builder()
.baseUrl(baseUrl)
.addCallAdapterFactory(StatefulLiveDataCallAdapterFactory.create())
.build()
}

64. 64
Stateful.Live.Data.Call.Adapter
fun createClient(baseUrl: String): Retrofit {
return Retrofit
.Builder()
.baseUrl(baseUrl)
.addCallAdapterFactory(StatefulLiveDataCallAdapterFactory.create())
.build()
}

65. 65
Stateful.Live.Data.Call.Adapter
fun createClient(baseUrl: String): Retrofit {
return Retrofit
.Builder()
.baseUrl(baseUrl)
.addCallAdapterFactory(StatefulLiveDataCallAdapterFactory.create())
.build()
}
interface MyRetrofitService {
@GET("weather/current")
fun getWeather(): Call<Weather>
}

66. 66
Stateful.Live.Data.Call.Adapter
fun createClient(baseUrl: String): Retrofit {
return Retrofit
.Builder()
.baseUrl(baseUrl)
.addCallAdapterFactory(StatefulLiveDataCallAdapterFactory.create())
.build()
}
interface MyRetrofitService {
@GET("weather/current")
fun getWeather(): StatefulLiveData<Weather>
}

67. 67
class FirestoreRepo {
private val firestoreDb: FirebaseFirestore = … // init FirebaseFirestore
fun getUser(userId: String) : Task<User> {
val getUserTask = firestoreDb
.collection(“Users”)
.whereEqualTo(“userId”, userId)
return getUserTask
}
}
Task<T>.toStatefulLiveData

68. 68
class FirestoreRepo {
private val firestoreDb: FirebaseFirestore = … // init FirebaseFirestore
fun getUser(userId: String) : StatefulLiveData<User> {
val getUserTask = firestoreDb
.collection(“Users”)
.whereEqualTo(“userId”, userId)
return getUserTask.toStatefulLiveData()
}
}
Task<T>.toStatefulLiveData

69. 69
Task<T>.toStatefulLiveData
class FirestoreRepo {
private val firestoreDb: FirebaseFirestore = … // init FirebaseFirestore
fun getUser(userId: String) : StatefulLiveData<Account> {
val getUserTask = firestoreDb
.collection(“Users”)
.whereEqualTo(“userId”, userId)
return getUserTask.toStatefulLiveData { // User: task result
val userAccount: Account = … // map User -> Account
userAccount ^toStatefulLiveData
}
}
}

70. Extendibility

71. 71
class LoadingWithPercent(val percent: Int) : StatefulData<Int>()

72. 72
class LoadingWithPercent(val percent: Int) : StatefulData<Int>()
class WeatherDashboardActivity : Activity() {
private fun observeWeather() {
viewModel.weather.observe(this, Observer { //it: StatefulData<Weather>
When (it) {
is ... -> {...}
is LoadingWithPercent -> {
showProgress(it.percent) // it.percent: Int
}
}
})
}
}

73. 73
class LoadingWithPercent(val percent: Int) : StatefulData<Int>()
fun <T> MutableStatefulLiveData<T>.putLoadingWithPercent(percent: Int) {...}
fun <T> StatefulLiveData<T>.observeLoadingWithPercent(owner: LifecycleOwner,
observer: Observer<in Any?>): StatefulLiveData<T> {...}

74. 74
Event bus Callback listener Rx StatefulLiveData
Life cycle aware X X X
Low learning
curve
X
Lean X X
Data retention X X
Memory leaks
free
X X X

75. 75
Use the right tool for the job
(or make one if it doesn’t exist)

76. 76
Got get Stateful, It’s Live!
https://github.com/climacell/statefullivedata
Thank you!