lifecycleScope — что это, привязка к Lifecycle и работа в Android

Что такое lifecycleScope в Android?

lifecycleScope — это extension-свойство на интерфейс LifecycleOwner (Activity, Fragment, Service), предоставляющее готовый CoroutineScope, привязанный к полному жизненному циклу компонента. Когда LifecycleOwner достигает состояния DESTROYED, lifecycleScope автоматически отменяет все активные корутины.

// In Fragment or Activity
lifecycleScope.launch {
    delay(1000)
    showSnackbar("Hello!")
}

В отличие от viewModelScope, lifecycleScope отменяется при каждом уничтожении LifecycleOwner — включая ротацию экрана. Это делает его идеальным для операций, которые должны жить только пока виден конкретный экран.

Где доступен lifecycleScope

lifecycleScope доступен везде, где есть LifecycleOwner:

• Activity — AppCompatActivity наследует LifecycleOwner
• Fragment — Fragment наследует LifecycleOwner
• LifecycleService — сервис с жизненным циклом
• ProcessLifecycleOwner — жизненный цикл всего приложения
• Кастомные LifecycleOwner — любые объекты, реализующие LifecycleOwner

Как работает lifecycleScope: Lifecycle и автоматическая отмена

Механизм автоматической отмены lifecycleScope основан на подписке на события Lifecycle. Когда Lifecycle опускается ниже CREATED в DESTROYED, scope отменяется.

Состояния Lifecycle

Внутреннее устройство lifecycleScope

lifecycleScope создаётся как CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) и хранится внутри Lifecycle. При переходе Lifecycle в состояние DESTROYED вызывается scope.cancel(). Механизм реализован через LifecycleEventObserver, который подписывается на события жизненного цикла при первом обращении к scope.

Поведение при ротации

При повороте экрана Activity уничтожается (onDestroy) и создаётся заново. lifecycleScope отменяется вместе со старой Activity, и новый экземпляр scope создаётся для новой Activity. Это принципиальное отличие от viewModelScope, который сохраняется при ротации.

API lifecycleScope: launch, launchWhen и repeatOnLifecycle

Библиотека lifecycle предоставляет несколько способов запуска корутин через lifecycleScope. Рассмотрим эволюцию API от устаревших методов к современным.

lifecycleScope.launch — базовый запуск

Самый простой способ — lifecycleScope.launch { ... }. Корутина запускается немедленно и отменяется при DESTROYED. Однако она может выполнять код даже когда UI невидим (например, в фоне после onStop). Это не всегда желательно.

Устаревшие: launchWhenCreated / launchWhenStarted / launchWhenResumed

Эти методы приостанавливали выполнение корутины, когда Lifecycle опускался ниже указанного состояния, и возобновляли при возврате. Однако они были помечены как @Deprecated в lifecycle-runtime-ktx 2.6.0, потому что:

• Не отменяли корутину — только приостанавливали
• Приводили к накоплению висящих корутин, потребляющих память
• Создавали race condition при быстром переключении состояний

Современный API: repeatOnLifecycle

repeatOnLifecycle — рекомендованный Google способ запуска корутин, синхронизированных с жизненным циклом. Он отменяет и перезапускает корутину каждый раз, когда Lifecycle достигает заданного состояния.

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.uiState.collect { state ->
            updateUI(state)
        }
    }
}

Корутина, переданная в repeatOnLifecycle, запускается когда Lifecycle достигает STARTED, и отменяется когда он опускается ниже STARTED. При возврате в STARTED корутина перезапускается заново. Это безопасно и эффективно — никакие корутины не висят в паузе.

flowWithLifecycle — для Flow

Для сбора данных из Flow с учётом жизненного цикла существует оператор flowWithLifecycle. Он автоматически останавливает и возобновляет сбор при изменении состояния Lifecycle:

viewModel.uiState
    .flowWithLifecycle(lifecycle, Lifecycle.State.STARTED)
    .onEach { state -> updateUI(state) }
    .launchIn(lifecycleScope)

