Главная
Курс по Android с нуля (бесплатные уроки в Android Studio на Kotlin)
Урок 17: Жизненный цикл Activity, Logcat (логирование)

Урок 17: Жизненный цикл Activity, Logcat (логирование)

Введение
Процесс запуска приложения (3 состояния Activity)
Методы жизненного цикла Activity
Логирование и класс Log
Logcat в Android Studio
- Иерархия логирования
Метод onCreate(): Инициализация Activity и настройка UI
Метод onStart(): Подготовка Activity к отображению
Метод onResume(): Активация Activity и взаимодействие с пользователем
Метод onPause(): Приостановка Activity и освобождение ресурсов
Метод onStop(): Завершение видимости Activity
Метод onDestroy(): Полное завершение Activity и освобождение всех ресурсов
Заключение

Введение

Вы уже не раз могли слышать про некие методы жизненного цикла, которые есть у разных компонентов. Чтобы разобраться зачем они вообще были придуманы и как их использовать (спойлер: они очень важны и нужны) – давайте взглянем на процесс запуска приложения.

Процесс запуска приложения (3 состояния Activity)

Итак, вы тапнули на иконку какого-нибудь приложения на экране смартфона. Вообще-то надо сказать, что запуск приложения и отрисовка его элементов довольно сложный технологический процесс. В ваших руках практически происходит построение целого мегаполиса из методов, системных классов, расчетов свойств и размеров UI элементов для определенного устройства и экрана со своей плотностью пикселей. Под капотом выполняются тысячи и тысячи строк кода, чтобы вы увидели, например, изображение котика в красивом интерфейсе Телеграм.

И все это должно произойти до того, как что-то будет отображено пользователю. Ну потому, что неподготовленные ресурсы могут некорректно отображаться, вызывать торможения или вовсе не работать.

Так вот, чтобы разделять эти процессы придумали определенные состояния. В каждом специальном состоянии активити происходит своя определенная работа. Их всего 3.

Состояние, которое я описал выше называется CREATED (создано). То есть Activity еще не видна пользователю, а только создано и подготовлено для отрисовки.
На следующем этапе оно отрисовывается и уже видна пользователю, но он все еще не может с ним взаимодействовать. Обычно это состояние проходит мгновенно, но вы можете задержаться на нем, когда, например, во время открытия приложения появляется системное диалоговое окно для каких-нибудь разрешений. Это состояние называется VISIBLE (видимое). Запомните: смотреть можно, трогать нельзя.
Третье состояние Activity полностью готово для взаимодействия с пользователем. Оно находится на переднем плане и вы можете испытывать полноценный user experience. Название этому состоянию RESUMED (возобновлено).

Методы жизненного цикла Activity

И вот в таком виде теперь примерно становится понятно что и в какой момент происходит под капотом при запуске Activity. При этом важно понимать, что при сворачивании приложения или выключении экрана – все состояния отрабатывают в обратном порядке.

Однако, это все еще абстрактное представление. Двигаемся дальше.

При переходе из одного состояния в другое – вся производимая работа по подготовке ресурсов и всего такого выполняется в специально разработанных системных методах. Именно их называют методами жизненного цикла Activity. Эти методы вызываются системой Android автоматически, когда наступает то или иное состояние. Это системные коллбэки.

Коллбэки (или обратные вызовы) – это методы, которые передаются как параметры другим функциям и могут быть вызваны (т.е. выполнены) в будущем при наступлении определённых условий. Так вот и в нашем контексте обсуждения – система определяет, когда активити становится видимой, когда она переходит в фон и т.д., и вызывает соответствующие методы коллбэки.

Кроме того, глядя на эту схемку видно, что нельзя взять и просто так перескочить через состояние. То есть невозможно из состояния created попасть в resumed. Также как и нельзя не вызвать соответствующий метод ЖЦ при переходе из одного состояния в другое.

Великолепно. Теперь мы концептуально понимаем зачем был придуман жизненный цикл. Чтобы работать с ресурсами системы в разных состояниях приложениях. Чтобы в итоге доставлять позитивный опыт для конечного пользователя.

Пришло время подробнее проговорить назначение каждого метода ЖЦ, чтобы окончательно стало понятно его назначение в системе. Таким образом вам будет проще их запомнить и рассказывать на собеседованиях, в том числе и на тренировочных собесах в рамках нашего практикума AndroidSprint.

Логирование и класс Log

Но прежде чем воспроизводить работу каждого метода, давайте познакомимся с логированием. А в частности инструментом Logcat в Android Studio, чтобы мы могли отслеживать вызовы методов в зависимости от состояния Activity.

Логирование — это способ отслеживания выполнения программы путем вывода сообщений в консоль. Внутри метода onCreate() напишу лог с уровнем INFO.

Log.i("!!!", "${this.componentName.shortClassName} Выполняется метод onCreate()").

В Android для создания логов используется класс Log. Он позволяет выводить различные уровни сообщений: VERBOSE, DEBUG, INFO, WARN, ERROR и ASSERT. А еще есть уровень WTF (what a terrable failure). Уровни логирования используются для классификации сообщений по степени их важности и предназначению.

