Android: жизненный цикл и состояние — бесплатный тест онлайн

Вопрос 1 из 30

Почему поведение «StateFlow в viewModelScope» не является случайностью?

// На ревью требуется объяснить причину поведения.
import kotlinx.coroutines.flow.*
class UserViewModel(private val repo: Repo) : ViewModel() {
    val state = repo.users.stateIn(
        viewModelScope,
        SharingStarted.WhileSubscribed(5_000),
        emptyList()
    )
}

Объяснение опирается на утверждение: Scope переживает удаление ViewModel из back stack и живёт до завершения процесса. ViewModel владеет экранным состоянием и операциями дольше конкретного интерфейс-экземпляра, но не является хранилищем для process death без saved state. Ключевым считают контракт: Он создаётся заново при каждой recomposition. Здесь действует следующее правило: Он гарантирует выполнение каждого вызова на Main независимо от операторов. Наблюдаемое поведение выводят из того, что он автоматически сохраняет весь state на диск.

Вопрос 2 из 30

Что следует изменить прежде всего во фрагменте «Минимальное состояние поиска»?

// Сохраните назначение фрагмента, но укрепите его контракт.
class SearchViewModel(private val saved: SavedStateHandle) : ViewModel() {
    var query: String
        get() = saved["query"] ?: ""
        set(value) { saved["query"] = value }
}

Обернуть операцию проверкой и не менять основной контракт: Хранит любой объём объектов в памяти после полного удаления приложения. Сохранять идентификатор, фильтр или черновик, а тяжёлую модель заново загружать из репозитория. Передать ответственность владельцу вызова, предполагая, что автоматически шифрует каждое значение и синхронизирует его с сервером. Зафиксировать текущее поведение регрессионным тестом: Гарантирует восстановление активного сетевого соединения. Добавить локальную обработку результата, потому что работает только при смене ориентации и не участвует в process recreation.

Вопрос 3 из 30

Какой редкий случай способен сломать наивную трактовку «Activity в глобальном кеше»?

Лямбда, listener или coroutine, захватившие View/Activity, могут утечь без явного поля context. Отдельно воспроизвести случай, в котором garbage collector очищает поле object после onDestroy. Воспроизвести редкий сценарий, где опасность ограничена главным потоком и исчезает при coroutineScope. Зафиксировать сценарий, где ожидается: Activity автоматически заменяется applicationContext при присваивании в object. Добавить граничный тест на утверждение: Утечка возможна только при nullable-поле, non-null свойство безопасно.

Вопрос 4 из 30

Предложенная правка для «Реальное пересоздание Activity» звучит так: Добавить тест перехода в background и process-death-инструментированный сценарий для критичного восстановления. Какой недостаток важнее обсудить?

Обратная сторона изменения состоит в том, что он доказывает восстановление после любого убийства процесса и обновления приложения. Сопровождение усложнится, если окажется, что он проверяет отсутствие всех утечек памяти без profiler/LeakCanary. Граница полезности решения описывается условием: Он гарантирует одинаковое поведение на всех версиях Android без матрицы устройств. Главная цена решения — необходимость учитывать, что он заменяет тесты reducer и репозитория. Инструментированный тест ближе к платформе, но медленнее и менее локален; слои тестов должны дополнять друг друга.

Вопрос 5 из 30

Какие границы ответственности здесь удачны?

// Проследите фактическое выполнение без изменения кода.
import kotlinx.coroutines.flow.*
class ScreenModel(
    private val repo: Repo,
    saved: SavedStateHandle
) : ViewModel() {
    private val id = requireNotNull(saved.get<String>("id"))
    val state = repo.observe(id)
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), Loading)
}

Saved state хранит навигационный id, repo владеет данными, а ViewModel собирает из них состояние экрана. Loading должен быть mutable singleton, чтобы интерфейс менял его напрямую. WhileSubscribed гарантирует, что upstream в рассматриваемом случае не не перезапустится. SavedStateHandle следует использовать как исходной кэш всех сущностей. ViewModel должна сама открывать SQLite и хранить Activity для отображения ошибок.

