Kotlin: ViewModel

Если вы пишете Android-приложения, слово ViewModel вы встречаете постоянно. При этом вокруг него столько мифов («это просто класс для данных», «нужен только для MVVM»), что полезно вернуть всё на место: что это за класс, какую проблему он решает и когда его использовать не нужно.

Какую проблему решает ViewModel


Представьте экран с формой: пользователь заполнил поля, повернул телефон — и система пересоздала Activity. По умолчанию все данные исчезают: поля пустые, введённое — потеряно.

Проблема в том, что Activity — это компонент жизненного цикла: система может уничтожить и пересоздать её в любой момент (поворот экрана, смена языка, сворачивание и другие сценарии). Хранить данные внутри Activity — значит постоянно рисковать их потерять.

ViewModel — это класс, чей жизненный цикл привязан не к экрану, а к «владельцу»: Activity, Fragment или NavBackStackEntry. Когда экран пересоздаётся, получает новый экземпляр Activity, но тот же самый ViewModel — со всеми данными. Ровно это и есть его главное назначение.

Дополнительно ViewModel решает ещё одну задачу: отделяет логику от UI. Activity не должна сама ходить в сеть, читать базу и делать сложные вычисления — она должна только показывать и собирать ввод. ViewModel — то место, где эта логика живёт.

Как выглядит базовый пример


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:
@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, но удобнее):
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:
@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 сам соберёт зависимости:
@Composable
fun ProfileScreen(viewModel: ProfileViewModel = hiltViewModel()) { ... }

Если Hilt не используется, фабрика вручную:
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: Одно состояние экрана


Когда на экране много взаимосвязанных данных, удобно сворачивать их в один класс состояния. Это защищает от проблем «данные пришли не одновременно» и упрощает тестирование:
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, перейти на другой экран, запустить анимацию — это события, они не должны быть частью состояния (иначе после пересоздания экрана событие «сработает» повторно). Рабочий подход — канал событий:
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)
        }
    }
}

И на экране — однократный сбор с учётом жизненного цикла:
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:
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 нужна. Во всех остальных случаях можно обойтись без неё.

Автор:  21 час назад