Что происходит при запуске android приложения

Обновлено: 23.01.2025

Недавно я провел исследование о main() методе в Java и то, как он служит точкой входа для любого приложения Java. Это заставило меня задуматься, а как насчет Android-приложений? Есть ли у них основной метод? Как они загружаются? Что происходит за кулисами до выполнения onCreate()? Майкл Бэйли очень подробно рассказал о том, как работает Main Thread, так что это быстрый обзор его доклада плюс дополнительная информация из Android Open Source Project (AOSP).

В этой статье мы рассмотрим:

Что происходит при запуске приложения

При запуске любого приложения, многое происходит глубоко внутри на уровне ядра, например начальная загрузка Zygote, загрузка классов в JVM, а для JVM — найти основной метод static void main(String args []) и вызывать его. В случае Android JVM находит основной метод main() в ActivityThread. Затем он вызывает main(), после чего ядро передает управление вашему приложению. Итак, мы нашли точку входа — ActivityThread, но прежде чем подробно изучить это, давайте посмотрим на дорожную карту процесса, чтобы визуализировать всю операцию.

1 Схема запуска приложения

Между вызовом метода main() и onCreate() в нашем MainActivity примерно 15 шагов, и в этой статье мы пройдем по ним. На рисунке 1 изображена общая схема запуска приложения, показывающая различные классы взаимодействия сверху и соответствующую цепочку методов. Шаги пронумерованы, и когда я обращаюсь к ним, я буду использовать следующие обозначения Process3 или Process14

Рисунок 1: Схема запуска приложения по шагам от вызова main() до onCreate() в MainActivity

2. Класс ActivityThread

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

Рисунок 2: Метод main() в ActivityThread, который служит точкой входа для запуска вашего приложения.

Как видно в коде: метод main() выполняет три важных дела:

1. Подготавливает основной Looper (MainLooper) (Process 2)
2. Настройка Handler'a (Process 4)
3. Вызов метода Looper.loop() в главном потоке (MainThread) (Process 6)

2.1 Подготовка main looper (Process 2–3)

Основной Looper задается вызовом Looper.prepareMainLooper() (см. Строку 8 в коде). Это отмечает текущий случайный поток, который выполняет всю работу по вызову метода main() в качестве основного потока приложений. Именно так и именно здесь определяется знаменитый главный поток для приложения в Android!

2.2 Вызов Handler'a (Process 4-5)

Внутри класса ActivityThread существует приватный внутренний класс H, да-да, все верно, просто H, который наследуется от класса Handler (см. рис. 4 и 7). В 12й строке экземпляр H-обработчика устанавливается как главный Handler потока. Что очень интересно знать о классе H, как вы сами увидите позже, это то, что он содержит более 50 определений состояния/событий, в которых может находиться ваше приложение, например LAUNCH_ACTIVITY, PAUSE_ACTIVITY, BIND_SERVICE и т.д.

2.3 Вызов метод loop() у Looper’а (Process 6–7)

Обратите внимание, что в строке 18, если выполнение кода пойдет дальше чем Looper.loop() в 17 строке вдруг и приложение выйдет из цикла, то будет брошено исключение RuntimeException. Это говорит о том, что метод loop() в идеале никогда преждевременно не заканчивается. Мы увидим как это в следущем разделе.

3. Бесконечный loop() в Looper'е (Process 7,8,9)

Рисунок 3: Код внутри метода loop() в классе Looper'e

4. Запуск MainActivity (Process 10 to 15)

Рисунок 4: Приватный внутренний класс H и его handleMessage() метод

Один из случаев (cases) включает в себя запуск активности (строка 11), что интересно, так это то, что этот метод предназначен для обработки около 50 случаев, которые варьируются от возобновления, приостановки, запуска Activity, привязки Service'ов, обработки Receiver'ов, предоставления предупреждений lowMemory или trimMemory, когда память устройства заполняется и т. д.

В case LAUNCH_ACTIVITY вызывается метод handleLaunchActivity(), как показано в строке 13, см Process11 на схеме. Затем этот метод вызывает другой метод, называемый performLaunchActivity(), который возвращает объект Activity (см. Рис. 5, строка 7).