Например, INFO (как сейчас) используется для вывода информационных сообщений, которые отражают нормальное функционирование приложения. А ERROR сообщает об эксепшенах, которые произошли во время выполнения приложения. Каждый тип ошибки имеет свой цвет в консоли для удобной работы с ним.

В качестве тега обычно принято использовать имя класса, но для упрощения фильтрации всех логов под одним ключом можно вывести что-то уникальное. Я обычно использую просто восклицательные знаки. Но это только в ходе дебага и разработки, в рабочем коде лучше не оставлять восклицательные знаки.

В качестве сообщения используется сообщение в свободной форме, если выбрасываем ошибку, то еще можно через интерполяцию выводить ее подробности и другие данные. Я выведу название класса, в котором вызываем лог и соответствующее название метода.

Все, теперь, когда метод onCreate() будет вызван, в логах появится сообщение.

Logcat в Android Studio

Теперь запустим приложение и откроем панель Logcat. Logcat — это инструмент, который отображает журналы сообщений, включая логи, созданные приложением. Для начала настроим его для работы.

Сперва выберем представление – выбираем Formatting Options → Compact View.

Далее установим фильтры.

В поле фильтрации вводим package:mine, чтобы отображались сообщения только из нашего приложения.
Устанавливаем уровень логирования на INFO, чтобы видеть информационные сообщения и выше по важности.
Ну и в поле поиска вводим наш тег, чтобы отображались только сообщения его содержащие. Пока здесь ничего не отображается, так как лог запускается в методе onCreate(), который находится в SecondDemoActivity, а она еще не создана.

Иерархия логирования

И еще немного про иерархию. В Android уровни логирования располагаются в порядке важности:

VERBOSE (наименее важный)
DEBUG
INFO
WARN
ERROR
ASSERT (наиболее важный)

Когда мы говорим «выше по важности», мы имеем в виду уровни, которые находятся выше в этом списке, то есть более критичные. Например, ERROR — это более высокий уровень важности по сравнению с INFO. В более высокой категории важности не будут отображаться ошибки низкого приоритета. Плюс важные подкрашиваются ярче в Andoid Studio – от белого цвета до красного.

Метод onCreate(): Инициализация Activity и настройка UI

Отлично, ну и теперь к самим методам.

Рассказываю про методы ЖЦ Activity в Android

Метод ЖЦ Activity – onCreate(). С ним вы познакомились раньше всех, еще когда создавали проект и писали в нем свой первый код приложения. Метод вызывается системой один раз за весь ЖЦ. Происходит это когда Активити создана под капотом, но еще вообще нет никаких намеков на ее отображение.

В этом методе происходит настройка отображения интерфейса, мы подключали там файл с разметкой, можно проинициализировать различные слушатели, наблюдатели, адаптеры и так далее.

Мы разместили лог в SecondDemoActivity, и теперь при переходе на вторую Activity она создается и вызывается метод onCreate(). Внутри срабатывает наш прописанный лог и сообщение отображается в Logcat. Все отрабатывает корректно.

Метод onStart(): Подготовка Activity к отображению

Метод onStart() вызывается системой сразу после onCreate(), когда Activity становится видимой пользователю, но еще не интерактивна. В этот момент интерфейс уже подготовлен и отрисован на экране, но пользователь пока не может с ним взаимодействовать.

В методе onStart() обычно выполняется настройка компонентов, которые необходимы для отображения Activity. То есть всего того, что должно работать пока Активити видна пользователю. Например, можно инициализировать сервисы геолокации, bluetooth, или базы данных.

Разработчик должен заботиться об экономии ресурсов, в том числе батареи устройства. Если Activity еще не видна, то часто нет смысла подключать неиспользуемые компоненты раньше времени. Поэтому для таких целей onStart()идеальное место, чтобы их включить и onStop(), чтобы отключить соответственно.

В методе размещаю Log c соответствующим сообщением. Запускаем приложение, переходим во вторую Activity и наблюдаем, как сначала вызывается метод onCreate(), затем onStart(). Причем следующий метод был запущен спустя 2 миллисекунды. Все отлично, идем дальше.

override fun onStart() {
    super.onStart()
    Log.i("!!!", "${this.componentName.shortClassName} Выполняется метод onStart()")
}

Метод onResume(): Активация Activity и взаимодействие с пользователем

Метод onResume() вызывается тогда, когда Activity становится полностью активной и получает фокус ввода. Теперь она может обрабатывать пользовательский ввод (касания, нажатия кнопок и т.д.). Начинается полноценное функционирование экрана.

В onResume() обычно возобновляют работу компоненты, которые были приостановлены. Например, можно запустить анимации, воспроизведение видео или начать обновление данных в реальном времени.

Также, как и выше размещаю Log c соответствующим сообщением. Запускаем, переходим во вторую Activity и наблюдаем, как последовательно вызываются методы onCreate(), затем onStart() и текущий рассматриваемый onResume().

override fun onResume() {
    super.onResume()
    Log.i("!!!", "${this.componentName.shortClassName} Выполняется метод onResume()")
}