Вопрос 6 из 30

Что происходит, когда экран переходит ниже STARTED?

// Проследите фактическое выполнение без изменения кода.
import kotlinx.coroutines.*
lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.state.collect { render(it) }
    }
}

Collector продолжает работать в фоне, но render пропускает значения. StateFlow автоматически очищает текущее значение. RepeatOnLifecycle блокирует главный поток до DESTROYED. Весь lifecycleScope уничтожается и не восстановится при возврате. Дочерний блок collection отменяется и снова запускается при следующем переходе в STARTED.

Вопрос 7 из 30

Где поведение «Минимальное состояние поиска» требует отдельной проверки?

Добавить регрессию на гипотезу: Работает только при смене ориентации и не участвует в process recreation. Добавить тест на состояние, при котором хранит любой объём объектов в памяти после полного удаления приложения. Проверить соседний случай: Автоматически шифрует каждое значение и синхронизирует его с сервером. Отдельно проверить предположение, что гарантирует восстановление активного сетевого соединения. Большой Bundle может привести к TransactionTooLargeException; успешная работа в обычном тесте не доказывает безопасный размер.

Вопрос 8 из 30

Предложенная правка для «Activity в глобальном кеше» звучит так: Передать applicationContext в компонент, которому действительно нужен системный ресурс, либо внедрить узкий интерфейс. Какой недостаток важнее обсудить?

Граница полезности решения описывается условием: Опасность ограничена главным потоком и исчезает при coroutineScope. После правки останется ограничение: Утечка возможна только при nullable-поле, non-null свойство безопасно. Главная цена решения — необходимость учитывать, что garbage collector очищает поле object после onDestroy. Глобальный доступ кажется удобным, но скрывает жизненный цикл и делает тесты/многоконфигурационное поведение хрупкими. Обратная сторона изменения состоит в том, что activity автоматически заменяется applicationContext при присваивании в object.

Вопрос 9 из 30

Что проверяет такой тест лучше обычного unit-теста ViewModel?

// Проследите фактическое выполнение без изменения кода.
@Test fun state_survives_recreation() {
    scenario.onActivity { it.type("kotlin") }
    scenario.recreate()
    scenario.onActivity { assertEquals("kotlin", it.queryText()) }
}

Он проверяет отсутствие всех утечек памяти без profiler/LeakCanary. Он проходит реальное пересоздание Activity и связывает интерфейс, saved state и нового владельца lifecycle. Он доказывает восстановление после любого убийства процесса и обновления приложения. Он гарантирует одинаковое поведение на всех версиях Android без матрицы устройств. Он заменяет тесты reducer и репозитория.

Вопрос 10 из 30

Какой контракт определяет наблюдаемый результат «Экранное состояние по восстановленному id»?

// На ревью требуется объяснить причину поведения.
import kotlinx.coroutines.flow.*
class ScreenModel(
    private val repo: Repo,
    saved: SavedStateHandle
) : ViewModel() {
    private val id = requireNotNull(saved.get<String>("id"))
    val state = repo.observe(id)
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), Loading)
}

Объяснение опирается на утверждение: SavedStateHandle следует использовать как исходной кэш всех сущностей. Наблюдаемое поведение выводят из того, что whileSubscribed гарантирует, что upstream в рассматриваемом случае не не перезапустится. Ключевым считают контракт: Loading должен быть mutable singleton, чтобы интерфейс менял его напрямую. Android-архитектура отделяет восстанавливаемый ключ, источник данных и lifecycle интерфейс; state течёт вниз, события — к владельцу операции. Причину поведения формулируют так: ViewModel должна сама открывать SQLite и хранить Activity для отображения ошибок.

Вопрос 11 из 30

Какое объяснение результата «Сбор потока в STARTED» выдерживает проверку соседними случаями?

