Изучаем жизненный цикл активности и Logcat
Жизненный цикл активности — это важная тема, о которой часто любят спрашивать на собеседованиях. Следует разобраться, как живёт приложение, чтобы не было мучительно больно. На самом деле об этом следовало поговорить в самом начале курса, но ничего страшного, познакомимся сейчас. Пример написан с использованием Kotlin, но код достаточно простой и вам не составит труда написать такой же код на Java.
Прежде чем изучать жизненный цикл, познакомимся с бревенчатым котом Logcat.
У английского слова log есть несколько значений. В айтишной среде слово используется в качестве регистрационного журнала — смотреть логи, т.е. смотреть записи событий на сервере, в системе и т.д.
Также log имеет другое обычное значение — бревно. Следовательно, logcat можно перевести как бревенчатый кот, чтобы это не значило. Слово «бревно» обыгрывается в другой библиотеке Timber, который является продвинутым вариантом Logcat. «Timber» переводится как лесозаготовки, брус — т.е. уже обработанное бревно.
Начнём с самого простого. Вы уже привыкли, что у активности есть метод onCreate(), в котором мы обычно пишем код для инициализации компонентов и что-то ещё. Это метод жизненного цикла активности и он явно присутствует в нашем коде.
Но существуют и другие методы жизненного цикла. Их немного и они довольно часто используются, поэтому со временем вы их запомните наизусть. Сейчас следует понять, что эти методы вызываются в любом случае, даже если вы их явно не указали в своём коде. А зачем же они тогда нужны, если мы их не видим? А нужны для тех случаев, когда нам нужно воспользоваться ими в своих целях.
Возьмём метод onStart(). Он вызывается после onCreate(). Как в этом убедиться? Здесь нам поможет специально обученный кот Logсat (логичный кот), вкладку которого можно увидеть в нижней части студии. А пока сразу после метода onCreate() начинаем печатать название метода onStart(). Четырёх символов вполне достаточно, чтобы увидеть нужный метод и нажать Enter и получить заготовку.
В заготовку вставляем код, который будет обрабатываться логичным котом.
Подробнее о методах Log можно почитать в отдельно статье. Для большинства случае достаточно запомнить одну конструкцию с методом i (information), в котором указывают два строковых параметра. В первом параметре обычно указывают имя класса, а во втором — пояснение о событии, за которым мы наблюдаем. Если проект сложный и состоит из множества активностей, то первый параметр поможет быстро понять, откуда пришло сообщение.
Добавим аналогичный вызов в метод onCreate().
Запустим приложение (желательно в эмуляторе), откроем вкладку Logсat и установим наблюдение. В окне Logcat будет слишком много сообщений, которые будут нам мешать. Когда смотришь на бесконечный поток сообщений с какими-то веб-адресами и прочими записями, создаётся впечатление, что студия сливает всю информацию о банковских счетах, семейном положении, недвижимости в ЦРУ, ФБР, ФСБ, КГБ, Моссад одновременно. Говорят, что у котов усы (вибриссы) служат антеннами для связи с космосом. Не удивлюсь, если и эти пушистые засранцы передают информацию о своём хозяине и поток информации также льётся такой же бесконечной лентой. Когда коты решат захватить мир, у человечества не будет шансов.
Когда чувство паранойи немного отпустит, продолжим работу. Чтобы сократить число мешающих сообщений, выберите на вкладке пункт Show only selected application. Также следите, чтобы на второй вкладке отображалось название пакета вашего приложения. Дальше можно сократить число сообщений, если выбрать в другой вкладке пункт Info вместо Verbose. И наконец, в строке поиска можно ввести строку I/Main (если недостаточно, до вводите больше символов, вплоть до I/MainActivity), чтобы отсечь вообще всё лишнее. Теперь ничего нам не будет мешать.
Мы видим, что сначала был вызван метод onCreate(), затем onStart().
Перед записью идёт временная метка (дата, время). Можете иногда смотреть на эти показания, если вам интересно.
Не закрывая приложение, поверните устройство (в эмуляторе есть специальные значки для поворота) и наблюдайте за сообщениями в Logcat. Вы снова увидите пару строк, как при запуске приложения.
Наверное, вы уже подумали, что onStart() всегда вызывается после onCreate(). Рано успокаиваться. Не закрывая приложение, попробуйте вызвать другое приложение, которое бы закрыло ваше приложение. Это можно сделать следующим способом. Сверните приложение через среднюю кнопку навигации, запустите любое приложение, закройте запущенное приложение, через правую кнопку навигации откройте список недавно запущенных приложений и запустите своё приложение. Если посмотреть на сообщения, то увидите, что появится только строка «onStart() called», а строка «onCreate() called» не появится.
Следует запомнить: за onCreate() всегда следует вызов onStart(), но перед onStart() не обязательно должен идти onCreate(), так как onStart() может вызываться и для возобновления работы приостановленного приложения (приложение останавливается методом onStop()). При вызове onStart() окно ещё не видно пользователю, но вскоре будет видно.
Когда это может пригодиться? Допустим, мы используем датчик освещения. Его можно зарегистрировать в onStart(), так как он всегда будет вызван после onCreate(). Если приложение временно приостановлено, мы снимаем регистрацию датчика для экономии ресурсов, а при возобновлении работы снова включаем датчик. Такой подход позволяет грамотно распределять ресурсы приложения.
Настало время познакомиться с другими методами жизненного цикла. Для удобства мы повторим прошлый манёвр и добавим вызов сообщений в Logcat.
Мы получили заготовку и теперь можем наблюдать, как ведёт себя приложение в разных ситуациях — при вращении, закрытии, паузе и т.д. Далее следует изучить закономерности, в каком порядке методы жизненного цикла вызываются и использовать в своих целях. Описание методов и графики есть в отдельной статье.
Жизненный цикл есть не только у активности, но и у фрагментов. Частично эти циклы совпадают, но есть и различия. Используя методику, изложенную в стаье, вы можете самостоятельно проследить за жизненным циклом фрагмента и использовать в собственных целях.
Сообщения Logcat вы можете использовать в любых удобных местах, чтобы посмотреть, как отработал код, результат которого не виден на экране. Так вы всегда можете проверить, что всё идёт по плану.
Источник
Жизненный цикл Activity
Основным компонентом Android-приложения является Activity, определяющая интерфейс окна. Пользователи выполняют определенные действия в приложении через Activity : делают фото/видео, отправляют письмо, отвечают на звонок и т.д. Для каждой активности создается окно с соответствующим пользовательским интерфейсом. Как правило, окно занимает весь экран, но может быть и меньше.
Но прежде чем говорить об активности, необходимо пару слов сказать об операциях. Система Android работает с операциями. Каждой операции соответствует определенное окно (активность) для представления пользовательского интерфейса.
Операции
Android приложение может включать несколько слабо связанных друг с другом операций, одна из которых является «главной» и выполняется при первом старте приложения. Любая из операций может стартовать другую для выполнения определенных действий. Каждый раз, когда запускается какая-либо операция, предыдущая останавливается, и система сохраняет новую операцию в стеке типа FIFO («first-in-first-out»), т.е. «последним пришел — первым вышел». После завершения пользователем определенных действий или нажатии кнопки «Назад», текущая операция удаляется из стека и уничтожается, а предыдущая операция возобновляет своё функционирование.
Операция может даже стартовать операции в других приложениях на устройстве. Например, работу с почтой могут выполнять несколько приложений. Одно из приложений подготавливает информацию для отправки и определяет адресата/ов. При выполнении команды отправки стартует операция другого приложения. При этом действие отправляемой операции приостанавливается. После отправки сообщения первое приложение возобновляет работу операции, и все выглядит так, будто операция отправки электронной почты является частью первого приложения.
Несмотря на то, что операции могут относится к разным приложениям, Android поддерживает удобство работы пользователя, сохраняя обе операции в одной задаче. Задача — это коллекция операций, с которыми взаимодействует пользователь при выполнении определенного задания. Начальным местом для большинства задач является главный экран устройства. Когда пользователь нажимает на иконку главного экрана, то эта задача переходит на передний план. Если у приложения нет задач, т.е. приложение не использовалось, то создается новая задача и открывается «основная» операция этого приложения в качестве корневой операции в стеке. Операции упорядочены в стеке (стек переходов назад), в том порядке, в котором они открывались.
Каждая стартуемая операция помещается на вершину стека и получает фокус. Предыдущая операция остается в стеке, но её выполнение приостанавливается, и система «сохраняет» её текущее состояние (интерфейс). При нажатии кнопки «Назад», текущая операция удаляется из вершины стека (операция уничтожается) и возобновляется работа предыдущей операции с восстановлением предыдущего состояния её пользовательского интерфейса. Операции в стеке никогда не переупорядочиваются; выполняется только добавление операций в стек и удаление из него. Т.е. при запуске новой операции, она добавляются в стек, и удаляется из стека, когда пользователь выходит из неё. Таким образом, стек переходов работает по принципу «последним пришел — первым вышел».
Callback методы
Когда Android останавливает операцию по какой-либо причине (например, запуск новой операции), или возобновляет её работу, для уведомления об изменении состояния операции используются callback-методы обратного вызова жизненного цикла операции. Чтобы создать операцию, необходимо сначала создать активность Activity (или её подкласс). В активности можно переопределить (override) методы обратного вызова, которые вызывает система при переходе операции из одного состояния своего жизненного цикла в другое, например при создании, остановке, возобновлении или уничтожении операции. В callback-методах можно выполнить определенные действия, связанные с чтением и освобождением ресурсов.
Класс Activity имплементирует Callback-методы представленные в следующей таблице :
Методы обратного вызова Activity
| Метод | Описание |
|---|---|
| onCreate() | метод вызывается при первом создании Activity |
| onStart() | метод вызывается перед тем, как интерфейс Activity будет открыт пользователю |
| onResume() | метод вызывается перед предоставлением доступа пользователю к активности |
| onPause() | метод вызывается перед открытием другой Activity |
| onStop() | метод вызывается после удаления интерфейс Activity с экрана устройства |
| onDestroy() | метод вызывается перед уничтожением Activity |
Как видно из описания в таблице callback-методы не вызывают смену состояния активности. Наоборот, при смене состояния Activity система вызывает эти методы, чтобы можно было бы во-время реагировать на это программным способом. Схематично жизненный цикл операции представлен на следующем рисунке, который позаимствован со страницы описания Операций android-приложений.
onCreate
Метод приложения onCreate необходимо переопределить, поскольку система вызывает его при создании активности. В этом методе вызывается setContentView(), определяющий шаблон layout пользовательского интерфейса активности. В реализации метода необходимо инициализировать переменные и загрузить ресурсы, связать данные с элементами управления. Длительные инициализации следует выполнять в фоновом процессе, а не в методе onCreate, поскольку система может вызвать диалоговое окно ANR (Application Not Responding, приложение не отвечает).
В качестве параметра метод onCreate принимает объект Bundle, содержащий состояние пользовательского интерфейса последнего вызова обработчика onSaveInstanceState. Для восстановления интерфейса в его предыдущем состоянии необходимо использовать эту переменную внутри onCreate() или переопределить метод onRestoreInstanceState().
onStart
Метод onStart вызывается либо при создании активности, либо перед возобновлением работы приостановленного приложения. При вызове данного метода интерфейс приложения еще не виден на экране.
onResume
Метод onResume() вызывается после метода onStart(), когда пользователь взаимодействует с окном и приложение получает монопольные ресурсы. Помните, что система вызывает данный метод каждый раз, когда активность переходит на передний план. Таким образом, метод onResume() можно использовать для инициализации компонентов, регистрации любых процессов, которые были освобождены/приостановлены в методе onPause() и выполнить любые другие инициализации, когда Activity вновь активна.
Старайтесь фомрировать относительно быстрый и легковесный код, чтобы приложение было «отзывчивым» при скрытии или появлении на экране.
onPause
При открытии/восстановлении новой/другой активности вызывется метод onPause текущей активности. По сути, если вызывается метод onPause, то происходит свёртывание текущей активности. И поскольку пользователь может назад не вернуться, то обычно именно в этом методе следует сохранить изменения, деактивировать и отпустить монопольные ресурсы, остановить воспроизведение видео, аудио, анимацию и обработку данных от GPS. Исходя из архитектуры своего приложения, можно также приостановить выполнение потоков пока активность вновь не появится на переднем плане.
Старайтесь формировать относительно быстрый и легковесный код, чтобы приложение оставалось отзывчивым при скрытии с экрана или выходе на передний план.
onStop
Когда окно становится невидимым на устройстве вызывается метод onStop. Это может произойти при удалении активности или при старте другой активности, перекрывающей окно текущей. При остановке активности её объекты сохраняются в памяти. Система отслеживает текущее состояние для каждого компонента (View). Поэтому, если пользователь ввёл какой-либо текст в текстовое поле, то его содержание не потеряется и, при восстановлении работы активности, этот текст будет восстанавлен.
Примечание: при закрытии/останове активности состояние объектов хранится в специальном объекте типа Bundle в виде ключ-значение; значения компонентов восстанавливаются при восстановлении состояния активности.
В методе onStop() можно выполнить тяжеловесные операции, связанные с сохранением данных при приостановке сложной анимации, отслеживании показаний датчиков, запросов к GPS, таймеров, сервисов или других процессов, которые нужны исключительно для восстановления пользовательского интерфейса.
При нехватке памяти система может уничтожить скрытую активность вызовом метода onDestroy(), игнорируя метод onStop().
onDestroy
Метод onDestroy вызывается перед завершением работы активности. Это последний вызов системой метода активности перед ее уничтожением. В данном методе, при необходимости, следует проверить сохранение и освобожение используемых ресурсов.
Пример
Для наглядности вышеизложенного создадим пример с переопределением Callback-методов, в которых выведем в журнал Logcat соответствующие сообщения с тегом STATE.
Стартуйте пример и следите за сообщениями. Они будут представлены в определенной последовательности вызовов Сallback-методов в виде сообщений на вкладке Logcat.
Протоколирование
Ниже представлены выполнения определенных действий, сопровождаемых выводом соответствующих сообщений в Logcat.
Источник
