Day 9/100: onSaveInstanceState vs ViewModel vs SavedStateHandle — Pick the Right Tool

Event                        │ onSaveInstanceState │ ViewModel │ SavedStateHandle
─────────────────────────────┼─────────────────────┼───────────┼──────────────────
Screen rotation              │ ✅ survives          │ ✅ survives│ ✅ survives
App goes to background       │ ✅ survives          │ ✅ survives│ ✅ survives
Process killed (background)  │ ✅ survives          │ ❌ lost    │ ✅ survives
User navigates Back (finish) │ ❌ cleared           │ ❌ cleared │ ❌ cleared
App force-stopped by user    │ ❌ cleared           │ ❌ cleared │ ❌ cleared

override fun onSaveInstanceState(outState: Bundle) {
    super.onSaveInstanceState(outState)
    outState.putString("search_query", binding.searchInput.text.toString())
    outState.putInt("selected_tab", binding.tabLayout.selectedTabPosition)
}

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(binding.root)

    savedInstanceState?.let { bundle ->
        binding.searchInput.setText(bundle.getString("search_query"))
        binding.tabLayout.selectTab(
            binding.tabLayout.getTabAt(bundle.getInt("selected_tab"))
        )
    }
}

class SearchViewModel : ViewModel() {
    // Survives rotation — not process death
    private val _searchResults = MutableStateFlow<List<Product>>(emptyList())
    val searchResults: StateFlow<List<Product>> = _searchResults.asStateFlow()

    private val _isLoading = MutableStateFlow(false)
    val isLoading: StateFlow<Boolean> = _isLoading.asStateFlow()

    fun search(query: String) {
        viewModelScope.launch {
            _isLoading.value = true
            _searchResults.value = repository.search(query)
            _isLoading.value = false
        }
    }
}

class SearchViewModel(
    private val savedStateHandle: SavedStateHandle,
    private val repository: SearchRepository
) : ViewModel() {

    // This query survives process death
    // If the user was searching "headphones" and the process was killed,
    // they come back to a screen still searching "headphones"
    var searchQuery: String
        get() = savedStateHandle["search_query"] ?: ""
        set(value) {
            savedStateHandle["search_query"] = value
            triggerSearch(value)
        }

    // This is also available as a Flow
    val searchQueryFlow: StateFlow<String> =
        savedStateHandle.getStateFlow("search_query", "")

    val searchResults: StateFlow<List<Product>> = searchQueryFlow
        .debounce(300)
        .flatMapLatest { query ->
            if (query.isBlank()) flowOf(emptyList())
            else repository.search(query)
        }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())
}

class OrderDetailViewModel(
    savedStateHandle: SavedStateHandle,
    private val orderRepository: OrderRepository
) : ViewModel() {

    // ✅ orderId comes from navigation args, stored in SavedStateHandle
    // Small string — survives process death, trivially serializable
    private val orderId: String = savedStateHandle["order_id"]
        ?: throw IllegalStateException("order_id navigation arg required")

    // ✅ Full Order object fetched from repository using the preserved ID
    // Repository reads from Room cache first, then network if needed
    // Not stored in SavedStateHandle — too large, and the repo can reconstruct it
    val order: StateFlow<Result<Order>> = orderRepository
        .getOrder(orderId)
        .map { Result.success(it) }
        .catch { emit(Result.failure(it)) }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), Result.success(null))

    // ✅ Lightweight UI state — selected tab, expanded sections
    // Could go in ViewModel (rotation only) or SavedStateHandle (process death too)
    // Here we use SavedStateHandle since it's cheap and the UX is better
    var selectedTab: Int
        get() = savedStateHandle["selected_tab"] ?: 0
        set(value) { savedStateHandle["selected_tab"] = value }
}

<!-- This EditText saves its content automatically because it has an id -->
<EditText
    android:id="@+id/search_input"
    android:layout_width="match_parent"
    android:layout_height="wrap_content" />