// На ревью требуется объяснить причину поведения.
import kotlinx.coroutines.*
lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.state.collect { render(it) }
    }
}

Причина результата в том, что repeatOnLifecycle блокирует главный поток до DESTROYED. Из правил языка или API следует, что collector продолжает работать в фоне, но render пропускает значения. Такой результат объясняют тем, что весь lifecycleScope уничтожается и не восстановится при возврате. Lifecycle-aware collection связывает активную работу с видимым состоянием владельца и повторно создаёт дочернюю корутину при входе в него. Механика примера описывается утверждением: StateFlow автоматически очищает текущее значение.

Вопрос 12 из 30

Как превратить неявное предположение в проверяемый контракт «StateFlow в viewModelScope»?

// Сохраните назначение фрагмента, но укрепите его контракт.
import kotlinx.coroutines.flow.*
class UserViewModel(private val repo: Repo) : ViewModel() {
    val state = repo.users.stateIn(
        viewModelScope,
        SharingStarted.WhileSubscribed(5_000),
        emptyList()
    )
}

Спрятать участок за вспомогательной функцией, сохранив предположение: Он создаётся заново при каждой recomposition. Ограничиться поясняющим комментарием о том, что он гарантирует выполнение каждого вызова на Main независимо от операторов. Передавать application-safe зависимости, держать интерфейс-состояние immutable и не помещать View/Activity/Context в долгоживущие поля. Добавить локальную обработку результата, потому что scope переживает удаление ViewModel из back stack и живёт до завершения процесса. Сохранить API и считать достаточным условие: Он автоматически сохраняет весь state на диск.

Вопрос 13 из 30

Каков фактический результат выполнения фрагмента «Activity в глобальном кеше»?

// Проследите фактическое выполнение без изменения кода.
object ImageCache {
    var context: Context? = null
}

class MainActivity : Activity() {
    override fun onCreate(state: Bundle?) {
        super.onCreate(state)
        ImageCache.context = this
    }
}

Утечка возможна только при nullable-поле, non-null свойство безопасно. Опасность ограничена главным потоком и исчезает при coroutineScope. Глобальный объект удержит уничтоженную Activity; Context здесь нельзя хранить таким способом. Garbage collector очищает поле object после onDestroy. Activity автоматически заменяется applicationContext при присваивании в object.

Вопрос 14 из 30

Какое объяснение результата «Реальное пересоздание Activity» выдерживает проверку соседними случаями?

// На ревью требуется объяснить причину поведения.
@Test fun state_survives_recreation() {
    scenario.onActivity { it.type("kotlin") }
    scenario.recreate()
    scenario.onActivity { assertEquals("kotlin", it.queryText()) }
}

Из правил языка или API следует, что он проверяет отсутствие всех утечек памяти без profiler/LeakCanary. Причина результата в том, что он заменяет тесты reducer и репозитория. Семантика фрагмента приводит к тому, что он гарантирует одинаковое поведение на всех версиях Android без матрицы устройств. Lifecycle-баги проверяются компонентным сценарием с recreation/stop/start, а чистая логика состояния остаётся в быстрых unit-тестах. Такой результат объясняют тем, что он доказывает восстановление после любого убийства процесса и обновления приложения.

Вопрос 15 из 30

Какую правку выбрать, чтобы сохранить назначение «Экранное состояние по восстановленному id» и убрать хрупкость?

// Сохраните назначение фрагмента, но укрепите его контракт.
import kotlinx.coroutines.flow.*
class ScreenModel(
    private val repo: Repo,
    saved: SavedStateHandle
) : ViewModel() {
    private val id = requireNotNull(saved.get<String>("id"))
    val state = repo.observe(id)
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), Loading)
}

