Какую проблему решает ViewModel
Представьте экран с формой: пользователь заполнил поля, повернул телефон — и система пересоздала Activity. По умолчанию все данные исчезают: поля пустые, введённое — потеряно.
Проблема в том, что Activity — это компонент жизненного цикла: система может уничтожить и пересоздать её в любой момент (поворот экрана, смена языка, сворачивание и другие сценарии). Хранить данные внутри Activity — значит постоянно рисковать их потерять.
ViewModel — это класс, чей жизненный цикл привязан не к экрану, а к «владельцу»: Activity, Fragment или NavBackStackEntry. Когда экран пересоздаётся, получает новый экземпляр Activity, но тот же самый ViewModel — со всеми данными. Ровно это и есть его главное назначение.
Дополнительно ViewModel решает ещё одну задачу: отделяет логику от UI. Activity не должна сама ходить в сеть, читать базу и делать сложные вычисления — она должна только показывать и собирать ввод. ViewModel — то место, где эта логика живёт.
Как выглядит базовый пример
ВыделитьKotlin
class SearchViewModel : ViewModel() {
private val _query = MutableStateFlow("")
val query: StateFlow<String> = _query.asStateFlow()
private val _results = MutableStateFlow<List<User>>(emptyList())
val results: StateFlow<List<User>> = _results.asStateFlow()
fun onQueryChanged(newQuery: String) {
_query.value = newQuery
search()
}
private fun search() {
viewModelScope.launch {
_results.value = repository.findUsers(_query.value)
}
}
}И подключение на экране — с Jetpack Compose:
ВыделитьKotlin
@Composable
fun SearchScreen(viewModel: SearchViewModel = viewModel()) {
val query by viewModel.query.collectAsStateWithLifecycle()
val results by viewModel.results.collectAsStateWithLifecycle()
SearchUi(
query = query,
results = results,
onQueryChanged = viewModel::onQueryChanged
)
}Обратите внимание на детали:
- Приватное поле и публичный поток: Снаружи видна только неизменяемая версия (StateFlow), менять состояние экрана можно только через методы ViewModel. Это защищает от хаотичной записи состояния откуда угодно.
- viewModelScope: Корутины, запущенные в этом скоупе, живут столько, сколько живёт ViewModel. Если экран закрыли навсегда — onCleared() вызывается автоматически, и корутины отменяются. Не нужно писать ручную отмену, не нужно бояться утечек.
- Экран не знает про сеть и базу: Он знает только про состояние и события. Это делает его дешёвым в тестировании и простым в замене.
Сколько живёт ViewModel
Важный момент, который часто упускают: ViewModel не бессмертна.
| Событие | Данные во ViewModel | Стандартный UI-стейт (в Activity) |
| Поворот экрана | Сохраняются | Теряются |
| Свернуть приложение (коротко) | Сохраняются | Сохраняются |
| Процесс убит системой | Теряются | Теряются |
| Пользователь закрыл экран | Теряются | Теряются |
ViewModel переживёт пересоздание Activity, но не гибель процесса. Если данные критичны (текст недописанного письма, состояние заказа), используйте
SavedStateHandle — это «короткоживущий» аргумент, который система сохраняет и восстанавливает через стандартный механизм (как onSaveInstanceState, но удобнее):
ВыделитьKotlin
class CheckoutViewModel(
private val savedStateHandle: SavedStateHandle,
private val repository: OrderRepository
) : ViewModel() {
private val _orderId = savedStateHandle.getStateFlow("orderId", "")
val orderId: StateFlow<String> = _orderId
fun setOrderId(id: String) {
savedStateHandle["orderId"] = id
}
}А вот долгосрочные данные (кэш, история, избранное) в ViewModel хранить нельзя — они должны жить в слое данных: репозиториях, базе, DataStore. ViewModel — про состояние экрана, а не про хранилище.
Как получить ViewModel
Современный подход — внедрение зависимостей через Hilt:
Выделитьkotlin
@HiltViewModel
class ProfileViewModel @Inject constructor(
private val repository: UserRepository
) : ViewModel() {
val user: StateFlow<User?> = repository.observeUser()
.stateIn(
scope = viewModelScope,
started = SharingStarted.WhileSubscribed(5000),
initialValue = null
)
}На экране достаточно
viewModel() — Hilt сам соберёт зависимости:
ВыделитьKotlin
@Composable
fun ProfileScreen(viewModel: ProfileViewModel = hiltViewModel()) { ... }Если Hilt не используется, фабрика вручную:
ВыделитьKotlin
class ProfileViewModel(private val userId: String) : ViewModel() {
companion object {
val Factory = viewModelFactory {
initializer {
val app = this[APPLICATION_KEY] as MyApplication
ProfileViewModel(app.container.userRepository)
}
}
}
}
// На экране:
val vm: ProfileViewModel = viewModel(factory = ProfileViewModel.Factory)Паттерн UiState: Одно состояние экрана
Когда на экране много взаимосвязанных данных, удобно сворачивать их в один класс состояния. Это защищает от проблем «данные пришли не одновременно» и упрощает тестирование:
ВыделитьKotlin
data class ProfileUiState(
val isLoading: Boolean = false,
val user: User? = null,
val error: String? = null
)
class ProfileViewModel(private val repository: UserRepository) : ViewModel() {
private val _uiState = MutableStateFlow(ProfileUiState())
val uiState: StateFlow<ProfileUiState> = _uiState.asStateFlow()
init {
load()
}
fun load() {
viewModelScope.launch {
_uiState.value = ProfileUiState(isLoading = true)
try {
val user = repository.getUser()
_uiState.value = ProfileUiState(user = user)
} catch (e: Exception) {
_uiState.value = ProfileUiState(error = e.message)
}
}
}
}На экране один collect — и вся разметка описывается через три возможных состояния: загрузка, контент, ошибка.
События: Как передавать «одноразовые» действия
Не всё на экране — состояние. Показать toast, перейти на другой экран, запустить анимацию — это события, они не должны быть частью состояния (иначе после пересоздания экрана событие «сработает» повторно). Рабочий подход — канал событий:
ВыделитьKotlin
sealed interface ProfileEvent {
data class ShowToast(val message: String) : ProfileEvent
data object NavigateToSettings : ProfileEvent
}
class ProfileViewModel : ViewModel() {
private val _events = Channel<ProfileEvent>()
val events = _events.receiveAsFlow()
fun onLogoutClicked() {
viewModelScope.launch {
authRepository.logout()
_events.send(ProfileEvent.NavigateToSettings)
}
}
}И на экране — однократный сбор с учётом жизненного цикла:
ВыделитьKotlin
LaunchedEffect(Unit) {
viewModel.events.collect { event ->
when (event) {
is ProfileEvent.ShowToast -> showToast(event.message)
ProfileEvent.NavigateToSettings -> navigateToSettings()
}
}
}ViewModel и MVVM
ViewModel — строительный блок паттерна MVVM (Model–View–ViewModel), который Google официально рекомендует для Android. Роли распределяются так:
- Model — данные и логика домена: репозитории, база, сеть.
- ViewModel — состояние конкретного экрана, логика «что показывать», трансформация данных модели в UI-состояние.
- View (Activity/Fragment/Compose) — только отрисовка и передача пользовательских действий.
Хорошая ViewModel не содержит ссылок на UI-компоненты, контексты и «знает» только про свой экран. Если ViewModel тянется к другому экрану или хранит в себе контекст Activity — это сигнал, что логика на месте не там.
Частые ошибки
- Хранить Context или View в ViewModel: Это прямая дорога к утечке памяти и крошечной катастрофе при пересоздании экрана. Контекст, если он нужен, — только ApplicationContext, и то через DI.
- Хранить долгоживущие данные: Кэш изображений, историю сообщений, токены — не здесь. Для этого есть слой данных.
- Толстые ViewModel: Одна ViewModel на всё приложение — анти-паттерн. ViewModel — на экран (или на логическую группу навигации), а не на весь проект. Если класс вырос в тысячу строк — разбирайте его на юнит-классы и делегируйте.
- Игнорировать onCleared(): Если ViewModel подписана на «долгоживущие» источники (например, на глобальный синглтон с колбэками), не забудьте отписаться в
onCleared(). СоviewModelScopeи потоками обычно это происходит автоматически, но не везде. - Логика в View: Если в Activity или Compose-функции вы делаете расчёты, обрабатываете ошибки, форматируете данные для отображения — скорее всего, эта логика должна жить во ViewModel.
Тестируемость
ViewModel тестируется легко — это просто класс с зависимостями, без UI:
ВыделитьKotlin
class SearchViewModelTest {
@Test
fun `search returns filtered users`() = runTest {
val repository = FakeUserRepository()
val vm = SearchViewModel(repository)
vm.onQueryChanged("иван")
advanceUntilIdle()
assertEquals(listOf("Иван Петров"), vm.results.value.map { it.name })
}
}Никаких эмуляторов, никаких Robolectric — обычный unit-тест. Это одна из главных причин, почему отделять логику в ViewModel стоит даже в небольших проектах.
Когда ViewModel не нужна
Есть ситуации, где ViewModel — лишний вес:
- Слайд, демо, утилитный экран без состояния: Если экран просто показывает статичную страницу — ViewModel не добавляет ценности.
- Крошечный экран с одной строкой данных: Порой проще хранить состояние прямо в Compose через remember — и это нормально, если данные не переживают пересоздание.
- Состояние, которое не должно переживать поворот экрана: Например, поле для пароля, которое по соображениям безопасности нужно очищать при смене экрана.
Главный критерий: если данные экрана обязаны выжить при пересоздании, или логика экрана требует выделения в отдельный класс — ViewModel нужна. Во всех остальных случаях можно обойтись без неё.