Android ViewModels: Saving State across Process Death

Ahmed Rizwan — Sat, 08 Feb 2020 14:09:34 +0000

A misconception among some android developers is that the purpose of using ViewModels is state persistence — it’s actually partly true — they do help in saving state across configuration change (e.g. device rotation) but not process death. So if Android kills your app (let’s say because of low memory), then your app state is lost.

So depending on whether you want to persist your state across process death or not — you can either use onSaveInstanceState in your Fragments/Activities or the new SavedStateHandle in your ViewModels.

Ok so why SavedStateHandle and why save/handle states in ViewModels?

Well if you handle your state (for process death) in Activities or Fragments — that’ll add extra verbosity and will cause tight coupling between state-handling & activity/fragment code. Handling your state via ViewModels solves this issue.

Using SavedStateHandle

Add lifecycle-viewmodel-savedstate dependency

dependencies {
  def lifecycle_version = "2.2.0" // currently the latest version
  // Saved state module for ViewModel
  implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"
}

Add SavedStateHandle property in your ViewModel

class MainViewModel(val state: SavedStateHandle) : ViewModel() {

}

Initialize your ViewModel using SavedStateViewModelFactory

class MainFragment : Fragment() {

   private val viewModel: MainViewModel by viewModels {
      SavedStateViewModelFactory(application, activity)
   }

Save and restore state

The SavedStateHandle has methods for setting/getting values.

get(String key)
contains(String key)
remove(String key)
set(String key, T value)
keys()

You can save/restore primitives, bundles and parcelables.
Saving is as easy as:

// In your viewmodel
fun saveName(name: String) {
    state.set("Name", name)
}
// In your fragment
viewModel.saveName("Ahmed Rizwan")

And restoring:

// In your viewmodel
fun getName(): String? {
    state.get<String>("Name")
}
// In your fragment 
val name = viewModel.getName()

Restore state as a LiveData

If you want to restore your data as LiveData, theres a getter for that as well.

// In your viewmodel 
val nameLiveData = state.getLiveData<String>("Name")
// In your activity/fragment
viewModel.nameLiveData.observe(this) { name ->
   // handle changes
}

And that’s it — make sure to handle all your states!
Happy coding!

Quick Recipe for creating DSLs in Kotlin

Ahmed Rizwan — Thu, 30 Jan 2020 21:10:45 +0000

A pretty cool feature in Kotlin is the ability to construct custom DSLs. And you need just four things in order to write them.

Infix Notations
Extension Methods
Lambdas
Lambda with Receiver

Let’s go through these one by one.

Infix Notation

Remove brackets & dots!

class Car {
   fun drive(miles: Int) {
      ...
   }
}
val car = Car()
car.drive(10) // normal stuff

Just add infix notation before method declaration for it to work

class Car {
   infix fun drive(miles: Int) {
      ...
   }
}
val car = Car()
car drive 10 // no brackets! no dots!

Extension Methods

Add new functions to any class without having to inherit!

val name = "Ahmed Riz"
name.shout() // won't compile as shout() is not part of String class

In order to make it a part of String class (without inheriting), create shout method prefixed with “String.”

fun String.shout() {
   println("$this !") // this refers to the value of string itself
}
val name = "Ahmed Riz"
name.shout()  // works! and prints out: Ahmed Riz !

Extension methods are project-scoped — you can access them anywhere inside the project.

Lambdas

Pass anonymous function literals (to higher order functions)!

// a higher order function
fun process(value: Int, operation: (Int) -> Unit) {
    operation(value)
}
// when calling, we can pass in a lambda expression
process(10, { value -> println(value) })
// and because it's the last param, we can extract it out
// just to clean things up even further 
process(10) { value -> println(value) }

Lambda with Receiver

Pass anonymous function literals (to higher order functions), but with a receiver type!

// slight change to the previous higher order function
// now instead of operation: (Int) -> Unit
// we'll do operation: Int.() -> Unit
// This makes Int the receiver type
fun process(value: Int, operation: Int.() -> Unit) {
    value.operation()
}
// usage now becomes
process(10) { println(this) } // prints out: 10

Combining These!

Let’s now create a DSL of our own. Just to demonstrate:

val myProfile = "Ahmed Rizwan" profile {
    age = 90
    phone = "123 456 789"      
}

Code in order to make it a valid DSL is as simple as this

class Profile(
    val name: String,
    var age: Int? = null,
    var phone: String? = null
)

infix fun String.profile(create: Profile.() -> Unit): Profile {
    val profile = Profile(this)
    profile.create()
    return profile
}

And that’s it!

Although the DSL above might not be a very useful one in real world — but hopefully it gives you an idea of how we can utilize these different Kotlin features to create some custom DSLs of our own.

Happy coding!

DEV Community: Ahmed Rizwan