Состояние и архитектура: ViewModel и MVVM

Храни состояние в Compose через `remember` и `mutableStateOf`, поднимай его выше (state hoisting), переноси данные экрана во ViewModel со StateFlow и строй приложение в стиле MVVM с однонаправленным потоком данных.

  • Продвинутый
  • 22 мин
  • 10 вопросов
  • Урок 11 из 14

В этом уроке ты узнаешь

  • Объяснять разницу между remember, rememberSaveable и mutableStateOf
  • Поднимать состояние и писать stateless-композабл без собственного состояния
  • Хранить состояние экрана во ViewModel через StateFlow и читать его в Compose
  • Описывать однонаправленный поток данных и слои MVVM

Лейла дошла до третьего вопроса в приложении-викторине и поворачивает телефон — счёт обнуляется, приходится начинать заново. У всех подобных ошибок один корень: состояние (state) хранится не там, где нужно. Состояние — любое значение, которое может меняться со временем и влияет на экран: введённый текст, положение переключателя, загруженный список, счёт. В этом уроке ты узнаешь, где и как его хранить.

remember и mutableStateOf

Compose замечает только изменения наблюдаемого состояния. mutableStateOf(...) создаёт такое значение: когда ты его меняешь, Compose заново вызывает функции, которые его читают (рекомпозиция). remember { } сохраняет значение между рекомпозициями; без него функция начинала бы с нуля при каждом вызове. Ключевое слово by позволяет не писать .value.

Неверно: обычная переменная

@Composable
fun Counter() {
    var count = 0
    Button(onClick = { count++ }) {
        Text("Clicked $count times")
    }
}

Верно: запомненное состояние

@Composable
fun Counter() {
    var count by rememberSaveable { mutableIntStateOf(0) }
    Button(onClick = { count++ }) {
        Text("Clicked $count times")
    }
}
Слева count растёт, но Compose об этом не знает, и на кнопке всегда 0. Справа каждое нажатие обновляет экран, а значение сохраняется даже при повороте экрана.

Чтобы читать дальше, зарегистрируйся бесплатно

Остальные разделы урока, тест и заметки открываются с аккаунтом Educora. Регистрация занимает минуту, а прогресс сохраняется на всех твоих устройствах.

Подъём состояния

Подъём состояния (state hoisting)Определение

Перенос состояния из composable-функции в вызывающую её функцию. Composable получает значение параметром, а о желании его изменить сообщает наверх через лямбду. Такая функция становится stateless (без состояния): её легко тестировать, показывать в превью и переиспользовать.

Kotlin
@Composable
fun CounterScreen() {
    var count by rememberSaveable { mutableIntStateOf(0) }
    Counter(count = count, onIncrement = { count++ })
}

@Composable
fun Counter(count: Int, onIncrement: () -> Unit, modifier: Modifier = Modifier) {
    Button(onClick = onIncrement, modifier = modifier) {
        Text("Clicked $count times")
    }
}
CounterScreen владеет состоянием, а Counter только показывает его и сообщает о нажатиях.

ViewModel и StateFlow

ViewModel — класс, который хранит данные и логику экрана. Он не пересоздаётся при повороте экрана, поэтому счёт не теряется. Состояние наружу отдаём через StateFlow — поток, у которого всегда есть текущее значение и который рассылает изменения. Внутри прячется изменяемый MutableStateFlow, а наружу открыт только StateFlow для чтения.

Kotlin
data class QuizUiState(
    val question: Int = 1,
    val score: Int = 0,
    val finished: Boolean = false
)

class QuizViewModel : ViewModel() {
    private val _uiState = MutableStateFlow(QuizUiState())
    val uiState: StateFlow<QuizUiState> = _uiState.asStateFlow()

    fun answer(correct: Boolean) {
        _uiState.update { state ->
            val next = state.question + 1
            state.copy(
                question = next,
                score = if (correct) state.score + 1 else state.score,
                finished = next > 5
            )
        }
    }
}
Всё состояние экрана — в одном неизменяемом data class; update атомарно заменяет его новой копией.
Kotlin
@Composable
fun QuizScreen(viewModel: QuizViewModel = viewModel()) {
    val state by viewModel.uiState.collectAsStateWithLifecycle()

    Column(modifier = Modifier.padding(16.dp)) {
        if (state.finished) {
            Text("Your score: ${state.score} / 5")
        } else {
            Text("Question ${state.question} of 5")
            Button(onClick = { viewModel.answer(correct = true) }) { Text("Correct") }
            Button(onClick = { viewModel.answer(correct = false) }) { Text("Wrong") }
        }
    }
}
На экране: «Question 1 of 5» и две кнопки; после пятого ответа — результат вроде «Your score: 3 / 5». Поворот экрана на него не влияет.