Зафиксировать текущее поведение регрессионным тестом: Loading должен быть mutable singleton, чтобы интерфейс менял его напрямую. Обернуть операцию проверкой и не менять основной контракт: WhileSubscribed гарантирует, что upstream в рассматриваемом случае не не перезапустится. Определить политику повторной загрузки после паузы, обрабатывать ошибку upstream до stateIn и делать состояния неизменяемыми. Вынести участок в отдельный метод, считая верным следующее: ViewModel должна сама открывать SQLite и хранить Activity для отображения ошибок. Оставить структуру прежней, документировав утверждение: SavedStateHandle следует использовать как исходной кэш всех сущностей.

Вопрос 16 из 30

Какой рефакторинг делает поведение «Сбор потока в STARTED» предсказуемее?

// Сохраните назначение фрагмента, но укрепите его контракт.
import kotlinx.coroutines.*
lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.state.collect { render(it) }
    }
}

Сохранить API и считать достаточным условие: Collector продолжает работать в фоне, но render пропускает значения. Добавить локальную обработку результата, потому что весь lifecycleScope уничтожается и не восстановится при возврате. Собирать интерфейс-потоки через repeatOnLifecycle/collectAsStateWithLifecycle, а не запускать вечный collector без остановки. Спрятать участок за вспомогательной функцией, сохранив предположение: RepeatOnLifecycle блокирует главный поток до DESTROYED. Ограничиться поясняющим комментарием о том, что stateFlow автоматически очищает текущее значение.

Вопрос 17 из 30

Какой тест лучше всего защищает край контракта «StateFlow в viewModelScope»?

Две navigation entries могут иметь разные экземпляры одного ViewModel-класса; scope определяется владельцем, а не именем класса. Добавить регрессию на гипотезу: Scope переживает удаление ViewModel из back stack и живёт до завершения процесса. Проверить крайний ввод, при котором он гарантирует выполнение каждого вызова на Main независимо от операторов. Зафиксировать сценарий, где ожидается: Он создаётся заново при каждой recomposition. Считать опасной границей ситуацию, где он автоматически сохраняет весь state на диск.

Вопрос 18 из 30

Какую обратную сторону имеет решение для «Минимальное состояние поиска»: Сохранять идентификатор, фильтр или черновик, а тяжёлую модель заново загружать из репозитория?

Решение оправдано лишь при условии: Гарантирует восстановление активного сетевого соединения. Восстановление улучшает опыт после убийства процесса, но требует явной схемы ключей и миграции сохранённых значений. Практическое ограничение подхода: Хранит любой объём объектов в памяти после полного удаления приложения. Обратная сторона изменения состоит в том, что работает только при смене ориентации и не участвует в process recreation. Новый риск связан с тем, что автоматически шифрует каждое значение и синхронизирует его с сервером.

Вопрос 19 из 30

Какой рефакторинг делает поведение «Реальное пересоздание Activity» предсказуемее?

// Сохраните назначение фрагмента, но укрепите его контракт.
@Test fun state_survives_recreation() {
    scenario.onActivity { it.type("kotlin") }
    scenario.recreate()
    scenario.onActivity { assertEquals("kotlin", it.queryText()) }
}

Добавить локальную обработку результата, потому что он доказывает восстановление после любого убийства процесса и обновления приложения. Сохранить API и считать достаточным условие: Он проверяет отсутствие всех утечек памяти без profiler/LeakCanary. Добавить тест перехода в background и process-death-инструментированный сценарий для критичного восстановления. Добавить защитную проверку перед фрагментом, поскольку он гарантирует одинаковое поведение на всех версиях Android без матрицы устройств. Спрятать участок за вспомогательной функцией, сохранив предположение: Он заменяет тесты reducer и репозитория.

Вопрос 20 из 30

Какой контрпример точнее всего показывает границу «Экранное состояние по восстановленному id»?

