Запуск активити android что это такое

Запуск activity в android-приложении

В этом уроке

Вы также должны прочитать

Попробуйте

В отличие от других парадигм программирования, в котором приложения запускаются с помощью метода main() , Android система инициирует код в экземпляре Activity , вызывая конкретные методы обратного вызова, которые соответствуют конкретным этапам ее жизненного цикла. Существует последовательность методов обратного вызова, которые запускают activity , и последовательность методов обратного вызова, которые уничтожают activity .

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

Понимание обратных вызовов жизненного цикла

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

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

Рисунок 1. Упрощенная иллюстрация жизненного цикла activity , выраженное в виде ступенчатой ​​пирамиды. Она показывает для каждого обратного вызова, используемого для перемещения activity на шаг вперед к Resumed (возобновленный) состоянию в верхней части, есть также методы обратного вызова, которые перемещают activity на шаг вниз. activity также может вернуться к Resumed состоянию из Paused (приостановленный) и Stopped (остановленный) состояния.

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

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

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

Resumed (возобновлена) В этом состоянии, activity находится на переднем плане, и пользователь может с ней взаимодействовать. (Также иногда это состоянии называется «работает».) Paused (приостановлена) В этом состоянии, activity частично закрыта другой activity — другая activity находится в переднем плане, полупрозрачна или не покрывает весь экран. Приостановленная деятельность не принимать пользовательский ввод и не может выполнять какой-либо код. Stopped (остановлена) В этом состоянии, activity полностью скрыта и не видна пользователю; это расценивается как работа в фоновом режиме. Во время остановки, экземпляр activity , и вся его информация о состоянии, такая как переменные-члены классов сохраняется, но он не может выполнять какой-либо код.

Другие состояния (Created (создана) и Started (запущена)) являются временными и система быстро переходит от них к следующему состоянию, вызвав следующий метод обратного вызова жизненного цикла. То есть, после того, как система вызывает onCreate() , она быстро вызывает onStart() , , за которым быстро следует onResume() .

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

Укажите activity для запуска вашего приложения

Когда пользователь выбирает ваш значок приложения на главном экране, система вызывает onCreate() метод для Activity объекта в вашем приложении, который вы объявили как «главную» activity . Это activity , которая выступает в качестве основной точки входа в пользовательский интерфейс вашего приложения.

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

Главная activity вашего приложения должна быть объявлена в манифесте с помощью , который включает в себя MAIN действие и LAUNCHER категорию. Например:

Источник

Activity

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

Ключевым компонентом для создания визуального интерфейса в приложении 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 снова появится на экране.

Другой вариант работы может возникнуть, если вдруг система видит, что для работы активных приложений необходимо больше памяти. И система может сама завершить полностью работу activity, которая невидима и находится в фоне. Либо пользователь может нажать на кнопку Back (Назад). В этом случае у activity вызывается метод onStop .

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 .

Другая ситуация, если пользователь нажимает на кнопку Back (Назад), то вызывается следующая цепочка onPause -> onStop -> onDestroy . В результате Activity уничтожается. Если мы вдруг захотим вернуться к Activity через диспетчер задач или заново открыв приложение, то activity будет заново пересоздаваться через методы onCreate -> onStart -> onResume

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

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

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

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

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

Источник

Памятка по жизненному циклу Android — часть I. Отдельные Activity

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

Чтобы обеспечить такое взаимодействие с пользователем, вы должны знать, как управлять жизненными циклами компонентов. Компонентом может быть Activity, Fragment, Service, класс Application и даже сам процесс приложения. Компонент имеет жизненный цикл, в течение которого он проходит через различные состояния. Всякий раз, когда происходит переход, система уведомляет вас об этом при помощи методов жизненного цикла.

Чтобы нам было легче объяснить, как работает жизненный цикл в Android, мы определили несколько сценариев (примеров из жизни), которые сгруппированы по компонентам:

Часть 1: Activity — ЖЦ одного активити (этот пост)

Диаграммы также доступны в виде шпаргалки в формате PDF для краткого ознакомления.

Примечание: эти диаграммы соответствуют поведению в Android P/Jetpack 1.0.

Следующие сценарии демонстрируют поведение компонентов по умолчанию, если не указано иное.

Если вы обнаружили ошибки в статье или считаете, что не хватает чего-то важного, напишите об этом в комментариях.

Часть 1: Activity

Одно Aсtivity — Сценарий 1. Приложение завершено и перезапущено

Будет вызван, если:

Пользователь нажимает кнопку Назад или

Вызван метод Activity.finish()

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

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

onSaveInstanceState не вызывается (поскольку активити завершено, вам не нужно сохранять состояние)

onCreate не имеет Bundle при повторном открытии приложения, потому что активити было завершено и состояние не нужно восстанавливать.

Одно Aсtivity — Сценарий 2. Пользователь уходит

Будет вызван, если:

Пользователь нажимает кнопку «Домой»

Пользователь переключается на другое приложение (через меню «Все приложения», из уведомления, при принятии звонка и т. д.)

В этом случае система остановит активити, но не завершит его сразу.

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

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

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

Одно Aсtivity — Сценарий 3. Изменение кофигурации

Будет вызван, если:

Изменена конфигурация, такие как поворот экрана

Пользователь изменил размер окна в многооконном режиме

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

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

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

Bundle в onCreate тот же самый, что и в onRestoreInstanceState .

Одно Aсtivity — Сценарий 4. Приложение приостановлено системой

Будет вызван, если:

Включён многооконный режим (API 24+) и потерян фокус

Другое приложение частично покрывает работающее приложение: диалоговое окно покупки (in-app purchases), диалоговое окно получения разрешения (Runtime Permission), стороннее диалоговое авторизации и т. д.

Появится окно выбора приложения (при обработке неявного интента), например диалоговое окно шейринга.

Этот сценарий не применим к:

Диалогам в том же приложении. Отображение AlertDialog или DialogFragment не приостанавливает базовое активити.

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

Источник