rememberSaveable for configuration changes in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What happens to the state saved with rememberSaveable on screen rotation?

Consider a Compose UI using rememberSaveable to store a counter value. What will happen to the counter value when the device is rotated (causing a configuration change)?

A The app crashes because rememberSaveable cannot handle rotation.

B The counter value resets to its initial value after rotation.

C The counter value is preserved and restored after rotation.

D The counter value doubles automatically after rotation.

💡 Hint

Think about what rememberSaveable is designed to do with state during configuration changes.

rememberSaveable saves the state in a way that survives configuration changes like screen rotations, so the counter value is preserved.

📝 Syntax

intermediate

Which code snippet correctly uses rememberSaveable to save a String state?

Choose the correct Kotlin Compose code that uses rememberSaveable to save a String variable name.

A val name = remember { mutableStateOf("") }

B val name = rememberSaveable { mutableStateOf("") }

C val name = rememberSaveable("")

D val name = mutableStateOf(rememberSaveable("") )

💡 Hint

Remember the syntax for using rememberSaveable with mutableStateOf.

The correct syntax is val name = rememberSaveable { mutableStateOf("") }. Option B uses remember but not rememberSaveable, so state won't survive configuration changes. Options C and D are invalid syntax.

❓ lifecycle

advanced

What is the difference between remember and rememberSaveable regarding process death?

Which statement correctly describes how remember and rememberSaveable behave when the app process is killed by the system?

A Neither <code>remember</code> nor <code>rememberSaveable</code> can restore state after process death.

B <code>remember</code> and <code>rememberSaveable</code> both preserve state after process death automatically.

C <code>rememberSaveable</code> loses state on process death; <code>remember</code> restores it.

D <code>remember</code> loses state on process death; <code>rememberSaveable</code> can restore state if it is Parcelable or can be saved in Bundle.

💡 Hint

Think about what happens to in-memory state versus saved instance state on process death.

remember only keeps state in memory and loses it on process death. rememberSaveable saves state in a Bundle if the type is supported (e.g., Parcelable), so it can restore state after process death.

🔧 Debug

advanced

Why does this rememberSaveable state not restore after rotation?

Given this code snippet, why does the state not restore after device rotation?

var count by rememberSaveable { mutableStateOf(0) }

Button(onClick = { count++ }) {
  Text("Count: $count")
}

A Because the code uses delegated property <code>by</code> without importing <code>import androidx.compose.runtime.getValue</code> and <code>setValue</code>.

B Because the variable is declared as <code>var</code> with delegated property, it should be <code>val</code>.

C Because rememberSaveable requires a key parameter to save the state.

D Because <code>count</code> is a primitive Int, it cannot be saved by rememberSaveable.

💡 Hint

Check if the delegated property syntax is fully supported by imports.

Using by delegation requires importing getValue and setValue from Compose runtime. Without these imports, the code compiles but the state does not behave correctly.

🧠 Conceptual

expert

How does rememberSaveable handle custom data classes for state preservation?

You want to save a custom data class instance using rememberSaveable. Which approach will correctly preserve the state across configuration changes?

A Make the data class implement Parcelable or Serializable and use rememberSaveable normally.

B Use rememberSaveable without changes; all data classes are saved automatically.

C Convert the data class to JSON string manually and save that string with rememberSaveable.

D Use remember instead of rememberSaveable because rememberSaveable does not support custom classes.

💡 Hint

Think about what types rememberSaveable can save by default.

rememberSaveable can save types that are Parcelable or Serializable. To save a custom data class, it must implement one of these interfaces. Otherwise, you must provide a custom saver or convert it to a supported type.