<!-- This one doesn't — no id -->
<EditText
    android:layout_width="match_parent"
    android:layout_height="wrap_content" />

// remember — survives recomposition only
var searchQuery by remember { mutableStateOf("") }

// rememberSaveable — survives recomposition AND process death
// Backed by the same Bundle mechanism
var searchQuery by rememberSaveable { mutableStateOf("") }

@Composable
fun SearchScreen(
    viewModel: SearchViewModel = viewModel()
) {
    // ✅ Collect ViewModel state — survives rotation, re-fetched after process death
    val searchResults by viewModel.searchResults.collectAsStateWithLifecycle()
    val isLoading by viewModel.isLoading.collectAsStateWithLifecycle()

    // ✅ rememberSaveable for ephemeral UI state not worth putting in ViewModel
    // e.g., whether a filter panel is expanded
    var isFilterExpanded by rememberSaveable { mutableStateOf(false) }

    // ❌ Don't use remember for state the user would be frustrated to lose
    // var searchQuery by remember { mutableStateOf("") }

    // ✅ Query lives in ViewModel/SavedStateHandle — survives process death
    val searchQuery by viewModel.searchQueryFlow.collectAsStateWithLifecycle()

    SearchScreenContent(
        query = searchQuery,
        results = searchResults,
        isLoading = isLoading,
        isFilterExpanded = isFilterExpanded,
        onQueryChange = viewModel::onQueryChange,
        onFilterToggle = { isFilterExpanded = !isFilterExpanded }
    )
}

What are you preserving?

Navigation argument (ID, type, mode)?
  → SavedStateHandle (via nav args, automatic with Navigation Component)

User input that defines the screen (search query, form draft)?
  → SavedStateHandle in ViewModel

Fetched data (list of items, user profile)?
  → ViewModel StateFlow, re-fetched from repository after process death
  → Repository caches to Room for offline resilience

Ephemeral UI state (expanded sections, selected tab)?
  → ViewModel (rotation only) — acceptable UX to reset after process death
  → SavedStateHandle — if reset after process death would be jarring

Transient visual state (scroll position)?
  → View's own save state (XML id) or rememberSaveable in Compose

Nothing — should reset on every entry?
  → Don't save it. Let it be ephemeral.

class RegistrationViewModel(
    private val savedStateHandle: SavedStateHandle
) : ViewModel() {

    // Each field backed by SavedStateHandle — survives process death
    var firstName: String
        get() = savedStateHandle["first_name"] ?: ""
        set(value) { savedStateHandle["first_name"] = value }

    var lastName: String
        get() = savedStateHandle["last_name"] ?: ""
        set(value) { savedStateHandle["last_name"] = value }

    var email: String
        get() = savedStateHandle["email"] ?: ""
        set(value) { savedStateHandle["email"] = value }

    // Alternatively — expose as StateFlow for Compose
    val firstNameFlow = savedStateHandle.getStateFlow("first_name", "")
}

// ❌ Can exceed Bundle limit
savedStateHandle["search_results"] = listOf<Product>(/* 500 items */)

// ✅ Store the query, re-fetch the results
savedStateHandle["search_query"] = "headphones"
// Results re-fetched from Room cache using the query on restoration

// Nav graph:
// <argument android:name="orderId" app:argType="string" />

// In ViewModel — orderId automatically available via SavedStateHandle
val orderId: String = savedStateHandle["orderId"]!!

// In the destination that produces a result (EditFragment):
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    binding.saveButton.setOnClickListener {
        // Set result on the PREVIOUS destination's SavedStateHandle
        navController.previousBackStackEntry
            ?.savedStateHandle
            ?.set("address_updated", true)
        navController.popBackStack()
    }
}

// In the source fragment that consumes the result (ProfileFragment):
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    navController.currentBackStackEntry
        ?.savedStateHandle
        ?.getLiveData<Boolean>("address_updated")
        ?.observe(viewLifecycleOwner) { updated ->
            if (updated) viewModel.refreshProfile()
        }
}