Data management ¶

When using Activities or Fragments, you will usually want to store some data. For instance, the user checked some options in the previous activity, and you want to keep track of it.

It's even more needed as many scenarios lead to an Activity being destroyed, so you may have to save data to load it back, for instance, when the user rotates the screen.

This usually involves a few classes:

• ViewModel 🏠: a class to store data in a model
• Bundle 🎒: a class to store data in a model
• LiveData<T> 📩: update the model when the view changes; update the view when the model changes

A model may be temporary (a variable), or persistent (a database, a file...). A database may be local (SQLite) or remote (an API...).

We commonly use the ViewModel 🏠 class to handle data.

A ViewModel is created when the application is started, and destroyed when the application is destroyed (ViewModel#onCleared()).

When loading back an activity, you can use the view model to configure the view with the data you stored in it.

implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.5.1'

To define a basic blank model:

class EmptyViewModel : ViewModel() {
    // implement your ViewModel here
    // e.g. methods to store data/query an API...
    // 🔥 the simplest usage, stock data in variables
    var count = 0
}

The next step is to load the view model inside an activity or a fragment. The code is different for Activities and Fragments.

Activity ¶

This import is unneeded if you added the one below for fragments.

implementation "androidx.activity:activity-ktx:1.6.1"

class MainActivity : AppCompatActivity() {
    private val viewModel: EmptyViewModel by viewModels()
    
    override fun onCreate(savedInstanceState: Bundle?) {
        // ...
        // ex: init the view with count
        val count = viewModel.count
    }
}

Fragment ¶

This will import the function for use both in Fragments and Activities.

implementation "androidx.fragment:fragment-ktx:1.5.5"

class BlankFragment : Fragment() {
    private val viewModel: EmptyViewModel by viewModels()
    
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        // ex: init the view with count
        val count = viewModel.count
    }
}

ViewModel sharing ¶

Any viewModel is not shared between activities or fragments. For instance, two activities with the code for activities will create two separate viewModel instances.

For fragments, it's possible to create an activity-scoped viewModel, which is shared between all fragments of an activity:

class BlankFragment : Fragment() {
-    private val viewModel: EmptyViewModel by viewModels()
+    private val viewModel: EmptyViewModel by activityViewModels()
}

Other code samples ¶

class MainActivity : AppCompatActivity() {
    private lateinit var viewModel: BlankViewModel
    
    override fun onCreate(savedInstanceState: Bundle?) {
        // ...
        // init the view with count
        viewModel = ViewModelProvider(this)[BlankViewModel::class.java]
        val count = viewModel.count
    }   
}

class XXXViewModel(v: Integer) : ViewModel() {
    // ...
}

class XXXViewModelFactory(private val v: Integer) : ViewModelProvider.Factory {
    @Suppress("UNCHECKED_CAST")
    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        return XXXViewModel(v) as T
    }
}

- private val viewModel: XXXViewModel by viewModels()
+ private val viewModel: XXXViewModel by viewModels {
+    XXXViewModelFactory(10)
+}

A LiveData 📩 is a life-cycle aware observable variable.

Observable means we can execute some code when the variable's value changes. Life-cycle aware means it doesn't check if the variable changed when the application is not either Started or Resumed.

implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.5.1'

✅ They are used to update the view when the model changes.

A LiveData wraps a variable and adds to it its logic. For instance, LiveData<Int> wrap a value of type Int.

The value can be null, so we have to use null-safe operators. (!!, ?, ?:...).

val count : LiveData<Int> = MutableLiveData<Int>(0)
if (count.value!! == 0) {} // true

Each time value is assigned (modifying value won't trigger observers), observers will be called. In an Activity:

viewModel.count.observe(this) { newCount -> /* ... */ }
viewModel.count.observe(this) { /* it == newCount */ }

⚠️ Use viewLifecycleOwner instead of this in a Fragment.

🚀 With Data binding, you can avoid using observers to update views.

LiveData and MutableLiveData ¶

The value attribute of a LiveData<T> cannot be modified, while we can for a MutableLiveData<T>. We usually use MutableLiveData<T> internally, and only expose a LiveData<T> to other classes.

class MainViewModel : ViewModel() {
    // use a backing field
    // count is unmodifiable from the "outside"
    var _count = MutableLiveData(0)
    val count : LiveData<Int> = _count

    // only allow count to be increased
    fun increaseCount() {
        // assign value to trigger observers
        _count.value = _count.value!!.inc()
    }
}

LiveData Code Samples ¶

val myButton = ...
myButton.setOnClickListener {
    viewModel.increaseCount()
}

val countTextView = ...
viewModel.count.observe(viewLifecycleOwner) {
    // it is the newValue for "count"
    // here, we update a TextView
    countTextView.text = it.toString()
}

private val _state = MutableLiveData<LoadingState>()
val state : LiveData<LoadingState>  = _state

enum class LoadingState {
    LOADING, SUCCESS, FAILED
}

// set the state before the request
_state.value = LoadingState.LOADING
// ... An API request
// set the state according to the result
_state.value =
    if (...) LoadingState.SUCCESS
    else LoadingState.FAILED

// Ex: here we simply return "count" as a "String"
// When _count is changed, we execute the code below.
// The last line is the newValue of our LiveData<String>
val count: LiveData<String> = Transformations.map(_count) {
    it.toString()
}

- countTextView.text = it.toString()
+ countTextView.text = it

private val a = MutableLiveData(0)
private val b = MutableLiveData(0)
private val mediator = MediatorLiveData<Int>()
val count: LiveData<Int> = mediator

init {
    mediator.addSource(a) { mediator.value = it + b.value!! }
    mediator.addSource(b) { mediator.value = it + a.value!! }
}

fun increaseCount() {
    if ((1..10).random() > 5){
         a.value = a.value!! + 10
    } else {
        b.value = b.value!! + 100
    }
}

Another alternative to ViewModel is using a Bundle 🎒, but they are limited in size, so they're not convenient to use.

• Datastore
• File system
• backups (see autobackups)
• Advanced Data Binding
• Android Basics: Room

val preferences: SharedPreferences = PreferenceManager.getDefaultSharedPreferences(this)
if (preferences.getBoolean("key", false)) {}

// implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.5.1"
val myLiveData : LiveData<Int> = flow {
    while (true) {
        val data : Int = 0 /* fetch from the api some data */
        emit(data) // send
        delay(60000) // wait 60 seconds
    }
}.asLiveData()

public val tasksStateFlow = MutableStateFlow<List<Task>>(emptyList())