Jetpack Compose State Management: Patterns That Scale from Day One

// Local UI State - stays in the composable
@Composable
fun ExpandableCard() {
    var isExpanded by remember { mutableStateOf(false) }
    
    Card(
        onClick = { isExpanded = !isExpanded }
    ) {
        Text(if (isExpanded) "Expanded content" else "Collapsed")
    }
}

class UserProfileState(
    val repository: UserRepository
) {
    var name by mutableStateOf("")
    var email by mutableStateOf("")
    var isLoading by mutableStateOf(false)
        private set
    
    suspend fun loadUser(userId: String) {
        isLoading = true
        try {
            val user = repository.getUser(userId)
            name = user.name
            email = user.email
        } finally {
            isLoading = false
        }
    }
}

@Composable
fun UserProfileScreen() {
    val state = remember { UserProfileState(UserRepository()) }
    
    if (state.isLoading) {
        CircularProgressIndicator()
    } else {
        Text("Name: ${state.name}")
        Text("Email: ${state.email}")
    }
}

@HiltViewModel
class ProfileViewModel @Inject constructor(
    private val repository: UserRepository
) : ViewModel() {
    
    private val _uiState = MutableStateFlow(ProfileUiState())
    val uiState: StateFlow<ProfileUiState> = _uiState.asStateFlow()
    
    data class ProfileUiState(
        val user: User? = null,
        val isLoading: Boolean = false,
        val error: String? = null
    )
    
    fun loadProfile(userId: String) {
        viewModelScope.launch {
            _uiState.update { it.copy(isLoading = true, error = null) }
            try {
                val user = repository.getUser(userId)
                _uiState.update { it.copy(user = user, isLoading = false) }
            } catch (e: Exception) {
                _uiState.update { it.copy(error = e.message, isLoading = false) }
            }
        }
    }
}

@Composable
fun ProfileScreen(
    viewModel: ProfileViewModel = hiltViewModel()
) {
    val uiState by viewModel.uiState.collectAsState()
    
    ProfileContent(uiState)
}

@Composable
private fun ProfileContent(state: ProfileUiState) {
    when {
        state.isLoading -> CircularProgressIndicator()
        state.error != null -> Text("Error: ${state.error}")
        state.user != null -> Text(state.user.name)
    }
}

class ShoppingCartState(
    private val cartRepository: CartRepository,
    private val analytics: Analytics
) : ViewModel() {
    
    private val _cartItems = MutableStateFlow<List<CartItem>>(emptyList())
    private val _checkoutProgress = MutableStateFlow<CheckoutProgress>(CheckoutProgress.Idle)
    
    val cartItems: StateFlow<List<CartItem>> = _cartItems.asStateFlow()
    val checkoutProgress: StateFlow<CheckoutProgress> = _checkoutProgress.asStateFlow()
    
    val totalAmount by cartItems.map { items ->
        items.sumOf { it.price * it.quantity }
    }.collectAsStateInViewModel()
    
    init {
        loadCart()
    }
    
    private fun loadCart() {
        viewModelScope.launch {
            cartRepository.getCartItems().collect(_cartItems)
        }
    }
    
    fun addToCart(item: CartItem) {
        viewModelScope.launch {
            cartRepository.addItem(item)
            analytics.logEvent("item_added", mapOf("item_id" to item.id))
        }
    }
    
    fun checkout() {
        viewModelScope.launch {
            _checkoutProgress.value = CheckoutProgress.Processing
            try {
                cartRepository.checkout()
                _checkoutProgress.value = CheckoutProgress.Success
            } catch (e: Exception) {
                _checkoutProgress.value = CheckoutProgress.Error(e.message ?: "Unknown error")
            }
        }
    }
}

@Composable
fun NotificationEffect(
    scope: CoroutineScope = rememberCoroutineScope(),
    navigateToList: () -> Unit
) {
    val context = LocalContext.current
    
    LaunchedEffect(key1 = Unit) {
        // Runs once when entering composition
        doSomethingImportant()
    }
    
    DisposableEffect(key1 = "analytics") {
        val job = scope.launch {
            analytics.logScreenView("ProfileScreen")
        }
        
        onDispose {
            job.cancel()
        }
    }
    
    // Navigation effect based on state
    val uiState by viewModel.uiState.collectAsState()
    LaunchedEffect(uiState.isSuccess) {
        if (uiState.isSuccess) {
            navigateToList()
        }
    }
}

@HiltViewModel
class EventViewModel @Inject constructor() : ViewModel() {
    private val _events = MutableLiveData<Event<Unit>>()
    val events: LiveData<Event<Unit>> = _events
    
    fun navigateToSettings() {
        _events.value = Event(Unit)
    }
}

// In your activity or fragment
viewModel.events.observe(this) { event ->
    event.getContentIfNotHandled()?.let {
        navigateToSettings()
    }
}

@HiltViewModel
class SettingsViewModel @Inject constructor(
    private val dataStore: DataStore<Preferences>
) : ViewModel() {
    
    private object PreferencesKeys {
        val THEME_MODE = preferencesKey<String>("theme_mode")
        val ONBOARDING_COMPLETE = preferencesKey<Boolean>("onboarding_complete")
    }
    
    val themeMode = dataStore.data
        .map { preferences ->
            preferences[PreferencesKeys.THEME_MODE] ?: "light"
        }
        .onEach { mode ->
            // Apply theme changes
            updateTheme(mode)
        }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), "light")
    
    suspend fun updateTheme(mode: String) {
        dataStore.edit { preferences ->
            preferences[PreferencesKeys.THEME_MODE] = mode
        }
    }
}