Ключевым компонентом для создания визуального интерфейса в приложении Android является activity (активность). Нередко activity ассоциируется с отдельным экраном или окном приложения, а переключение между окнами будет происходить как перемещение от одной activity к другой. Приложение может иметь одну или несколько activity. Например, в прошлой теме работа приложения начиналась с класса MainActivity:
Все объекты activity представляют собой объекты класса android.app.Activity , которая содержит базовую функциональность для всех activity. В приложении из прошлой темы мы напрямую с этим классом не работали, а MainActivity наследовалась от класса AppCompatActivity . Однако сам класс AppCompatActivity, хоть и не напрямую, наследуется от базового класса Activity.
Жизненный цикл приложения
Все приложения Android имеют строго определенный системой жизненный цикл. При запуске пользователем приложения система дает этому приложению высокий приоритет. Каждое приложение запускается в виде отдельного процесса, что позволяет системе давать одним процессам более высокой приоритет, в отличие от других. Благодаря этому, например, при работе с одними приложениями не блокировать входящие звонки. После прекращения работы с приложением, система освобождает все связанные ресурсы и переводит приложение в разряд низкоприоритетного и закрывает его.
Все объекты activity, которые есть в приложении, управляются системой в виде стека activity, который называется back stack . При запуске новой activity она помещается поверх стека и выводится на экран устройства, пока не появится новая activity. Когда текущая activity заканчивает свою работу (например, пользователь уходит из приложения), то она удаляется из стека, и возобновляет работу та activity, которая ранее была второй в стеке.
После запуска activity проходит через ряд событий, которые обрабатываются системой и для обработки которых существует ряд обратных вызовов:
Схематично взаимосвязь между всеми этими обратными вызовами можно представить следующим образом
onCreate()
onCreate – первый метод, с которого начинается выполнение activity. В этом методе activity переходит в состояние Created. Этот метод обязательно должен быть определен в классе activity. В нем производится первоначальная настройка activity. В частности, создаются объекты визуального интерфейса. Этот метод получает объект Bundle , который содержит прежнее состояние activity, если оно было сохранено. Если activity заново создается, то данный объект имеет значение null. Если же activity уже ранее была создана, но находилась в приостановленном состоянии, то bundle содержит связанную с activity информацию.
onStart
В методе onStart() осуществляется подготовка к выводу activity на экран устройства. Как правило, этот метод не требует переопределения, а всю работу производит встроенный код. После завершения работы метода activity отображается на экране, вызывается метод onResume , а activity переходит в состояние Resumed.
onRestoreInstanceState
После завершения метода onStart() вызывается метод onRestoreInstanceState , который призван восстанавливать сохраненное состояние из объекта Bundle, который передается в качестве параметра. Но следует учитывать, что этот метод вызывается только тогда, когда Bundle не равен null и содержит ранее сохраненное состояние. Так, при первом запуске приложения этот объект Bundle будет иметь значение null, поэтому и метод onRestoreInstanceState не будет вызываться.
onResume
А при вызове метода onResume activity переходит в состояние Resumed, а пользователь может с ней взаимодействовать. И собственно activity остается в этом состоянии, пока она не потеряет фокус, например, вследствии переключения на другую activity или просто из-за выключения экрана устройства.
onPause
Если пользователь решит перейти к другой activity, то система вызывает метод onPause . В этом методе можно освобождать используемые ресурсы, приостанавливать процессы, например, воспроизведение аудио, анимаций, останавливать работу камеры (если она используется) и т.д., чтобы они меньше сказывались на производительность системы.
Но надо учитывать, что на работу данного метода отводится очень мало времени, поэтому не стоит здесь сохранять какие-то данные, особенно если при этом требуется обращение к сети, например, отправка данных по интернету, или обращение к базе данных.
После выполнения этого метода activity становится невидимой, не отображается на экране, но она все еще активна. И если пользователь решит вернуться к этой activity, то система вызовет снова метод onResume , и activity снова появится на экране.
Другой вариант работы может возникнуть, если вдруг система видит, что для работы активных приложений необходимо больше памяти. И система может сама завершить полностью работу activity, которая невидима и находится в фоне. Либо пользователь может нажать на кнопку Back (Назад). В этом случае у activity вызывается метод onStop .
onSaveInstanceState
Метод onSaveInstanceState вызывается после метода onPause() , но до вызова onStop() . В onSaveInstanceState производится сохранение состояния приложения в передаваемый в качестве параметра объект Bundle.
onStop
В этом методе activity переходит в состояние Stopped. В методе onStop следует особождать используемые ресурсы, которые не нужны пользователю, когда он не взаимодействует с activity. Здесь также можно сохранять данные, например, в базу данных.
При этом во время состояния Stopped activity остается в памяти устройства, сохраняется состояние всех элементов интерфейса. К примеру, если в текстовое поле EditText был введен какой-то текст, то после возобновления работы activity и перехода ее в состояние Resumed мы вновь увидим в текстовом поле ранее введенный текст.
Если после вызова метода onStop пользователь решит вернуться к прежней activity, тогда система вызовет метод onRestart . Если же activity вовсе завершила свою работу, например, из-за закрытия приложения, то вызывается метод onDestroy() .
onDestroy
Ну и завершается работа активности вызовом метода onDestroy , который возникает либо, если система решит убить activity, либо при вызове метода finish() .
Также следует отметить, что при изменении ориентации экрана система завершает activity и затем создает ее заново, вызывая метод onCreate .
В целом переход между состояниями activity можно выразить следующей схемой:
Расмотрим несколько ситуаций. Если мы работаем с Activity и затем переключаемся на другое приложение, либо нажимаем на кнопку Home, то у Activity вызывается следующая цепочка методов: onPause -> onStop . Activity оказывается в состоянии Stopped. Если пользователь решит вернуться к Activity, то вызывается следующая цепочка методов: onRestart -> onStart -> onResume .
Другая ситуация, если пользователь нажимает на кнопку Back (Назад), то вызывается следующая цепочка onPause -> onStop -> onDestroy . В результате Activity уничтожается. Если мы вдруг захотим вернуться к Activity через диспетчер задач или заново открыв приложение, то activity будет заново пересоздаваться через методы onCreate -> onStart -> onResume
Управление жизненным циклом
Мы можем управлять этими событиями жизненного цикла, переопределив соответствующие методы. Для этого возьмем из прошлой главы класс MainActivity и изменим его следующим образом:
Для логгирования событий здесь используется класс android.util.Log .
В данном случае обрабатываются все ключевые методы жизненного цикла. Вся обработка сведена к вызову метода Log.d() , в который передается TAG – случайное строковое значение и строка, которая выводится в консоли logcat внизу Andro >View -> Tool Windows -> Android Monitor .
И при запуске приложения мы сможем увидеть в окне logcat отладочную информацию, которая определяется в методах жизненного цикла activity:
Основным компонентом Android-приложения является Activity, определяющая интерфейс окна. Пользователи выполняют определенные действия в приложении через Activity : делают фото/видео, отправляют письмо, отвечают на звонок и т.д. Для каждой активности создается окно с соответствующим пользовательским интерфейсом. Как правило, окно занимает весь экран, но может быть и меньше.
Но прежде чем говорить об активности, необходимо пару слов сказать об операциях. Система Android работает с операциями. Каждой операции соответствует определенное окно (активность) для представления пользовательского интерфейса.
Операции
Android приложение может включать несколько слабо связанных друг с другом операций, одна из которых является «главной» и выполняется при первом старте приложения. Любая из операций может стартовать другую для выполнения определенных действий. Каждый раз, когда запускается какая-либо операция, предыдущая останавливается, и система сохраняет новую операцию в стеке типа FIFO («first-in-first-out»), т.е. «последним пришел — первым вышел». После завершения пользователем определенных действий или нажатии кнопки «Назад», текущая операция удаляется из стека и уничтожается, а предыдущая операция возобновляет своё функционирование.
Операция может даже стартовать операции в других приложениях на устройстве. Например, работу с почтой могут выполнять несколько приложений. Одно из приложений подготавливает информацию для отправки и определяет адресата/ов. При выполнении команды отправки стартует операция другого приложения. При этом действие отправляемой операции приостанавливается. После отправки сообщения первое приложение возобновляет работу операции, и все выглядит так, будто операция отправки электронной почты является частью первого приложения.
Несмотря на то, что операции могут относится к разным приложениям, Android поддерживает удобство работы пользователя, сохраняя обе операции в одной задаче. Задача — это коллекция операций, с которыми взаимодействует пользователь при выполнении определенного задания. Начальным местом для большинства задач является главный экран устройства. Когда пользователь нажимает на иконку главного экрана, то эта задача переходит на передний план. Если у приложения нет задач, т.е. приложение не использовалось, то создается новая задача и открывается «основная» операция этого приложения в качестве корневой операции в стеке. Операции упорядочены в стеке (стек переходов назад), в том порядке, в котором они открывались.
Каждая стартуемая операция помещается на вершину стека и получает фокус. Предыдущая операция остается в стеке, но её выполнение приостанавливается, и система «сохраняет» её текущее состояние (интерфейс). При нажатии кнопки «Назад», текущая операция удаляется из вершины стека (операция уничтожается) и возобновляется работа предыдущей операции с восстановлением предыдущего состояния её пользовательского интерфейса. Операции в стеке никогда не переупорядочиваются; выполняется только добавление операций в стек и удаление из него. Т.е. при запуске новой операции, она добавляются в стек, и удаляется из стека, когда пользователь выходит из неё. Таким образом, стек переходов работает по принципу «последним пришел — первым вышел».
Callback методы
Когда Android останавливает операцию по какой-либо причине (например, запуск новой операции), или возобновляет её работу, для уведомления об изменении состояния операции используются callback-методы обратного вызова жизненного цикла операции. Чтобы создать операцию, необходимо сначала создать активность Activity (или её подкласс). В активности можно переопределить (override) методы обратного вызова, которые вызывает система при переходе операции из одного состояния своего жизненного цикла в другое, например при создании, остановке, возобновлении или уничтожении операции. В callback-методах можно выполнить определенные действия, связанные с чтением и освобождением ресурсов.
Класс Activity имплементирует Callback-методы представленные в следующей таблице :
Методы обратного вызова Activity
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.
Жизненный цикл приложения в 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()
Метод 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 будет свидетельствовать, что приложение не было закрыто, а только свёрнуто. Это очень важный момент, который нужно понять. Понимание этих вещей поможет вам правильно выстраивать логику приложения.
Памятка
Нажимаем кнопку Назад для выхода из приложения
Нажата кнопка Домой
После нажатия кнопки Домой, когда приложение запущено из списка недавно открытых приложений или через значок
Когда запускается другое приложение из области уведомлений или открывается приложение Настройки
Нажата кнопка Назад в другом приложении или в Настройках и ваше приложение стало снова видимым.
Открывается диалоговое окно
Диалоговое окно закрывается
Кто-то звонит на телефон
Пользователь отвечает на звонок
Экран телефона гаснет
Экран снова включён
На китайских планшетах иногда наблюдал, когда какие-то методы не срабатывали.
При повороте активность проходит через цепочку различных состояний. Порядок следующий.
