Что такое android activity
Activity (Активность, Деятельность)
Что такое Activity
Разработчики со стажем могут воспринимать Активность как форму. Простые приложения состоят из одной активности. Более сложные приложения могут иметь несколько окон, т.е. они состоят из нескольких активностей, которыми надо уметь управлять и которые могут взаимодействовать между собой.
Активность, которая запускается первой, считается главной. Из нее можно запустить другую активность. Причем не только ту, которая относится к нашему приложению, но и другого приложения. Пользователю будет казаться, что все запускаемые им активности являются частями одного приложения, хотя на самом деле они могут быть определены в разных приложениях и работают в разных процессах. Попробуйте воспринимать активности как страницы разных сайтов, открываемых в браузерах по ссылке.
Обычно активность занимает весь экран устройства, но это не является обязательным требованием. Вы можете создавать полупрозрачные и плавающие окна активностей. И с развитием Android такой подход набирает обороты.
Чтобы создать активность, нужно унаследоваться от класса Activity и вызвать метод onCreate(). В результате мы получим пустой экран. Толку от такого экрана никакого. Поэтому в активность добавляют компоненты, фрагменты с помощью разметки.
Жизненный цикл активности
Активность имеет жизненный цикл — начало, когда Android создает экземпляр активности, промежуточное состояние, и конец, когда экземпляр уничтожается системой и освобождает ресурсы. Активность может находиться в трех состояниях:
Если активность, которая была уничтожена системой, нужно снова показать на экране, она должна быть полностью перезапущена и восстановлена в своем предыдущем состоянии.
Активность в виде диалогового окна
Помните, изучая темы, мы создали вторую активность в виде диалогового окна. С таким же успехом вы можете создать окно и для основной активности. Добавим в манифесте для активности строчку:
Напишем код для запуска:
Обратите внимание, что в данном примере мы не используем разметку, а программно создаём экземпляр класса TextView с необходимыми свойствами (текст, отступы) и передаём его в метод setContentView().
Програмнное создание активности
В основном мы пользуемся XML-разметкой для формирования внешнего вида активности. Это рекомендованный способ и в 99% вы будете использовать именно его. Но в некоторых случаях возможно вам понадобится создать активность программно. Сложного там ничего нет, для общего развития пригодится.
Если в стандартном случае мы подключаем XML-файл в методе setContentView(R.layout.activity_main), то при программном создании данный метод нам не понадобится. Удаляем его и пишем код:
В данном примере мы также присваиваем компонентам идентификаторы через метод setId(), хотя необходимости в этом не было. В примере эта возможность показана для демонстрации. Если вы используете идентификаторы, то в файле res/values/stings.xml добавьте строчки:
Обычно опытные программисты создают отдельный файл для идентификаторов, например, res/values/ids.xml.
Классы Activity в Android
Android SDK включает набор классов, наследованных от Activity. Они предназначены для упрощения работы с виджетами, которые часто встречаются в обычном пользовательском интерфейсе. Перечислим некоторые из них (наиболее полезные).
Activity
Activity и жизненный цикл приложения
Жизненный цикл приложения
Все приложения Android имеют строго определенный системой жизненный цикл. При запуске пользователем приложения система дает этому приложению высокий приоритет. Каждое приложение запускается в виде отдельного процесса, что позволяет системе давать одним процессам более высокой приоритет, в отличие от других. Благодаря этому, например, при работе с одними приложениями Android позволяет не блокировать входящие звонки. После прекращения работы с приложением, система освобождает все связанные ресурсы и переводит приложение в разряд низкоприоритетного и закрывает его.
После запуска activity проходит через ряд событий, которые обрабатываются системой и для обработки которых существует ряд обратных вызовов:
Схематично взаимосвязь между всеми этими обратными вызовами можно представить следующим образом
onCreate()
onStart
onResume
При вызове метода onResume activity переходит в состояние Resumed и отображается на экране устройства, и пользователь может с ней взаимодействовать. И собственно activity остается в этом состоянии, пока она не потеряет фокус, например, вследствии переключения на другую activity или просто из-за выключения экрана устройства.
onPause
onStop
В этом методе activity переходит в состояние Stopped. В этом состоянии activity полностью невидима. В методе onStop следует особождать используемые ресурсы, которые не нужны пользователю, когда он не взаимодействует с activity. Здесь также можно сохранять данные, например, в базу данных.
При этом во время состояния Stopped activity остается в памяти устройства, сохраняется состояние всех элементов интерфейса. К примеру, если в текстовое поле EditText был введен какой-то текст, то после возобновления работы activity и перехода ее в состояние Resumed мы вновь увидим в текстовом поле ранее введенный текст.
onDestroy
В целом переход между состояниями activity можно выразить следующей схемой:
Управление жизненным циклом
Мы можем управлять этими событиями жизненного цикла, переопределив соответствующие методы. Для этого возьмем из прошлой главы класс MainActivity и изменим его следующим образом:
И при запуске приложения мы сможем увидеть в окне Logcat отладочную информацию, которая определяется в методах жизненного цикла activity:
Активность и её жизненный цикл
Класс Acitvity является важнейшим компонентом Android-приложения, а способ запуска и компоновки является фундаментальной частью платформы Android. В отличие от парадигм программирования, где приложение запускается в методе main(), система Android инициирует код в экземпляре Activity, вызывая специальные коллбэки, которые соответствуют конкретным этапам жизненного цикла активности (подробнее о жизненном цикле активности будет сказано ниже).
Опыт использования мобильных приложений отличается от прочих тем, что взаимодействие пользователя с приложением не всегда начинается со стартового экрана. Например, если пользователь запустит приложение Gmail, он увидит список писем. Однако если он пользуется приложениями социальных сетей, которые могут запустить Gmail, то пользователь может попасть непосредственно на экран отправки письма.
Класс Activity предназначен для облегчения этой парадигмы. Когда одно приложение вызывает другое, вызывающее приложение запускает активность другого приложения, а не само приложение. Таким образом, активность служит точкой входа для взаимодействия приложения с пользователем.
Есть различные разновидности активностей, хотя все они так или иначе являются наследниками базового класса Activity. Например, если используется библиотека поддержки, то при создании нового проекта Android Studio генерирует класс MainActivity, который наследует от AppCompatAcitivty. Если посмотреть иерархию наследования, то в результате можно увидеть, что в начале этой иерархии будет находиться класс Activity.
Активность представляет собой окно, в котором приложение рисует свой UI. Это окно обычно полностью заполняет экран, но может быть меньше экрана или находиться поверх других окон. Как правило, одна активность представляет собой один экран в приложении. Например, одна активность может реализовывать окно настроек, в то время как другая — окно с выбором фото.
Большинство приложений имеют несколько экранов, из чего можно сделать вывод, что они содержат несколько активностей. Как правило, одна из активностей определяется как главная и является первым экраном, появляющимся при запуске пользователем приложения. Затем каждая активность может запустить другую активность для выполнения каких-либо действий. На примере Gmail можно увидеть, что главной активностью является экран со списком писем. Из этой активности можно запустить активность, которая отвечает за создание и отправку новых писем, или любую другую.
Несмотря на то, что активности работают вместе, чтобы организовать хороший пользовательский интерфейс в приложении, каждая активность слабо связано с другими: обычно в приложении есть минимальные зависимости между активностями. Кроме того, активности часто запускают активности других приложений. Например, активность веб-браузера может запустить активность приложения социальной сети.
Рассмотрим на примере, как добавить в приложение новую активность. Создадим в Android Studio новый пустой проект. По умолчанию, в приложении создаётся одна главная активность, называемая MainActivity. При этом в проекте происходят следующие действия.
Создаётся одноимённый класс MainActivity.java. В этом классе будет реализовываться вся работа активности, при создании в ней уже есть переопределённый метод onCreate() и загрузка разметки активности.
Как уже говорилось выше, метод setContentView() загружает разметку активности. Эта разметка берётся из XML-файла, который размещается в /res/layout. При создании проекта там уже находится сгенерированный файл activity_main.xml, идентификатор которого и передаётся в параметры setContentView(). Как правило, идентификатор идентичен названию файла. Если заглянуть в этот файл, то можно увидеть там TextView с надписью Hello World!, размещённое в центре экрана. Таким образом, то, что будет в коде этого файла, и увидит пользователь при запуске активности, для которой эта разметка установлена.
Чтобы приложение могло использовать активность, она должна быть зарегистрирована в манифесте приложения. IDE уже сделала это за разработчика, если открыть файл AndroidManifest.xml, то можно обнаружить там внутри элемент с именем, аналогичным имени активности.
Как уже говорилось выше, одна из активностей в приложении должна быть главной. Поэтому внутри был автоматически добавлен интент-фильтр со следующими параметрами:
Вот всё, что нужно для того, чтобы создать активность. Подводя итог, можно сказать, что для создания активности Android Studio выполняет 3 шага:
Ничто не мешает разработчику выполнять эти шаги вручную, однако намного проще воспользоваться возможностями Android Studio, которая в разы ускоряет этот процесс. Допустим, нам понадобилось добавить в проект вторую активность. Для того, чтобы добавить новую активность нужно в контекстном меню выбрать New — Activity. В списке будет предложено выбрать несколько активностей с уже готовыми компонентами (например, активность с настройками). Чтобы создать активность без лишних компонентов, нужно выбрать Empty Activity.
Откроется окно, в котором будет предложено ввести название новой активности и название 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 и ожидает возобновления. Существует несколько причин, по которым активность может войти в это состояние:
Метод 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, то этот контент сохранится и затем восстановится.
Примечание: Как только активность окажется остановленной, система может уничтожить процесс, который содержит активность, чтобы чтобы освободить память для своих нужд. Даже если система уничтожит процесс, она продолжает сохранять состояния объектов View (например, текст в EditText) в Bundle (парах «ключ-значение«) и восстанавливать их, когда пользователь возвращается в активность.
В состоянии Stopped активность либо возвращается для взаимодействия с пользователем, либо полностью завершается. Если активность возвращается, система вызывает onRestart(). Если активность завершается, система вызывает метод onDestroy().
onDestroy()
Метод onDestroy() вызывается до того, как активность будет уничтожена. Система вызывает этот метод по следующим причинам:
Если активность прекращает работу, то onDestroy() — это последний коллбэк жизненного цикла активности. Если onDestroy() вызывается в результате изменения конфигурации, система немедленно создаёт новый экземпляр активности и затем вызывает onCreate() в новом экземпляре.
Метод onDestroy() освобождает все ресурсы, которые ещё не были освобождены в методах ранее, такими как onStop().
Посмотрим на примере приложения, как это всё работает. Возьмём проект, который создали ранее, и переопределим в коде MainActivity все коллбэки жизненного цикла активности. Затем добавим в них показ всплывающих сообщений, чтобы знать, в какой момент какое состояние вызывается. В результате получается следующий код:
Активность и её жизненный цикл : 4 комментария
Потому что этот метод не является метод жизненного цикла
Спасибо. Из десяток статей эта лучшая (для новичка)
Реально куча сайтов перечитала и ваше объяснение самое понятное для новичков! Спасибо огромное! Наконец-то в программе все работает!
Памятка по жизненному циклу Android — часть I. Отдельные Activity
Android спроектирован так, чтобы использование приложения пользователем было максимально интуитивным. Например, пользователи приложения могут повернуть экран, ответить на уведомление или переключиться на другое приложение, и после этих манипуляций они все так же должны иметь возможность продолжить использовать приложение без каких-либо проблем.
Чтобы обеспечить такое взаимодействие с пользователем, вы должны знать, как управлять жизненными циклами компонентов. Компонентом может быть Activity, Fragment, Service, класс Application и даже сам процесс приложения. Компонент имеет жизненный цикл, в течение которого он проходит через различные состояния. Всякий раз, когда происходит переход, система уведомляет вас об этом при помощи методов жизненного цикла.
Чтобы нам было легче объяснить, как работает жизненный цикл в Android, мы определили несколько сценариев (примеров из жизни), которые сгруппированы по компонентам:
Часть 1: Activity — ЖЦ одного активити (этот пост)
Диаграммы также доступны в виде шпаргалки в формате PDF для краткого ознакомления.
Примечание: эти диаграммы соответствуют поведению в Android P/Jetpack 1.0.
Следующие сценарии демонстрируют поведение компонентов по умолчанию, если не указано иное.
Если вы обнаружили ошибки в статье или считаете, что не хватает чего-то важного, напишите об этом в комментариях.
Часть 1: Activity
Пользователь нажимает кнопку Назад или
Вызван метод Activity.finish()
Самый простой сценарий показывает, что происходит, когда приложение с одним активити запускается, завершается и перезапускается пользователем:
Управление состоянием
onSaveInstanceState не вызывается (поскольку активити завершено, вам не нужно сохранять состояние)
onCreate не имеет Bundle при повторном открытии приложения, потому что активити было завершено и состояние не нужно восстанавливать.
Пользователь нажимает кнопку «Домой»
Пользователь переключается на другое приложение (через меню «Все приложения», из уведомления, при принятии звонка и т. д.)
В этом случае система остановит активити, но не завершит его сразу.
Управление состоянием
Когда ваше активити переходит в состояние Stopped, система использует onSaveInstanceState для сохранения состояния приложения на тот случай, если впоследствии система завершит процесс приложения (см. ниже).
Предполагая, что процесс не был убит, экземпляр активити сохраняется в памяти, сохраняя все состояние. Когда активити возвращается на передний план, вам не нужно повторно инициализировать компоненты, которые были созданы ранее.
Изменена конфигурация, такие как поворот экрана
Пользователь изменил размер окна в многооконном режиме
Управление состоянием
Изменения конфигурации, такие как поворот или изменение размера окна, должны позволить пользователям продолжить работу с того места, где они остановились.
Активити полностью уничтожено, но состояние сохраняется и восстанавливается при создании нового экземпляра.
Включён многооконный режим (API 24+) и потерян фокус
Другое приложение частично покрывает работающее приложение: диалоговое окно покупки (in-app purchases), диалоговое окно получения разрешения (Runtime Permission), стороннее диалоговое авторизации и т. д.
Появится окно выбора приложения (при обработке неявного интента), например диалоговое окно шейринга.
Этот сценарий не применим к:
Диалогам в том же приложении. Отображение AlertDialog или DialogFragment не приостанавливает базовое активити.
Уведомлениям. Пользователь, получающий новое уведомление или открывающий панель уведомлений, не приостанавливает текущее активити.