Оператор flowWithLifecycle — наиболее лаконичный способ безопасной подписки на Flow в UI-слое.

Примеры использования lifecycleScope

Рассмотрим три реальных сценария применения lifecycleScope в Android-приложении на Kotlin.

Пример 1: Подписка на Location-обновления только когда экран видим

class MapFragment : Fragment() {

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        lifecycleScope.launch {
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                locationProvider.observeLocation().collect { loc ->
                    updateMapMarker(loc)
                }
            }
        }
    }
}

Корутина стартует когда фрагмент становится видимым (STARTED) и отменяется когда он уходит с экрана (STOPPED). Если пользователь переключается на другое приложение, Location-обновления не потребляют батарею.

Пример 2: Запуск анимации при старте фрагмента

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.RESUMED) {
        animateFadeIn(titleView)
        delay(200)
        animateSlideUp(contentView)
    }
}

Анимация запускается только когда фрагмент на переднем плане (RESUMED). Если пользователь сворачивает приложение во время анимации, корутина отменяется, и при возврате анимация запускается заново.

Пример 3: Периодическая синхронизация данных на видимом экране

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        while (isActive) {
            syncData()
            delay(30_000L)
        }
    }
}

Данные синхронизируются каждые 30 секунд, но только когда экран видим. isActive проверяет, не отменена ли корутина, что обеспечивает возможность безопасного выхода из цикла при уходе с экрана.

lifecycleScope vs viewModelScope: сценарии применения

Оба scope привязаны к жизненному циклу, но к разным его аспектам. Понимание разницы критически важно для правильной архитектуры Android-приложений.

Ключевое различие

viewModelScope привязан к ViewModel, которая переживает ротацию экрана. lifecycleScope привязан к LifecycleOwner (Activity/Fragment), который при ротации уничтожается и создаётся заново. Это определяет сценарии их применения.

Когда использовать lifecycleScope

• Подписка на системные события (Location, датчики, камера)
• Анимации и UI-эффекты, привязанные к конкретному экрану
• Чанковая загрузка данных с учётом видимости экрана
• Операции, которые должны прекратиться при уходе с экрана

Когда использовать viewModelScope

• Загрузка данных из Repository
• Бизнес-логика, которая должна пережить ротацию
• Кэширование и обработка данных
• Любые операции, результат которых нужен после ротации

Комбинированное использование

На практике часто встречается комбинация обоих scope: viewModelScope загружает данные и управляет состоянием, lifecycleScope подписывается на Flow из ViewModel с учётом жизненного цикла экрана. Это разделение ответственности считается best practice в современной Android-разработке.

Типовые ошибки при работе с lifecycleScope

Рассмотрим четыре наиболее частые ошибки, которые допускают разработчики при использовании lifecycleScope.

Ошибка 1: Использование lifecycleScope вместо viewModelScope для загрузки данных

Если запустить загрузку данных в lifecycleScope.launch, при ротации экрана корутина отменится, и данные придётся загружать заново. Используйте viewModelScope для долгоживущих операций. lifecycleScope — только для UI-привязанных задач.

Ошибка 2: Сбор Flow без repeatOnLifecycle

Прямой вызов viewModel.someFlow.collect { ... } внутри lifecycleScope.launch продолжает собирать данные даже когда экран невидим. Это может привести к обновлению UI в фоне и лишним накладным расходам. Всегда используйте repeatOnLifecycle или flowWithLifecycle.

Ошибка 3: Забыли про отмену при уходе с экрана

Хотя lifecycleScope отменяется при DESTROYED, код после точки приостановки (suspend) может не выполниться при внезапной отмене. Не полагайтесь на выполнение post-кода после suspend-вызова, если только не используете NonCancellable.

Ошибка 4: Использование устаревшего launchWhenStarted вместо repeatOnLifecycle

launchWhenStarted и его аналоги не отменяют корутину, а только приостанавливают. Если экран много раз переключается между передним и задним планом, корутина накапливает отложенные вызовы. Переходите на repeatOnLifecycle — это единственный правильный способ синхронизации с Lifecycle.