Окей. Далее представим, что пользователь перестал взаимодействовать с приложением и решил принудительно закрыть его. В этом случае помним, что вызывается та же самая цепочка состояний в обратном порядке. Но набор методов будет уже другой.

Метод onPause(): Приостановка Activity и освобождение ресурсов

Обратный порядок начинается с метода onPause(). То есть, если я принудительно закрою приложение, то последовательно вызовутся все три метода до уничтожения Activity: onPause(), onStop() и onDestroy().

Однако, можно воспроизвести ситуацию, когда мы можем зафиксировать нашу SecondDemoActivity на методе onPause(), для этого добавлю несколько изменений в код и сейчас все будет наглядно понятно.

По новой созданной кнопке мы будем вызывать системное диалоговое окно с запросом разрешения на доступ к локации устройства. Он полностью управляется системой и открывается поверх нашей SecondDemoActivity, затемняя при этом фон.

Такая ситуация позволяет перевести нашу Активити из состояния RESUMED в состояние VISIBLE и вызвать системный метод onPause(). Что произошло? Activity теряет фокус, взаимодействовать с компонентом уже нельзя, но интерфейс все еще остается видимым на экране, хоть и на заднем плане. В консоли видим, как отрабатывает лог в методе onPause().

Если необходимо, Activity на этом этапе может сохранить данные, которые нужно восстановить при возобновлении. Например, состояние ввода текста в инпуте. В этом методе можно отключать различные слушатели, датчики, анимации или приостанавливать воспроизведение видео и выполнение задач по расписанию. В общем освобождаем ресурсы, которые не нужны, когда Activity не на переднем плане.

Если кликнуть вне этой области, то диалог закроется, а состояние нашей Активити вернется в VISIBLE и вызовется системный метод onResume(). Что мы и наблюдаем в консоли.

Метод onStop(): Завершение видимости Activity

Теперь рассмотрим метод ЖЦ onStop(). Он вызывается системой, когда Activity перестает быть видимой для пользователя, но все еще существует в памяти. То есть все еще не уничтожена. Это происходит в ситуациях, когда мы переходим на другую Activity, сворачиваем приложение или открываем другое приложение, полностью перекрывающее текущую Activity.

Метод onStop() подходит для того, чтобы освободить ресурсы, связанные с пользовательским интерфейсом и прекратить выполнение долгосрочных операций. Например, отключить сервисы геолокации, остановить обновление данных или сохранить состояние приложения. Освобождаем ресурсы, которые не нужны, когда Activity не видна пользователю.

Добавлю логирование в метод onStop().

override fun onStop() {
    super.onStop()
    Log.i("!!!", "${this.componentName.shortClassName} Выполняется метод onStop()")
}

Для демонстрации его работы запускаю приложение, перехожу во вторую Активити и сворачиваю приложение. При сворачивании вижу по логам, как сначала вызывается onPause(), затем onStop(). Активити при этом не уничтожается.

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

При повторном открытии свернутого приложения видим по логам, как открывается наша SecondDemoActivity. И последовательно вызываются методы onStart() и onResume(). Все отрабатывает корректно.

Метод onDestroy(): Полное завершение Activity и освобождение всех ресурсов

Наконец, метод onDestroy() вызывается перед тем, как Activity полностью уничтожается системой. Этот метод позволяет освободить все оставшиеся ресурсы, отключить слушатели и завершить все операции, связанные с Activity. Добавляю логирование.

В методе onDestroy() также необходимо очищать ссылки на объекты, чтобы предотвратить утечки памяти. Например, если вы используете View Binding, нужно обнулить ссылку на биндинг. Об этом говорится в официальной документации на примере метода ЖЦ Фрагмента onDestroyView().

Воспроизведем полное закрытие приложения, где Activity принудительно уничтожится. Как видим в консоли поочередно вызвались методы onPause(), onStop() и onDestroy() перед самым уничтожением. При повторном запуске приложения и переходе на нашу Активити с логами видим весь процесс создания и отображения: onCreate(), onStart() и onResume().

Итого Активити может уничтожиться, если:

пользователь принудительно закрыл приложение,
система уничтожила приложение в фоне из-за нехватки ресурсов,
вы самостоятельно прописали и вызвали метод finish().

Заключение

Вот таким образом мы прошлись по всем основным методам жизненного цикла Activity. Теперь стало понятнее в какой момент состояния они вызываются системой.

Подытожим. Эти методы созданы, чтобы разработчики могли их переопределять для управления поведением приложения. Зачем это нужно?

Во-первых, чтобы достичь ожидаемого поведения. Например, все же помнят что будет, если свернуть ютубчик или аудиоплеер VK в их бесплатных версиях? Наступает тишина.
Во-вторых, разработчик обязан думать о ресурсах процессора и об аккумуляторе.

Важно понять, что разработчик в системе Android лишь размещает свой код в колбеках активити и просит систему что-то сделать. А система уже решает когда уничтожить то или иное активити, если, например, потребуется освободить память.

И это конец. Теперь вы не просто знаете, что такое жизненный цикл Activity — вы понимаете, когда и зачем вызываются ключевые методы, какие задачи в них уместны, а какие — вредны.