Изучаем жизненный цикл активности и 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 вы можете использовать в любых удобных местах, чтобы посмотреть, как отработал код, результат которого не виден на экране. Так вы всегда можете проверить, что всё идёт по плану.
Источник
Жизненный цикл приложения на Android
Жизненный цикл приложения в Android жёстко контролируется системой и зависит от нужд пользователя, доступных ресурсов и т. д. Например, пользователь хочет запустить браузер. Решение о запуске приложения принимает система. Хотя последнее слово и остаётся за системой, она подчиняется определённым заданным и логическим правилам, позволяющим определить, можно ли загрузить, приостановить приложение или прекратить его работу. Если в данный момент пользователь работает с определённым окном, система даёт приоритет соответствующему приложению. И наоборот, если окно невидимо и система решает, что работу приложения необходимо остановить, чтобы мобилизовать дополнительные ресурсы, будет прекращена работа приложения, имеющего более низкий приоритет. В Android ресурсы более ограниченны, поэтому Android более жёстко контролирует работу приложений.
Основные методы жизненного цикла приложения
- protected void onCreate()
- protected void onStart()
- protected void onRestart()
- protected void onResume()
- protected void onPause()
- protected void onStop()
- protected void onDestroy()
У методов onCreate(), onStart(), onResume() вызов суперкласса должен происходить до вызова вашего кода. В методах onPause(), onStop(), onDestroy() суперкласс следует вызывать после вашего кода (не обращайте внимания на мои примеры).
onCreate()
Метод onCreate() вызывается при создании или перезапуска активности. Система может запускать и останавливать текущие окна в зависимости от происходящих событий. Внутри данного метода настраивают статический интерфейс активности. Инициализирует статические данные активности, связывают данные со списками и т.д. Связывает с необходимыми данными и ресурсами. Задаёт внешний вид через метод setContentView().
В этом методе загружайте пользовательский интерфейс, размещайте ссылки на свойства класса, связывайте данные с элементами управления, создавайте сервисы и потоки. Метод onCreate() принимает объект Bundle, содержащий состояние пользовательского интерфейса, сохранённое в последнем вызове обработчика onSaveInstanceState. Для восстановления графического интерфейса в его предыдущем состоянии нужно задействовать эту переменную: внутри onCreate() или переопределив метод onRestoreInstanceState().
Операции по инициализации, занимающие много времени, следует выполнять в фоновом процессе, а не с помощью метода onCreate(). В противном случае можно получить диалоговое окно ANR (Application Not Responding, приложение не отвечает).
В методе можно сделать проверку, запущено ли приложение впервые или восстановлено из памяти. Если значение переменной savedInstanceState будет null, приложение запускается первый раз:
А значение переменной currentBillTotal можно сохранить в методе onSaveInstanceState():
onStart()
За onCreate() всегда следует вызов onStart(), но перед onStart() не обязательно должен идти onCreate(), так как onStart() может вызываться и для возобновления работы приостановленного приложения (приложение останавливается методом onStop()). При вызове onStart() окно ещё не видно пользователю, но вскоре будет видно. Вызывается непосредственно перед тем, как активность становится видимой пользователю. Сопровождается вызовом метода onResume(), если активность получает передний план, или вызовом метода onStop(), если становится скрытой.
onResume()
Метод onResume() вызывается после onStart(), даже когда окно работает в приоритетном режиме и пользователь может его наблюдать. В этот момент пользователь взаимодействует с созданным вами окном. Приложение получает монопольные ресурсы. Запускает воспроизведение анимации, аудио и видео. Также может вызываться после onPause().
Имейте в виду, что система вызывает этот метод каждый раз, когда ваша активность идёт на переднем плане, в том числе, при первом создании. Таким образом, вы должны реализовать onResume() для инициализации компонентов, регистрации любых широковещательных приёмников или других процессов, которые вы освободили/приостановили в onPause() и выполнять любые другие инициализации, которые должны происходить, когда активность вновь активна.
Пытайтесь размещать относительно быстрый и легковесный код, чтобы ваше приложение оставалось отзывчивым при скрытии с экрана или выходе на передний план.
Вам не нужно перезагружать состояние пользовательского интерфейса внутри него, так как эти функции возложены на обработчики onCreate() и onRestoreInstanceState.
Например, после метода onPause(), в котором мы приостановили работу камеры (см. ниже) снова запускаем камеру:
onPause()
Когда пользователь решает перейти к работе с новым окном, система вызовет для прерываемого окна метод onPause(). По сути происходит свёртывание активности. Сохраняет незафиксированные данные. Деактивирует и выпускает монопольные ресурсы. Останавливает воспроизведение видео, аудио и анимацию. От onPause() можно перейти к вызову либо onResume(), либо onStop().
В этом методе необходимо остановить анимацию и другие действия, которые загружают процессор. Зафиксировать несохранённые данные, например, черновик письма, потому как после его выполнения работа активности может прерваться без предупреждения. Освободить системные ресурсы, например, обработку данных от GPS.
Пытайтесь размещать относительно быстрый и легковесный код, чтобы ваше приложение оставалось отзывчивым при скрытии с экрана или выходе на передний план.
Исходя из архитектуры своего приложения, вы также можете приостановить выполнение потоков, процессов или широковещательных приёмников, пока активность не появится на переднем плане.
Например, при работе с камерой метод используется следующим образом:
В тоже время вы не должны использовать onPause() для хранения пользовательских изменений (таких, как персональные данные, введённые в форму) для постоянного хранения. Исключение допускается, когда вы уверены, что пользователи ожидают изменения, которые будут автоматически сохранены (например, при составлении электронной почты). Тем не менее, вы должны избегать выполнения интенсивной работы в onPause(), таких как запись в базе данных, так как это может замедлить переход к следующей активности (вместо него вы должны выполнять тяжелую нагрузку во время операции отключения onStop()).
Когда активность приостановлена, то все компоненты сохраняются в памяти и при возобновления нет необходимости повторно инициализировать их.
onStop()
Метод onStop() вызывается, когда окно становится невидимым для пользователя. Это может произойти при её уничтожении, или если была запущена другая активность (существующая или новая), перекрывшая окно текущей активности. Всегда сопровождает любой вызов метода onRestart(), если активность возвращается, чтобы взаимодействовать с пользователем, или метода onDestroy(), если эта активность уничтожается.
Когда ваша активность останавливается, объекты активности хранятся в памяти и восстанавливаются, когда активность возобновляет свою работу. Вам не нужно повторно инициализировать компоненты, которые были созданы ранее. Кроме того, система отслеживает текущее состояние для каждого представления, поэтому, если пользователь введёт текст в текстовое поле, то его содержание сохраняется и вам не нужно сохранять и восстанавливать его.
Примечание: Даже если система закрыла вашу активность, когда она была остановлена, она по-прежнему сохраняет состояние объектов, таких как текст в EditText в специальном объекте Bundle (в виде ключ-значение) и восстанавливает их, если пользователь переходит обратно к тому же экземпляру активности.
В этом методе можно сделать сложные операции по сохранению данных: для приостановки сложной анимации, потоков, отслеживания показаний датчиков, запросов к GPS, таймеров, сервисов или других процессов, которые нужны исключительно для обновления пользовательского интерфейса. Нет смысла потреблять ресурсы (такты центрального процессора или сетевой трафик) для обновления интерфейса, в то время как он не виден на экране. Примените методы onStart() или onRestart() для возобновления или повторного запуска этих процессов, когда активность опять станет видимой.
При нехватке памяти система может уничтожить скрытую активность, минуя метод onStop() с вызовом метода onDestroy().
onRestart()
Если окно возвращается в приоритетный режим после вызова onStop(), то в этом случае вызывается метод onRestart(). Т.е. вызывается после того, как активность была остановлена и снова была запущена пользователем. Всегда сопровождается вызовом метода onStart().
onRestart предшествует вызовам метода onStart() (кроме самого первого). Используйте его для специальных действий, которые должны выполняться только при повторном запуске активности в рамках «полноценного» состояния.
onDestroy()
Метод вызывается по окончании работы активности, при вызове метода finish() или в случае, когда система уничтожает этот экземпляр активности для освобождения ресурсов. Эти два сценария уничтожения можно определить вызовом метода isFinishing(). Вызывается перед уничтожением активности. Это последний запрос, который получает активность от системы. Если определённое окно находится в верхней позиции в стеке, но невидимо пользователю и система решает завершить это окно, вызывается метод onDestroy(). В этом случае метод удаляет все статические данные активности. Отдаёт все используемые ресурсы.
Так как все необходимые операции по освобождению ресурсов вы сделали в методе onStop(), то в этом методе вы можете подстраховаться и проверить ещё раз все неосвобождённые ресурсы.
На практике вам чаще всего придется сталкиваться с методами onCreate(), onResume() и onPause(). Метод onCreate() будет вызываться при создании пользовательского интерфейса для работы с окном. Данный метод позволит вам связывать данные с компонентами и подключать обработчики событий к компонентам пользовательского интерфейса. При помощи onPause() вы сможете сохранить важную информацию в базе данных вашего приложения. Это последний безопасный метод, который будет вызываться перед тем, как система завершит работу приложения. Метод onDestroy() не обязательно будет вызываться, поэтому не полагайтесь на этот метод при реализации критическом логики.
Пример
Для наглядности создадим пример, где для каждого метода жизненного цикла подготовим всплывающее сообщение, а также для подстраховки будем вести запись в журнале. Мы сможем воочию увидеть весь жизненный цикл.
Код для методов:
Запускайте проект и следите за сообщениями. Они будут всплывать в нужной последовательности, давая вам представление о жизненном цикле приложения. Также сообщения будут транслироваться в окно logcat на вкладке 6.Android в студии. Обратите внимание на следующий момент. Когда ваше приложение запущено, то нажмите на первую кнопку, чтобы изменить текст в TextView. Затем нажмите кнопку «Home» (не Back!), чтобы попасть на Домашний экран. После чего снова запустите ваше приложение. Вы увидите, что приложение не вызывает метод onCreate(), а текст в TextView будет свидетельствовать, что приложение не было закрыто, а только свёрнуто. Это очень важный момент, который нужно понять. Понимание этих вещей поможет вам правильно выстраивать логику приложения.
Памятка
Нажимаем кнопку Назад для выхода из приложения
Нажата кнопка Домой
После нажатия кнопки Домой, когда приложение запущено из списка недавно открытых приложений или через значок
Когда запускается другое приложение из области уведомлений или открывается приложение Настройки
Нажата кнопка Назад в другом приложении или в Настройках и ваше приложение стало снова видимым.
Открывается диалоговое окно
Диалоговое окно закрывается
Кто-то звонит на телефон
Пользователь отвечает на звонок
Экран телефона гаснет
Экран снова включён
На китайских планшетах иногда наблюдал, когда какие-то методы не срабатывали.
При повороте активность проходит через цепочку различных состояний. Порядок следующий.
onPause()
onStop()
onDestroy()
onCreate()
onStart()
onResume()
Порядок вызовов
После onCreate() — onStart()
После onRestart() — onStart()
После onStart() — onResume() или onStop()
После onResume() — onPause()
После onPause() — onResume() или onStop()
После onStop() — onRestart() или onDestroy()
Источник