Что знаешь про жизненный цикл компонентов

Жизненный цикл компонентов в Android

Жизненный цикл компонентов — это одна из фундаментальных тем в Android-разработке, описывающая состояния, через которые проходит компонент (Activity, Fragment, Service, BroadcastReceiver) от создания до уничтожения. Понимание жизненного цикла критически важно для правильного управления ресурсами, данными и поведением приложения.

Ключевые компоненты и их жизненные циклы

1. Activity

Activity — это основной компонент для взаимодействия с пользователем. Её жизненный цикл управляется системой через callback-методы:

• onCreate(): Вызывается при создании Activity. Здесь инициализируются UI (setContentView), данные, ViewModel. Состояние Bundle может быть null (новый запуск) или содержать сохранённые данные (после поворота).
• onStart(): Activity становится видимой, но не взаимодействует с пользователем. Подписки на данные (например, LiveData) часто запускаются здесь.
• onResume(): Activity выходит на передний план и становится интерактивной. Запускаются анимации, камеры, таймеры.
• onPause(): Другая Activity частично перекрывает текущую. Здесь следует приостановить ресурсоёмкие операции, но не тяжёлые задачи (сохранение данных), так как метод должен быть быстрым.
• onStop(): Activity больше не видна. Можно освобождать ресурсы (например, отписаться от сетевых запросов).
• onDestroy(): Финализация Activity. Вызывается перед уничтожением (завершение работы или системное убийство). Здесь очищаются связи с контекстом.

Пример переопределения методов:

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        Log.d("Lifecycle", "onCreate")
    }

    override fun onStart() {
        super.onStart()
        Log.d("Lifecycle", "onStart")
    }

    override fun onResume() {
        super.onResume()
        Log.d("Lifecycle", "onResume")
    }

    override fun onPause() {
        super.onPause()
        Log.d("Lifecycle", "onPause")
    }

    override fun onStop() {
        super.onStop()
        Log.d("Lifecycle", "onStop")
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.d("Lifecycle", "onDestroy")
    }
}

Для сохранения состояния используются onSaveInstanceState() (сохранение в Bundle) и onRestoreInstanceState() (восстановление). Рекомендуется использовать ViewModel с LiveData для хранения данных, связанных с UI, так как ViewModel переживает изменения конфигурации (например, поворот экрана).

2. Fragment

Fragment — это модульная часть UI, вложенная в Activity. Его жизненный цикл похож на Activity, но более сложный из-за привязки к родительской Activity:

• onAttach(): Fragment присоединяется к Activity.
• onCreate(): Инициализация данных (без UI).
• onCreateView(): Создание и возврат View-иерархии.
• onViewCreated(): View создана, можно настраивать элементы (например, RecyclerView).
• onStart(), onResume(), onPause(), onStop() — аналогично Activity, синхронизированы с жизненным циклом Activity.
• onDestroyView(): View уничтожена, но Fragment ещё существует. Здесь нужно очищать ссылки на View для избежания утечек памяти.
• onDestroy() и onDetach(): Полное уничтожение Fragment.

Важно: Fragment может находиться в Back Stack, что влияет на его состояния. Для управления данными в Fragment рекомендуется использовать ViewModel, разделяемую с Activity.

3. Service

Service выполняет фоновые операции без UI. Два основных типа:

• Started Service (запущен через startService()): Живёт до явной остановки или завершения задачи. Жизненный цикл: onCreate() → onStartCommand() → работа → stopSelf()/stopService() → onDestroy().
• Bound Service (привязан через bindService()): Живёт, пока хотя бы один клиент привязан. Жизненный цикл: onCreate() → onBind() → обслуживание клиентов → onUnbind() → onDestroy().

Для долгих фоновых задач в современных версиях Android рекомендуется использовать WorkManager или Foreground Service (с уведомлением).

4. BroadcastReceiver

BroadcastReceiver реагирует на системные или кастомные события. Жизненный цикл короткий: метод onReceive() вызывается при получении события и должен завершиться быстро (не более 10 секунд), иначе система завершит процесс. Для длительных операций следует запускать Service или JobIntentService.

Практические аспекты и лучшие практики

• Управление ресурсами: Следует освобождать ресурсы (сетевые соединения, датчики) в onPause()/onStop(), чтобы избежать утечек памяти и повышенного потребления батареи.
• Сохранение состояния: Для простых данных — Bundle (onSaveInstanceState), для сложных — ViewModel + Repository. Данные в Bundle должны быть легковесными (примитивы, String).
• Обработка конфигураций: Изменение ориентации, языка приводит к уничтожению и пересозданию Activity/Fragment. ViewModel сохраняется благодаря ViewModelProvider, который использует ViewModelStore.
• Жизненный цикл в архитектуре: В паттернах MVVM или MVI компоненты жизненного цикла (LifecycleOwner) позволяют автоматически управлять подписками (например, LiveData.observe()).
• Обработка прерываний: Нажатие кнопки "Назад", переход в другое приложение, звонок — всё это вызывает методы жизненного цикла, которые нужно корректно обрабатывать.

Пример использования LiveData с учетом жизненного цикла:

class MyViewModel : ViewModel() {
    private val _data = MutableLiveData<String>()
    val data: LiveData<String> = _data

    fun loadData() {
        _data.value = "Hello, Lifecycle!"
    }
}

class MyActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val viewModel: MyViewModel by viewModels()
        viewModel.data.observe(this) { value ->
            // Обновление UI только при активном состоянии (STARTED, RESUMED)
            textView.text = value
        }
    }
}

Итог

Глубокое понимание жизненного цикла позволяет создавать отзывчивые, стабильные и энергоэффективные приложения. Современные подходы (ViewModel, LiveData, Lifecycle-Aware Components) автоматизируют многие аспекты, но знание внутренних механизмов остаётся обязательным для решения сложных задач, таких как обработка восстановления состояния, управление памятью и фоновая работа.