Добавить граничный тест на утверждение: SavedStateHandle следует использовать как исходной кэш всех сущностей. Проверить границу полезности утверждения: Loading должен быть mutable singleton, чтобы интерфейс менял его напрямую. Отдельно воспроизвести случай, в котором whileSubscribed гарантирует, что upstream в рассматриваемом случае не не перезапустится. Проверить, сохраняется ли контракт, когда viewModel должна сама открывать SQLite и хранить Activity для отображения ошибок. WhileSubscribed с timeout может оставить upstream активным между короткими сменами экрана; это осознанный ресурсный компромисс.

Вопрос 21 из 30

Какой соседний случай отличает устойчивое решение «Сбор потока в STARTED» от удачного примера?

Отдельно проверить предположение, что stateFlow автоматически очищает текущее значение. Добавить регрессию на гипотезу: RepeatOnLifecycle блокирует главный поток до DESTROYED. Добавить тест на состояние, при котором весь lifecycleScope уничтожается и не восстановится при возврате. Проверить соседний случай: Collector продолжает работать в фоне, но render пропускает значения. Код после repeatOnLifecycle выполнится только после DESTROYED, потому что функция suspend ждёт завершения жизненного цикла.

Вопрос 22 из 30

Какова практическая цена решения «StateFlow в viewModelScope»: Передавать application-safe зависимости, держать интерфейс-состояние immutable и не помещать View/Activity/Context в долгоживущие поля?

Цена упрощения проявится, если он автоматически сохраняет весь state на диск. Практическое ограничение подхода: Он гарантирует выполнение каждого вызова на Main независимо от операторов. ViewModel сокращает повторные загрузки при конфигурации, но слишком крупная модель превращается в общий mutable контейнер экрана. После внедрения придётся исходить из того, что scope переживает удаление ViewModel из back stack и живёт до завершения процесса. Компромисс состоит в утверждении: Он создаётся заново при каждой recomposition.

Вопрос 23 из 30

Какую задачу решает SavedStateHandle?

// Проследите фактическое выполнение без изменения кода.
class SearchViewModel(private val saved: SavedStateHandle) : ViewModel() {
    var query: String
        get() = saved["query"] ?: ""
        set(value) { saved["query"] = value }
}

Он восстанавливает небольшой ввод после recreation или process death, но не заменяет постоянное хранилище. Гарантирует восстановление активного сетевого соединения. Работает только при смене ориентации и не участвует в process recreation. Автоматически шифрует каждое значение и синхронизирует его с сервером. Хранит любой объём объектов в памяти после полного удаления приложения.

Вопрос 24 из 30

Какое правило определяет поведение фрагмента «Activity в глобальном кеше»?

// На ревью требуется объяснить причину поведения.
object ImageCache {
    var context: Context? = null
}

class MainActivity : Activity() {
    override fun onCreate(state: Bundle?) {
        super.onCreate(state)
        ImageCache.context = this
    }
}

Причину поведения формулируют так: Опасность ограничена главным потоком и исчезает при coroutineScope. Контракт здесь понимают так: Garbage collector очищает поле object после onDestroy. Семантика фрагмента приводит к тому, что утечка возможна только при nullable-поле, non-null свойство безопасно. Причина результата в том, что activity автоматически заменяется applicationContext при присваивании в object. Долгоживущий владелец не должен хранить короткоживущую Activity/View/Fragment ссылку; направление владения важнее nullable-типа.

Вопрос 25 из 30

В «Экранное состояние по восстановленному id» выбрали решение: Определить политику повторной загрузки после паузы, обрабатывать ошибку upstream до stateIn и делать состояния неизменяемыми. Какова его реальная цена?

Главный риск формулируют так: Loading должен быть mutable singleton, чтобы интерфейс менял его напрямую. После правки останется ограничение: SavedStateHandle следует использовать как исходной кэш всех сущностей. Сопровождение усложнится, если окажется, что viewModel должна сама открывать SQLite и хранить Activity для отображения ошибок. Главная цена решения — необходимость учитывать, что whileSubscribed гарантирует, что upstream в рассматриваемом случае не не перезапустится. Разделение добавляет репозитории и модели, зато позволяет переживать recreation и тестировать каждый жизненный цикл отдельно.