Рисунок 5: Метод handleLaunchActivity() в котором создается Activity

Рисунок 6: Класс Instrumentation наконец запускает Activity

На данный момент ваша Activity загружена c множеством полезных переменных и методов, которые можно использовать для создания вашего нового удивительного приложения для Android! Все это благодаря ActivityThread, умной работе Handler'a и Looper'a, и огромному классу Activity в 7600 строк кода, который позволяет аттачить фрагменты, получить контекст и легко управлять View's — и много еще чего.

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

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

Обратите внимание: Диаграммы описывают поведение в Android P / Jetpack 1.0.

Диаграммы показывают сценарии поведения по умолчанию, если не указано иное.

Жизненный цикл одной активности

Сценарий 1: завершение и повторный запуск приложения

Источники

Этот простейший сценарий показывает, что происходит, когда приложение с одной активностью завершается и снова запускается пользователем:

Сценарий 1: приложение завершено и перезапущено

Управление состоянием

onSaveInstanceState() не вызывается (активность завершается, поэтому не нужно сохранять её состояние);
onCreate() не принимает Bundle, так как предыдущая активность завершилась и не требует восстановления.

Сценарий 2: переход пользователя из приложения

Источники

Нажатие кнопки «Home».
Переключение на другое приложение (через кнопку «Overview», ответ на уведомление, приём входящего вызова и т. п.).

Сценарий 2: пользователь покидает приложение

В этом случае система остановит активность, но не будет сразу же завершать её.

Управление состоянием

Когда активность входит в остановленное состояние, система вызывает onSaveInstanceState() для сохранения состояния приложения на случай, если она завершит процесс впоследствии.

4–5 декабря, Онлайн, Беcплатно

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

Сценарий 3: изменение конфигурации

Источники

Смена конфигурации, например поворот экрана.
Изменение размера окна в мультиоконном режиме.

Сценарий 3: поворот и другие изменения конфигурации

Управление состоянием

Изменения конфигурации вроде поворота и увеличения или уменьшения окна, должны позволять пользователям продолжать работу именно там, где они остановились:

предыдущая активность полностью разрушается, но её состояние сохраняется и передаётся новой;
в onCreate() и onRestoreInstanceState() передаётся один и тот же Bundle.

Сценарий 4: остановка приложения системой

Источники

Сценарий 4 — остановка приложения системой

Сценарий не относится к следующим случаям:

Диалоги в этом же приложении — показ AlertDialog или DialogFragment не приведёт к остановке активности.
Уведомления — пользователь, получающий уведомление или открывающий их панель, не остановит активность.

Навигация и стек переходов

Примечание Показанные друг напротив друга группы событий отрабатываются параллельно. Поток выполнения может переключиться с одной группы событий на другую в любой момент времени, поэтому порядок вызовов методов из параллельных групп не определён. Однако последовательный порядок вызовов методов внутри группы гарантирован. Следующие сценарии не применяются к активностям и задачам с кастомным режимом запуска или заданным контекстом задачи (task affinity). За более подробной информацией обратитесь к документации на Android Developers.

Сценарий 1: навигация между активностями

Cценарий 1: завершение и повторный запуск приложения

В этом сценарии при старте новой активности первая останавливается (но не разрушается), что похоже на переход пользователя из приложения (по кнопке «Home»).

После нажатия на кнопку «Back» вторая активность разрушается и завершается.

Управление состоянием

Заметьте, что onSaveInstanceState() вызывается, а onRestoreInstanceState() — нет. Если изменение конфигурации произойдёт в то время, когда вторая активность открыта, то первая разрушится и будет снова создана, когда получит фокус обратно. Вот почему сохранение состояния важно.

Если система убьёт процесс для освобождения ресурсов, будет иметь место другой сценарий, в котором состояние потребуется восстановить.

Сценарий 2: активности в стеке переходов и изменения конфигурации

Управление состоянием

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

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

Завершение процесса

Когда Android нуждается в ресурсах, он завершает фоновые приложения.

Сценарий 3: завершение процесса

Управление состоянием

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

Узнать больше можно здесь.

Жизненный цикл фрагментов

