Android метод который вызывается

Жизненный цикл приложения на 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() не обязательно будет вызываться, поэтому не полагайтесь на этот метод при реализации критическом логики.

Пример

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

Код для методов:

Читайте также:  Android studio layout heights

Запускайте проект и следите за сообщениями. Они будут всплывать в нужной последовательности, давая вам представление о жизненном цикле приложения. Также сообщения будут транслироваться в окно 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()

Источник

Жизненный цикл Activity

Основным компонентом Android-приложения является Activity, определяющая интерфейс окна. Пользователи выполняют определенные действия в приложении через Activity : делают фото/видео, отправляют письмо, отвечают на звонок и т.д. Для каждой активности создается окно с соответствующим пользовательским интерфейсом. Как правило, окно занимает весь экран, но может быть и меньше.

Но прежде чем говорить об активности, необходимо пару слов сказать об операциях. Система Android работает с операциями. Каждой операции соответствует определенное окно (активность) для представления пользовательского интерфейса.

Операции

Android приложение может включать несколько слабо связанных друг с другом операций, одна из которых является «главной» и выполняется при первом старте приложения. Любая из операций может стартовать другую для выполнения определенных действий. Каждый раз, когда запускается какая-либо операция, предыдущая останавливается, и система сохраняет новую операцию в стеке типа FIFO («first-in-first-out»), т.е. «последним пришел — первым вышел». После завершения пользователем определенных действий или нажатии кнопки «Назад», текущая операция удаляется из стека и уничтожается, а предыдущая операция возобновляет своё функционирование.

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

Несмотря на то, что операции могут относится к разным приложениям, Android поддерживает удобство работы пользователя, сохраняя обе операции в одной задаче. Задача — это коллекция операций, с которыми взаимодействует пользователь при выполнении определенного задания. Начальным местом для большинства задач является главный экран устройства. Когда пользователь нажимает на иконку главного экрана, то эта задача переходит на передний план. Если у приложения нет задач, т.е. приложение не использовалось, то создается новая задача и открывается «основная» операция этого приложения в качестве корневой операции в стеке. Операции упорядочены в стеке (стек переходов назад), в том порядке, в котором они открывались.

Каждая стартуемая операция помещается на вершину стека и получает фокус. Предыдущая операция остается в стеке, но её выполнение приостанавливается, и система «сохраняет» её текущее состояние (интерфейс). При нажатии кнопки «Назад», текущая операция удаляется из вершины стека (операция уничтожается) и возобновляется работа предыдущей операции с восстановлением предыдущего состояния её пользовательского интерфейса. Операции в стеке никогда не переупорядочиваются; выполняется только добавление операций в стек и удаление из него. Т.е. при запуске новой операции, она добавляются в стек, и удаляется из стека, когда пользователь выходит из неё. Таким образом, стек переходов работает по принципу «последним пришел — первым вышел».

Callback методы

Когда Android останавливает операцию по какой-либо причине (например, запуск новой операции), или возобновляет её работу, для уведомления об изменении состояния операции используются callback-методы обратного вызова жизненного цикла операции. Чтобы создать операцию, необходимо сначала создать активность Activity (или её подкласс). В активности можно переопределить (override) методы обратного вызова, которые вызывает система при переходе операции из одного состояния своего жизненного цикла в другое, например при создании, остановке, возобновлении или уничтожении операции. В callback-методах можно выполнить определенные действия, связанные с чтением и освобождением ресурсов.

Читайте также:  Тема для диплома android

Класс 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.

Источник

Оцените статью