MVVM Architecture in Android Explained

data class Forecast(val city: String, val tempC: Int, val condition: String, val fetchedAt: Long)

interface WeatherRepository {
    suspend fun getForecast(city: String): Forecast       // throws IOException on network failure
}

sealed interface WeatherUiState {
    data object Idle : WeatherUiState
    data object Loading : WeatherUiState
    data class Success(val title: String, val temperature: String, val condition: String) : WeatherUiState
    data class Error(val message: String) : WeatherUiState
}

@HiltViewModel
class WeatherViewModel @Inject constructor(
    private val repository: WeatherRepository,
    private val savedState: SavedStateHandle,
) : ViewModel() {

    val city: StateFlow<String> = savedState.getStateFlow("city", "Chandigarh")

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

    init { refresh() }

    fun onCityChange(value: String) { savedState["city"] = value }

    fun refresh() {
        val target = city.value.trim()
        if (target.isEmpty()) return
        viewModelScope.launch {
            _uiState.value = WeatherUiState.Loading
            _uiState.value = try {
                val f = repository.getForecast(target)
                // Presentation logic lives here: formatting for display
                WeatherUiState.Success(title = f.city, temperature = "${f.tempC}°C", condition = f.condition)
            } catch (e: IOException) {
                WeatherUiState.Error("Couldn't load weather. Check your connection.")
            }
        }
    }
}

@Composable
fun WeatherRoute(viewModel: WeatherViewModel = hiltViewModel()) {
    val state by viewModel.uiState.collectAsStateWithLifecycle()
    val city by viewModel.city.collectAsStateWithLifecycle()
    WeatherScreen(state, city, viewModel::onCityChange, viewModel::refresh)
}

@Composable
fun WeatherScreen(state: WeatherUiState, city: String, onCityChange: (String) -> Unit, onRefresh: () -> Unit) {
    Column(Modifier.padding(16.dp)) {
        OutlinedTextField(city, onCityChange, label = { Text("City") }, singleLine = true)
        Button(onClick = onRefresh, Modifier.padding(vertical = 8.dp)) { Text("Get weather") }
        when (state) {
            WeatherUiState.Idle -> Unit
            WeatherUiState.Loading -> CircularProgressIndicator()
            is WeatherUiState.Success -> Column {
                Text(state.title, style = MaterialTheme.typography.headlineSmall)
                Text(state.temperature, style = MaterialTheme.typography.displayMedium)
                Text(state.condition)
            }
            is WeatherUiState.Error -> Text(state.message, color = MaterialTheme.colorScheme.error)
        }
    }
}

class WeatherViewModelTest {
    @get:Rule val mainRule = MainDispatcherRule()

    private class FakeRepo(var fail: Boolean = false) : WeatherRepository {
        override suspend fun getForecast(city: String) =
            if (fail) throw IOException() else Forecast(city, 31, "Sunny", 0)
    }

    @Test fun `success formats temperature`() = runTest {
        val vm = WeatherViewModel(FakeRepo(), SavedStateHandle())
        advanceUntilIdle()
        assertEquals("31°C", (vm.uiState.value as WeatherUiState.Success).temperature)
    }

    @Test fun `network failure shows error`() = runTest {
        val vm = WeatherViewModel(FakeRepo(fail = true), SavedStateHandle())
        advanceUntilIdle()
        assertTrue(vm.uiState.value is WeatherUiState.Error)
    }
}