В этой части обсудим поведение прикреплённых к активности фрагментов. Не смущайтесь сценария с добавлением фрагмента в стек переходов назад (подробнее о транзакциях фрагментов и стеке переходов здесь).

Сценарий 1: запуск активности с фрагментом и её завершение

Гарантировано, что вызов onCreate() активности выполнится раньше соответствующих вызовов фрагментов. Однако противолежащие методы обратного вызова, такие как onStart() и onResume() , выполняются параллельно, и поэтому порядок их вызовов не определён. Например, система может выполнить метод onStart() активности перед методом onStart() фрагмента, но выполнить метод onResume() фрагмента перед методом onResume() активности.

Примечание Будьте осторожны при управлении потоками выполнения и избегайте состояния гонки.

Сценарий 2: поворот активности с фрагментом

Сценарий 2: поворот действия с фрагментом

Управление состоянием

Сохранение и восстановление фрагментов очень похоже на сохранение и восстановление активностей. Различие заключается в том, что у фрагментов нет метода onRestoreInstanceState() , но им доступен Bundle в методах onCreate() , onCreateView() и onActivityCreated() .

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

Сценарий 3: поворот активности с сохранённым фрагментом

После поворота фрагмент не разрушается и не воссоздаётся, потому что после пересоздания активности используется тот же экземпляр фрагмента — при этом в onActivityCreated() всё ещё доступен объект состояния.

Не рекомендуется применять сохраняемые фрагменты, если они не используются для сохранения данных между изменениями конфигурации (в не UI-фрагменте). Класс ViewModel из библиотеки Architecture Components внутри реализован именно так, но он предоставляет более простой API.

ViewModels, полупрозрачные активности и режимы запуска

Модели представления (ViewModels)

Жизненный цикл модели представления достаточно простой — она имеет всего один метод обратного вызова, который называется onCleared() . Тем не менее, для модели представления есть различие между активностью и фрагментом:

Различие между активностью и фрагментом

Стоит обратить внимание, что инициализация случается всякий раз, когда вы получаете ViewModel , что обычно происходит в onCreate() .

Полупрозрачные активности

Из названия понятно, что у полупрозрачной активности полупрозрачный фон (как правило, совсем прозрачный). Таким образом, пользователь видит, что находится под ней.

Когда к теме активности применяется свойство android:windowIsTranslucent , диаграмма немного меняется: фоновая активность никогда не останавливается (только входит в состояние паузы), так что она может продолжать получать обновления UI:

Сравнение обычной и полупрозрачной активностей

Также при возвращении обратно к задаче, обе активности восстанавливаются и запускаются, и только полупрозрачная возобновляется:

Новая полупрозрачная активность: выход из приложения и повторное открытие

Режимы запуска

Рекомендованный способ работы с задачами и стеками переходов в своей основе прост — вы должны следовать поведению по умолчанию. За подробной информацией обратитесь к статье.

Если вам действительно нужен режим SINGLE_TOP , вот диаграмма:

Для сравнения посмотрите на следующей диаграмме режим singleTask (но, скорее всего, вам не нужно его использовать):

Если вы используете Navigation Architecture из Jetpack, то получите выгоду от поддержки Single Top и автоматического искусственного стека переходов.

Ключевым компонентом для создания визуального интерфейса в приложении Android является activity (активность). Нередко activity ассоциируется с отдельным экраном или окном приложения, а переключение между окнами будет происходить как перемещение от одной activity к другой. Приложение может иметь одну или несколько activity. Например, при создании проекта с пустой Activity в проект по умолчанию добавляется один класс Activity - MainActivity, с которого и начинается работа приложения:

Все объекты activity представляют собой объекты класса android.app.Activity , которая содержит базовую функциональность для всех activity. В приложении из прошлой темы мы напрямую с этим классом не работали, а MainActivity наследовалась от класса AppCompatActivity . Однако сам класс AppCompatActivity, хоть и не напрямую, наследуется от базового класса Activity.

Жизненный цикл приложения

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