Вопрос 26 из 30

Что станет новой точкой внимания после изменения «Сбор потока в STARTED»: Собирать интерфейс-потоки через repeatOnLifecycle/collectAsStateWithLifecycle, а не запускать вечный collector без остановки?

Цена упрощения проявится, если collector продолжает работать в фоне, но render пропускает значения. Практическое ограничение подхода: StateFlow автоматически очищает текущее значение. Компромисс состоит в утверждении: RepeatOnLifecycle блокирует главный поток до DESTROYED. После внедрения придётся исходить из того, что весь lifecycleScope уничтожается и не восстановится при возврате. Остановка экономит ресурсы, но cold upstream может заново выполнять загрузку при каждом возвращении без правильного sharing.

Вопрос 27 из 30

Что даёт `viewModelScope` этой модели?

// Проследите фактическое выполнение без изменения кода.
import kotlinx.coroutines.flow.*
class UserViewModel(private val repo: Repo) : ViewModel() {
    val state = repo.users.stateIn(
        viewModelScope,
        SharingStarted.WhileSubscribed(5_000),
        emptyList()
    )
}

Он автоматически сохраняет весь state на диск. Он создаётся заново при каждой recomposition. Он гарантирует выполнение каждого вызова на Main независимо от операторов. Scope переживает удаление ViewModel из back stack и живёт до завершения процесса. Корутины переживают пересоздание View и отменяются при окончательном `onCleared` ViewModel.

Вопрос 28 из 30

Почему поведение «Минимальное состояние поиска» не является случайностью?

// На ревью требуется объяснить причину поведения.
class SearchViewModel(private val saved: SavedStateHandle) : ViewModel() {
    var query: String
        get() = saved["query"] ?: ""
        set(value) { saved["query"] = value }
}

Объяснение опирается на утверждение: Хранит любой объём объектов в памяти после полного удаления приложения. Здесь действует следующее правило: Автоматически шифрует каждое значение и синхронизирует его с сервером. Saved state предназначен для минимального состояния, нужного для восстановления пути и интерфейс-ввода; данные должны быть поддерживаемого размера/формата. Ключевым считают контракт: Гарантирует восстановление активного сетевого соединения. Такой результат объясняют тем, что работает только при смене ориентации и не участвует в process recreation.

Вопрос 29 из 30

Какая правка устраняет причину риска в «Activity в глобальном кеше», а не только его проявление?

// Сохраните назначение фрагмента, но укрепите его контракт.
object ImageCache {
    var context: Context? = null
}

class MainActivity : Activity() {
    override fun onCreate(state: Bundle?) {
        super.onCreate(state)
        ImageCache.context = this
    }
}

Добавить защитную проверку перед фрагментом, поскольку утечка возможна только при nullable-поле, non-null свойство безопасно. Оставить реализацию без изменений и закрепить тестом предположение: Garbage collector очищает поле object после onDestroy. Передать applicationContext в компонент, которому действительно нужен системный ресурс, либо внедрить узкий интерфейс. Вынести участок в отдельный метод, считая верным следующее: Опасность ограничена главным потоком и исчезает при coroutineScope. Спрятать участок за вспомогательной функцией, сохранив предположение: Activity автоматически заменяется applicationContext при присваивании в object.

Вопрос 30 из 30

На каком входе или состоянии граница «Реальное пересоздание Activity» становится заметной?

Считать опасной границей ситуацию, где он проверяет отсутствие всех утечек памяти без profiler/LeakCanary. `recreate()` не полностью эквивалентен убийству процесса: память процесса и singleton-ы могут сохраниться. Добавить регрессию на гипотезу: Он доказывает восстановление после любого убийства процесса и обновления приложения. Проверить, сохраняется ли контракт, когда он гарантирует одинаковое поведение на всех версиях Android без матрицы устройств. Проверить крайний ввод, при котором он заменяет тесты reducer и репозитория.