Функция viewModel() создаёт ViewModel для экрана или возвращает уже существующую. collectAsStateWithLifecycle() превращает поток в состояние Compose и прекращает сбор, пока приложение в фоне. Эти функции находятся в библиотеках lifecycle-viewmodel-compose и lifecycle-runtime-compose.

  1. Добавь в каталог

    В файле gradle/libs.versions.toml добавь в раздел [libraries] две строки:
    androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "lifecycleRuntimeKtx" }
    androidx-lifecycle-runtime-compose = { group = "androidx.lifecycle", name = "lifecycle-runtime-compose", version.ref = "lifecycleRuntimeKtx" }

  2. Подключи к модулю

    В app/build.gradle.kts добавь в блок dependencies строки implementation(libs.androidx.lifecycle.viewmodel.compose) и implementation(libs.androidx.lifecycle.runtime.compose).

  3. Синхронизируй и импортируй

    Нажми Sync Now, затем поставь курсор на красные viewModel и collectAsStateWithLifecycle, нажми Alt+Enter и выбери import.

Однонаправленный поток и MVVM

В коде выше данные движутся по кругу: экран показывает состояние → пользователь нажимает кнопку → экран отправляет во ViewModel событие (answer) → ViewModel создаёт новое состояние → экран его показывает. Это называется однонаправленным потоком данных (UDF). Поскольку состояние меняет только одно место, ошибки искать проще. Эту логику можно проверить и на обычном Kotlin:

Kotlin
data class CounterState(val count: Int = 0, val message: String = "")

sealed interface CounterEvent {
    data object Increment : CounterEvent
    data object Reset : CounterEvent
}

fun reduce(state: CounterState, event: CounterEvent): CounterState = when (event) {
    CounterEvent.Increment -> state.copy(
        count = state.count + 1,
        message = if (state.count + 1 >= 3) "Great streak!" else ""
    )
    CounterEvent.Reset -> CounterState()
}

fun main() {
    var state = CounterState()
    val events = listOf(CounterEvent.Increment, CounterEvent.Increment, CounterEvent.Increment, CounterEvent.Reset)
    for (event in events) {
        state = reduce(state, event)
        println("$event -> $state")
    }
}

Ожидаемый результат

Increment -> CounterState(count=1, message=)
Increment -> CounterState(count=2, message=)
Increment -> CounterState(count=3, message=Great streak!)
Reset -> CounterState(count=0, message=)
Слой MVVMЗадачаПример
Model (данные)получает данные из интернета или базы данных и хранит ихLessonRepository
ViewModelхранит состояние экрана, обрабатывает событияQuizViewModel
View (представление)показывает состояние, передаёт события во ViewModelQuizScreen
ViewModel никогда не должна напрямую хранить composable-функции или Context.
вынести выделенный код в отдельную функцию — Extract Function (Mac: Cmd+Option+M)Ctrl+Alt+M
переименовать во всём проекте — RenameShift+F6
найти, где вызывается функция — Find Usages (Mac: Option+F7)Alt+F7
структура файла: список классов и функций (Mac: Cmd+F12)Ctrl+F12

Запомни

  • Compose видит только изменения наблюдаемого состояния вроде mutableStateOf; remember сохраняет его между рекомпозициями.
  • rememberSaveable сохраняет простые значения даже при повороте; основные данные экрана живут во ViewModel.
  • Поднимай состояние: value идёт вниз, события вроде onValueChange — вверх.
  • ViewModel хранит состояние в приватном MutableStateFlow и отдаёт открытый StateFlow; экран читает его через collectAsStateWithLifecycle().
  • MVVM: Model даёт данные, ViewModel управляет состоянием, View его показывает — данные движутся в одном направлении.
Заметил ошибку или неточность в уроке?

Проверь себя

Вопросов: 10. Каждый правильный ответ приносит XP.

Вопрос 1 / 10

Вопрос 1 / 10. Что происходит со значением из remember { mutableStateOf(0) } при повороте экрана?