Все объекты activity, которые есть в приложении, управляются системой в виде стека activity, который называется back stack . При запуске новой activity она помещается поверх стека и выводится на экран устройства, пока не появится новая activity. Когда текущая activity заканчивает свою работу (например, пользователь уходит из приложения), то она удаляется из стека, и возобновляет работу та activity, которая ранее была второй в стеке.

После запуска activity проходит через ряд событий, которые обрабатываются системой и для обработки которых существует ряд обратных вызовов:

Схематично взаимосвязь между всеми этими обратными вызовами можно представить следующим образом

onCreate()

onCreate - первый метод, с которого начинается выполнение activity. В этом методе activity переходит в состояние Created. Этот метод обязательно должен быть определен в классе activity. В нем производится первоначальная настройка activity. В частности, создаются объекты визуального интерфейса. Этот метод получает объект Bundle , который содержит прежнее состояние activity, если оно было сохранено. Если activity заново создается, то данный объект имеет значение null. Если же activity уже ранее была создана, но находилась в приостановленном состоянии, то bundle содержит связанную с activity информацию.

После того, как метод onCreate() завершил выполнение, activity переходит в состояние Started , и и система вызывает метод onStart()

onStart

В методе onStart() осуществляется подготовка к выводу activity на экран устройства. Как правило, этот метод не требует переопределения, а всю работу производит встроенный код. После завершения работы метода activity отображается на экране, вызывается метод onResume , а activity переходит в состояние Resumed.

onResume

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

onPause

Если пользователь решит перейти к другой activity, то система вызывает метод onPause , а activity переходит в состояние Paused . В этом методе можно освобождать используемые ресурсы, приостанавливать процессы, например, воспроизведение аудио, анимаций, останавливать работу камеры (если она используется) и т.д., чтобы они меньше сказывались на производительность системы.

Но надо учитывать, что в этот состоянии activity по прежнему остается видимой на экране, и на работу данного метода отводится очень мало времени, поэтому не стоит здесь сохранять какие-то данные, особенно если при этом требуется обращение к сети, например, отправка данных по интернету, или обращение к базе данных - подобные действия лучше выполнять в методе onStop() .

После выполнения этого метода activity становится невидимой, не отображается на экране, но она все еще активна. И если пользователь решит вернуться к этой activity, то система вызовет снова метод onResume , и activity снова появится на экране.

onStop

В этом методе activity переходит в состояние Stopped. В этом состоянии activity полностью невидима. В методе onStop следует особождать используемые ресурсы, которые не нужны пользователю, когда он не взаимодействует с activity. Здесь также можно сохранять данные, например, в базу данных.

При этом во время состояния Stopped activity остается в памяти устройства, сохраняется состояние всех элементов интерфейса. К примеру, если в текстовое поле EditText был введен какой-то текст, то после возобновления работы activity и перехода ее в состояние Resumed мы вновь увидим в текстовом поле ранее введенный текст.

Если после вызова метода onStop пользователь решит вернуться к прежней activity, тогда система вызовет метод onRestart . Если же activity вовсе завершила свою работу, например, из-за закрытия приложения, то вызывается метод onDestroy() .

onDestroy

Ну и завершается работа activity вызовом метода onDestroy , который возникает либо, если система решит убить activity в силу конфигурационных причин (например, поворот экрана или при многоконном режиме), либо при вызове метода finish() .

Также следует отметить, что при изменении ориентации экрана система завершает activity и затем создает ее заново, вызывая метод onCreate .

В целом переход между состояниями activity можно выразить следующей схемой:

Расмотрим несколько ситуаций. Если мы работаем с Activity и затем переключаемся на другое приложение, либо нажимаем на кнопку Home, то у Activity вызывается следующая цепочка методов: onPause -> onStop . Activity оказывается в состоянии Stopped. Если пользователь решит вернуться к Activity, то вызывается следующая цепочка методов: onRestart -> onStart -> onResume .

Управление жизненным циклом

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

Для логгирования событий здесь используется класс android.util.Log .

В данном случае обрабатываются все ключевые методы жизненного цикла. Вся обработка сведена к вызову метода Log.d() , в который передается TAG - случайное строковое значение и строка, которая выводится в консоли Logcat в нижней части Android Studio, выполняя роль отладочной информации. Если эта консоль по умолчанию скрыта, то мы можем перейти к ней через пункт меню View -> Tool Windows -> Logcat .

