rememberSaveable for configuration changes in Android Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is rememberSaveable in Jetpack Compose?

rememberSaveable is a function that helps save and restore state across configuration changes like screen rotations in Android apps using Jetpack Compose.

beginner

How does rememberSaveable differ from remember?

remember keeps state only during recompositions but loses it on configuration changes. rememberSaveable saves state to a Bundle, so it survives configuration changes like screen rotations.

intermediate

Which types of data can rememberSaveable automatically save?

It automatically saves types supported by the Android Bundle, such as Int, String, Boolean, and Parcelable objects.

intermediate

What happens to the state stored with rememberSaveable when the app process is killed?

The state is lost because rememberSaveable saves state only for configuration changes, not for process death or app termination.

advanced

How can you save a custom data type with rememberSaveable?

You can provide a custom Saver to tell rememberSaveable how to save and restore your custom data type.

What is the main benefit of using rememberSaveable over remember?

A It improves app performance by caching data.

B It preserves state across configuration changes like screen rotations.

C It automatically saves data to a database.

D It prevents app crashes.

rememberSaveable preserves state across configuration changes, unlike remember which loses state on such changes.

Which of these types can rememberSaveable save automatically?

A Functions

B Open network connections

C Threads

D Int and String

rememberSaveable can automatically save simple types like Int and String because they are supported by Android Bundles.

What do you need to provide to save a custom data type with rememberSaveable?

A A custom <code>Saver</code>

B A database schema

C A network API

D Nothing, it saves all types automatically

Custom data types require a Saver to define how to save and restore them.

Does rememberSaveable keep state if the app process is killed by the system?

A Only on Android 12 and above

B Yes, always

C No, it only survives configuration changes

D Only if the app is in the foreground

rememberSaveable only preserves state during configuration changes, not if the app process is killed.

Which Jetpack Compose function would you use to save UI state that should survive screen rotations?

A rememberSaveable

B LaunchedEffect

C mutableStateOf

D remember

rememberSaveable is designed to save state across configuration changes like screen rotations.

Explain how rememberSaveable helps manage state during configuration changes in Jetpack Compose.

Think about what happens when you rotate your phone and how state can be lost or saved.

Describe how to save a custom data type using rememberSaveable.

Consider how Android saves simple types and what you need to do for your own objects.

Practice

1. What is the main purpose of rememberSaveable in Jetpack Compose?

easy

A. To save UI state across configuration changes like screen rotations

B. To permanently store data in a database

C. To create animations in the UI

D. To manage network requests efficiently

Solution

1. Step 1: Understand configuration changes

   Configuration changes like screen rotation cause the UI to be recreated, losing normal state.

2. Step 2: Role of rememberSaveable

   rememberSaveable automatically saves and restores simple UI state during these changes.

3. Final Answer:

   To save UI state across configuration changes like screen rotations -> Option A

4. Quick Check:

   rememberSaveable = saves state on config changes [OK]

Hint: RememberSaveable = remember + auto save/restore state [OK]

Common Mistakes:

• Confusing rememberSaveable with permanent storage
• Thinking it manages animations or network
• Using remember instead and losing state on rotation

2. Which of the following is the correct syntax to declare a counter state that survives configuration changes using rememberSaveable?

easy

A. var count = mutableStateOf(0)

B. val count = remember { mutableStateOf(0) }

C. var count by rememberSaveable { mutableStateOf(0) }

D. val count by rememberSaveable(0)

Solution

1. Step 1: Identify correct usage of rememberSaveable

   The correct syntax uses delegation with by and initializes with mutableStateOf inside a lambda.

2. Step 2: Check each option

   var count by rememberSaveable { mutableStateOf(0) } matches the correct pattern: var count by rememberSaveable { mutableStateOf(0) }.

3. Final Answer:

   var count by rememberSaveable { mutableStateOf(0) } -> Option C

4. Quick Check:

   rememberSaveable needs mutableStateOf inside lambda [OK]

Hint: Use var count by rememberSaveable { mutableStateOf(0) } [OK]

Common Mistakes:

• Using remember instead of rememberSaveable
• Missing delegation with 'by'
• Passing initial value directly without lambda

3. Given this code snippet, what will be the displayed count after rotating the device twice?

var count by rememberSaveable { mutableStateOf(0) }
Button(onClick = { count++ }) {
  Text("Count: $count")
}

medium

A. App crashes on rotation due to state loss

B. Count resets to 0 after each rotation

C. Count increments automatically on rotation

D. Count value is preserved across rotations

Solution

1. Step 1: Understand rememberSaveable behavior

   It saves and restores the state value across configuration changes like rotations.

2. Step 2: Analyze the code

   Count increments on button clicks and is preserved after rotations, so it does not reset.

3. Final Answer:

   Count value is preserved across rotations -> Option D

4. Quick Check:

   rememberSaveable preserves state on rotation [OK]

Hint: rememberSaveable keeps count after rotations [OK]

Common Mistakes:

• Assuming count resets after rotation
• Thinking rotation increments count
• Believing app crashes due to state loss

4. What is wrong with this code if the goal is to preserve the toggle state across configuration changes?

val isChecked = remember { mutableStateOf(false) }
Checkbox(checked = isChecked.value, onCheckedChange = { isChecked.value = it })

medium

A. The onCheckedChange lambda is missing

B. Using remember instead of rememberSaveable loses state on rotation

C. Checkbox requires a String value, not Boolean

D. MutableStateOf should not be used for checkboxes

Solution

1. Step 1: Identify state preservation method

   Using remember alone does not save state across configuration changes.

2. Step 2: Correct approach

   Replace remember with rememberSaveable to preserve toggle state on rotation.

3. Final Answer:

   Using remember instead of rememberSaveable loses state on rotation -> Option B

4. Quick Check:

   rememberSaveable needed for state preservation [OK]

Hint: Use rememberSaveable, not remember, for config change state [OK]

Common Mistakes:

• Confusing remember with rememberSaveable
• Thinking mutableStateOf is wrong for checkbox
• Missing onCheckedChange lambda

5. You want to save a user input text that should survive configuration changes and process death. Which approach correctly uses rememberSaveable with a custom saver for a complex data type?

hard

A. var userInput by rememberSaveable(stateSaver = TextFieldValue.Saver) { mutableStateOf(TextFieldValue("") ) }

B. var userInput by rememberSaveable { mutableStateOf(TextFieldValue("") ) }

C. var userInput by remember { mutableStateOf(TextFieldValue("") ) }

D. var userInput by rememberSaveable(TextFieldValue("") )

Solution

1. Step 1: Understand saving complex types

   Complex types like TextFieldValue need a custom saver to be saved/restored by rememberSaveable.

2. Step 2: Check correct syntax

   var userInput by rememberSaveable(stateSaver = TextFieldValue.Saver) { mutableStateOf(TextFieldValue("") ) } uses stateSaver = TextFieldValue.Saver with rememberSaveable and mutableStateOf, which is correct.

3. Final Answer:

   var userInput by rememberSaveable(stateSaver = TextFieldValue.Saver) { mutableStateOf(TextFieldValue("") ) } -> Option A

4. Quick Check:

   Custom saver needed for complex types with rememberSaveable [OK]

Hint: Use stateSaver parameter for complex types in rememberSaveable [OK]

Common Mistakes:

• Not providing a custom saver for complex types
• Using remember instead of rememberSaveable
• Passing initial value directly without lambda