LiveData vs StateFlow/SharedFlow

Copy code// LiveData in ViewModel
class UserViewModel : ViewModel() {
    private val _user = MutableLiveData<User>()
    val user: LiveData<User> = _user

    private val _isLoading = MutableLiveData<Boolean>(false)
    val isLoading: LiveData<Boolean> = _isLoading

    fun loadUser(id: String) {
        _isLoading.value = true
        viewModelScope.launch {
            val result = userRepository.getUser(id)
            _user.value = result.getOrNull()
            _isLoading.value = false
        }
    }
}

// Activity/Fragment observes
viewModel.user.observe(viewLifecycleOwner) { user ->
    binding.tvName.text = user.name
}

Copy codeclass UserViewModel : ViewModel() {

    private val _uiState = MutableStateFlow(UserUiState())
    val uiState: StateFlow<UserUiState> = _uiState.asStateFlow()

    fun loadUser(id: String) {
        viewModelScope.launch {
            _uiState.update { it.copy(isLoading = true) }
            userRepository.getUser(id)
                .onSuccess { user ->
                    _uiState.update { it.copy(isLoading = false, user = user) }
                }
                .onFailure { error ->
                    _uiState.update { it.copy(isLoading = false, error = error.message) }
                }
        }
    }
}

Copy code// This will NOT emit a second time — same value
_uiState.value = UserUiState(isLoading = true) // emits
_uiState.value = UserUiState(isLoading = true) // NOT emitted — equal!

// This WILL always emit — mutable list reference changes
_listState.value = mutableListOf("A", "B")
_listState.value = mutableListOf("A", "B") // emits — different reference

Copy code// WRONG — continues collecting when app is in background
lifecycleScope.launch {
    viewModel.uiState.collect { render(it) }
}

// CORRECT — stops when STARTED, resumes when STARTED again
viewLifecycleOwner.lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.uiState.collect { render(it) }
    }
}

Copy codeclass EventViewModel : ViewModel() {

    // replay = 0: no replay for late collectors (good for events)
    // extraBufferCapacity = 1: don't drop events if collector is slow
    private val _events = MutableSharedFlow<UiEvent>(
        replay = 0,
        extraBufferCapacity = 1,
        onBufferOverflow = BufferOverflow.DROP_OLDEST
    )
    val events: SharedFlow<UiEvent> = _events.asSharedFlow()

    fun onLoginSuccess() {
        viewModelScope.launch {
            _events.emit(UiEvent.NavigateToHome)
        }
    }
}

sealed interface UiEvent {
    object NavigateToHome : UiEvent
    data class ShowError(val message: String) : UiEvent
}

Copy code// Channel approach (simpler, recommended for single consumer)
private val _events = Channel<UiEvent>(Channel.BUFFERED)
val events = _events.receiveAsFlow()

// Emit:
viewModelScope.launch { _events.send(UiEvent.NavigateToHome) }

// SharedFlow approach (for multiple consumers or complex buffering)
private val _events = MutableSharedFlow<UiEvent>(extraBufferCapacity = 1)
val events: SharedFlow<UiEvent> = _events.asSharedFlow()

Copy code// WRONG — event in StateFlow gets re-triggered on rotation
data class UiState(
    val navigateToDetail: Boolean = false,  // anti-pattern!
    val showError: String? = null
)

// Fragment collects uiState; on rotation:
// 1. New Fragment instance is created
// 2. New collector subscribes to StateFlow
// 3. StateFlow replays last value: navigateToDetail = true
// 4. Fragment navigates again — BUG!

// CORRECT — events in Channel, state in StateFlow
class CorrectViewModel : ViewModel() {
    private val _uiState = MutableStateFlow(UiState())
    val uiState: StateFlow<UiState> = _uiState.asStateFlow()

    private val _events = Channel<UiEvent>(Channel.BUFFERED)
    val events = _events.receiveAsFlow()
}

Copy code@HiltViewModel
class UserListViewModel @Inject constructor(
    private val userRepository: UserRepository
) : ViewModel() {

    // Converts the repository Flow to StateFlow, handling loading/error states
    val users: StateFlow<UiState<List<User>>> =
        userRepository.observeUsers()
            .map<List<User>, UiState<List<User>>> { UiState.Success(it) }
            .catch { emit(UiState.Error(it.message ?: "Error")) }
            .stateIn(
                scope = viewModelScope,
                started = SharingStarted.WhileSubscribed(5_000), // stays alive 5s after last subscriber
                initialValue = UiState.Loading
            )
}

Copy code// Before: LiveData
private val _name = MutableLiveData<String>()
val name: LiveData<String> = _name

// After: StateFlow
private val _name = MutableStateFlow("")
val name: StateFlow<String> = _name.asStateFlow()

// Before: observe in Fragment
viewModel.name.observe(viewLifecycleOwner) { binding.tvName.text = it }

// After: collect in Fragment
viewLifecycleOwner.lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.name.collect { binding.tvName.text = it }
    }
}

// Before: Transformations
val upperName: LiveData<String> = Transformations.map(_name) { it.uppercase() }

// After: Flow operators
val upperName: StateFlow<String> = _name
    .map { it.uppercase() }
    .stateIn(viewModelScope, SharingStarted.Eagerly, "")