И при запуске приложения мы сможем увидеть в окне Logcat отладочную информацию, которая определяется в методах жизненного цикла activity:

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

Пример

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

Памятка

Нажата кнопка Домой

После нажатия кнопки Домой, когда приложение запущено из списка недавно открытых приложений или через значок

Когда запускается другое приложение из области уведомлений или открывается приложение Настройки

Открывается диалоговое окно

Диалоговое окно закрывается

Кто-то звонит на телефон

Пользователь отвечает на звонок

Экран телефона гаснет

Экран снова включён

На китайских планшетах иногда наблюдал, когда какие-то методы не срабатывали.

При повороте активность проходит через цепочку различных состояний. Порядок следующий.

onPause()
onStop()
onDestroy()
onCreate()
onStart()
onResume()

Класс Acitvity является важнейшим компонентом Android-приложения, а способ запуска и компоновки является фундаментальной частью платформы Android. В отличие от парадигм программирования, где приложение запускается в методе main(), система Android инициирует код в экземпляре Activity, вызывая специальные коллбэки, которые соответствуют конкретным этапам жизненного цикла активности (подробнее о жизненном цикле активности будет сказано ниже).

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

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

Есть различные разновидности активностей, хотя все они так или иначе являются наследниками базового класса Activity. Например, если используется библиотека поддержки, то при создании нового проекта Android Studio генерирует класс MainActivity, который наследует от AppCompatAcitivty. Если посмотреть иерархию наследования, то в результате можно увидеть, что в начале этой иерархии будет находиться класс Activity.

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

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

Рассмотрим на примере, как добавить в приложение новую активность. Создадим в Android Studio новый пустой проект. По умолчанию, в приложении создаётся одна главная активность, называемая MainActivity. При этом в проекте происходят следующие действия.

Создаётся одноимённый класс MainActivity.java. В этом классе будет реализовываться вся работа активности, при создании в ней уже есть переопределённый метод onCreate() и загрузка разметки активности.

Как уже говорилось выше, метод setContentView() загружает разметку активности. Эта разметка берётся из XML-файла, который размещается в /res/layout. При создании проекта там уже находится сгенерированный файл activity_main.xml, идентификатор которого и передаётся в параметры setContentView(). Как правило, идентификатор идентичен названию файла. Если заглянуть в этот файл, то можно увидеть там TextView с надписью Hello World!, размещённое в центре экрана. Таким образом, то, что будет в коде этого файла, и увидит пользователь при запуске активности, для которой эта разметка установлена.

Как уже говорилось выше, одна из активностей в приложении должна быть главной. Поэтому внутри <activity> был автоматически добавлен интент-фильтр со следующими параметрами:

Вот всё, что нужно для того, чтобы создать активность. Подводя итог, можно сказать, что для создания активности Android Studio выполняет 3 шага:

Откроется окно, в котором будет предложено ввести название новой активности и название XML-файла разметки.

Жмём Finish и видим, что Android Studio добавила все необходимые файлы для активности.

Как можно было заметить, при создании активности в коде класса добавляется переопределённый метод onCreate(). Этот метод вызывается, когда активность начинает свою работу, и соответствует началу жизненного цикла активности.

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

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

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

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

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

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

Во время деинициализации наоборот нужно выполнить всю работу и только потом вызвать суперкласс:

onCreate()

Этот метод обратного вызова срабатывает, когда система создаёт активность. Его наличие обязательно, поскольку здесь выполняется первоначальная настройка активности. В этом методе активность переходит в состояние Created. В методе onCreate() нужно выполнять основную логику запуска, которая должна выполниться только один раз. Например, реализация onCreate() может привязать данные к спискам, ассоциировать активность с ViewModel и создать экземпляры некоторых переменных. Этот метод принимает в качестве параметра savedInstanceState, который представляет собой объект Bundle, содержащий ранее сохраненное состояние активности. Если активность ранее не существовала, значение объекта Bunde будет равно null.

После того, как onCreate() завершит выполнение, активность переходит в состояние Started и система следом вызывает onStart() и onResume().

onStart()

Когда активность переходит в состояние Started, система вызывает этот метод. Вызов onStart() делает активность видимой для пользователя, так как приложение готовится к переходу активности на передний план и становится интерактивной. Например, здесь можно реализовывать код, который будет поддерживать пользовательский интерфейс.

Метод onStart() завершается очень быстро и, как и с onCreate(), активность не остаётся в состоянии Started, а переходит в состояние Resumed, после чего система вызывает метод onResume().

onResume()

Когда активность переходит в состояние Resumed, она выходит на передний план, а затем система вызывает метод onResume(). Это состояние, в котором приложение взаимодействует с пользователем. Приложение остается в этом состоянии, пока не произойдёт что-то, что переключит фокус с приложения. К таким событиям можно отнести, например, входящий вызов, переход пользователя на другую активность или выключение экрана устройства.

Когда происходит событие, прерывающее текущее состояние, активность переходит в состояние Paused и система вызывает метод onPause().

onPause()

Метод onPause() является первым признаком того, что пользователь покидает активность. Это не всегда означает, что активность уничтожается, она просто перестаёт находиться на переднем плане (хотя может оставаться видимой, если пользователь находится в многооконном режиме). Метод onPause() следует использовать для приостановки или регулирования операций, которые не должны продолжаться пока активность находится в состоянии Paused и ожидает возобновления. Существует несколько причин, по которым активность может войти в это состояние:

Некоторые события прерывают выполнение приложения, как описано в части про onResume(). Это самый распространенный случай.
В Android 7.0 (API 24) или выше несколько приложений могут работать в многооконном режиме. Поскольку только одно из приложений имеет фокус в момент времени, система приостанавливает работу всех других приложений.
Открывается новая полупрозрачная активность (например, диалог). Пока активность ещё частично видимо, но не в фокусе, она остаётся приостановленной.

Метод onPause() можно также использовать для освобождения системных ресурсов, регулирования сенсоров или любых других ресурсов, которые могут влиять на расход батареи, пока активность приостановлена. Однако, как уже говорилось, активность в состоянии Paused может быть ещё частично видимой, поэтому лучше всего использовать для освобождения ресурсов onStop() вместо onPause().

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

Завершение метода onPause() не означает, что активность выходит из состояния Paused. Скорее активность останется в этом состоянии до тех пор, пока не возобновится или не станет полностью невидимой для пользователя. Если активность возобновляется, система снова вызывает метод onResume(). Если активность возвращается из состояния Paused в состояние Resumed, система сохраняет экземпляр Activity в памяти, вызывает его в методе onResume(). В этом случае не нужно повторно инициализировать компоненты, созданные ранее. Если активность становится полностью невидимой, система вызывает метод onStop().

onStop()

Когда активность больше не видна пользователю, она переходит в состояние Stopped, и система вызывает метод onStop(). Это может произойти, например, когда вновь запущенная активность охватывает весь экран. Система также может вызвать onStop(), когда активность завершила свою работу и вот-вот будет уничтожена.

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

onStop() также следует использовать для выполнения относительно затратных в плане расхода CPU операций. Например, если не удается найти более подходящее время для сохранения информации в базе данных, это можно сделать в onStop().

Когда активность переходит в состояние Stopped, экземпляр Activity сохраняется в памяти: он содержит всю необходимую информацию, но не привязан к менеджеру окон. Поэтому при восстановлении не нужно заново инициализировать все компоненты. Система также отслеживает текущее состояние для каждого объекта View в разметке, поэтому, если пользователь вводит текст в виджет EditText, то этот контент сохранится и затем восстановится.

В состоянии Stopped активность либо возвращается для взаимодействия с пользователем, либо полностью завершается. Если активность возвращается, система вызывает onRestart(). Если активность завершается, система вызывает метод onDestroy().

onDestroy()

Метод onDestroy() вызывается до того, как активность будет уничтожена. Система вызывает этот метод по следующим причинам:

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

Метод onDestroy() освобождает все ресурсы, которые ещё не были освобождены в методах ранее, такими как onStop().

Читайте также: