Жизненный цикл приложения Android основан на объектах Activities. Схема ниже показывает поток приложения перед запуском mainActivity.
Looper меньше используется для запуска цикла сообщений для потока. Потоки по умолчанию не имеют связанного с ними цикла сообщений. Чтобы создать его, вызовите функцию prepare() в потоке, который должен запускать цикл, а затем loop(), чтобы он обрабатывал сообщения до тех пор, пока цикл не будет остановлен.
Когда пользователь начинает покидать Activity, система вызывает методы для её удаления. В некоторых случаях это удаление является лишь частичным; Activity все еще находится в памяти (например, когда пользователь переключается на другое приложение) и все еще может вернуться на передний план. Если пользователь возвращается к ней, она возобновляется с того места, на котором пользователь остановился. За некоторыми исключениями приложениям запрещено запускать Activity при работе в фоновом режиме.
Вероятность того, что система завершит данный процесс — вместе с действиями в нем — зависит от состояния действия в данный момент. Состояние активности и извлечение из памяти предоставляют дополнительную информацию о взаимосвязи между состоянием и уязвимостью к извлечению.
В зависимости от сложности вашей деятельности вам, вероятно, не нужно реализовывать все методы жизненного цикла. Однако важно, чтобы вы понимали каждый из них и реализовывали те, которые гарантируют, что ваше приложение ведет себя так, как ожидают пользователи.
Обратные вызовы жизненного цикла
В этом разделе представлена концептуальная информация и информация о реализации методов обратного вызова, используемых в течение жизненного цикла активности.
Некоторые действия, такие как вызов setContentView(), относятся к самим методам жизненного цикла activity. Однако код, реализующий действия зависимого компонента, должен быть размещен в самом компоненте. Чтобы достичь этого, вы должны сделать зависимый компонент зависимым от жизненного цикла.
onCreate()
Вы должны реализовать этот обратный вызов, который срабатывает, когда система впервые создает действие. При создании активности она переходит в созданное состояние. В методе onCreate() вы выполняете базовую логику запуска приложения, которая должна выполняться только один раз за весь срок действия действия. Например, ваша реализация onCreate() может привязывать данные к спискам, связывать действие с ViewModel и создавать экземпляры некоторых переменных области видимости класса. Этот метод получает параметр savedInstanceState, который представляет собой объект пакета, содержащий ранее сохраненное состояние действия. Если действие никогда раньше не существовало, значение объекта Bundle равно null.
Ваша активность не находится в созданном состоянии. После завершения выполнения метода onCreate() действие переходит в начатое состояние, и система вызывает методы OnStart() и onResume() в быстрой последовательности. В следующем разделе объясняется обратный вызов OnStart().
OnStart()
Когда активность переходит в начатое состояние, система вызывает этот обратный вызов. Вызов OnStart() делает действие видимым для пользователя, поскольку приложение готовится к тому, что активность выйдет на передний план и станет интерактивным. Например, в этом методе приложение инициализирует код, который поддерживает пользовательский интерфейс.
Когда активность переходит в начатое состояние, любой компонент с поддержкой жизненного цикла, привязанный к жизненному циклу активности, получит событие ON_START.
Метод OnStart() завершается очень быстро, и, как и в случае с созданным состоянием, действие не остается постоянным в начатом состоянии. Как только этот обратный вызов завершается, активность переходит в возобновленное состояние, и система вызывает метод onResume().
onResume()
Когда активность переходит в возобновленное состояние, оно выходит на передний план, а затем система вызывает обратный вызов onResume(). Это состояние, в котором приложение взаимодействует с пользователем. Приложение остается в этом состоянии до тех пор, пока не произойдет что-то, что отвлечет внимание от приложения. Таким событием может быть, например, получение телефонного звонка, переход пользователя к другой активности или выключение экрана устройства.
Когда активность переходит в возобновленное состояние, любой компонент с поддержкой жизненного цикла, привязанный к жизненному циклу активности, получит событие ON_RESUME. Именно здесь компоненты жизненного цикла могут включить любую функциональность, которая должна выполняться, пока компонент виден и находится на переднем плане, например, запуск предварительного просмотра камеры.
Когда происходит прерывающее событие, активность переходит в состояние приостановки, и система вызывает обратный вызов onPause().
Если активность возвращается в возобновленное состояние из приостановленного состояния, система снова вызывает метод onResume(). По этой причине вы должны реализовать onResume() для инициализации компонентов, которые вы освобождаете во время onPause(), и выполнять любые другие инициализации, которые должны выполняться каждый раз, когда действие переходит в возобновленное состояние.
onPause()
Система вызывает этот метод как первый признак того, что пользователь покидает вашу активность (хотя это не всегда означает, что действие уничтожается); это указывает на то, что активность больше не находится на переднем плане (хотя она все еще может быть видна, если пользователь находится в многооконном режиме). Используйте метод onPause() для приостановки или корректировки операций, которые не должны продолжаться (или должны продолжаться в умеренном темпе), пока активность находится в приостановленном состоянии, и которые вы ожидаете возобновить в ближайшее время. Существует несколько причин, по которым активность может перейти в это состояние. Например:
Некоторое событие прерывает выполнение приложения, как описано в разделе onResume(). Это самый распространенный случай.
В Android 7.0 (уровень API 24) или выше несколько приложений работают в многооконном режиме. Поскольку только одно из приложений (Windows) имеет фокус в любое время, система приостанавливает работу всех остальных приложений.
Откроется новое полупрозрачная активность (например, диалоговое окно). Пока активность все еще частично видно, но не находится в фокусе, оно остается приостановленным.
Когда активность переходит в приостановленное состояние, любой компонент с поддержкой жизненного цикла, привязанный к жизненному циклу активности, получит событие ON_PAUSE. Здесь компоненты жизненного цикла могут останавливать любые функции, которые не должны выполняться, пока компонент не находится на переднем плане, например, останавливать предварительный просмотр камеры.
Вы также можете использовать метод onPause() для освобождения системных ресурсов, дескрипторов датчиков (например, GPS) или любых ресурсов, которые могут повлиять на время автономной работы, когда ваша активность приостановлена и пользователю они не нужны. Однако, как упоминалось выше в разделе onResume(), приостановленное действие все еще может быть полностью видно, если оно находится в многооконном режиме. Таким образом, вам следует рассмотреть возможность использования onStop() вместо onPause(), чтобы полностью освободить или настроить ресурсы и операции, связанные с пользовательским интерфейсом, для лучшей поддержки многооконного режима.
onStop()
Когда ваша активность больше не видна пользователю, она переходит в остановленное состояние, и система вызывает обратный вызов onStop(). Это может произойти, например, когда недавно запущенная активность занимает весь экран. Система может также вызвать onStop(), когда действие завершило выполнение и вот-вот будет завершено.
Когда действие переходит в остановленное состояние, любой компонент с поддержкой жизненного цикла, привязанный к жизненному циклу активности, получит событие ON_STOP. Именно здесь компоненты жизненного цикла могут остановить любую функциональность, которая не должна выполняться, пока компонент не виден на экране.
В методе onStop() приложение должно освободить или настроить ресурсы, которые не нужны, пока приложение не видно пользователю. Например, ваше приложение может приостановить анимацию или переключиться с мелкозернистых обновлений местоположения на крупнозернистые. Использование onStop() вместо onPause() гарантирует, что работа, связанная с пользовательским интерфейсом, продолжается, даже когда пользователь просматривает вашу активность в многооконном режиме.
onDestroy()
onDestroy() вызывается до того, как активность будет уничтожена. Система вызывает этот обратный вызов либо потому, что:
- активность завершается (из-за того, что пользователь полностью отменяет активность или из-за вызова функции finish() для действия);
- система временно уничтожает активность из-за изменения конфигурации (например, поворота устройства или многооконного режима).
Когда активность переходит в состояние destroyed, любой компонент с поддержкой жизненного цикла, привязанный к жизненному циклу активности, получит событие ON_DESTROY. Именно здесь компоненты жизненного цикла могут очистить все, что им нужно, прежде чем активность будет уничтожена.
Вместо того чтобы вводить логику в вашу активность, чтобы определить, почему оно уничтожается, вы должны использовать объект ViewModel, содержащий соответствующие данные представления для вашего действия. Если активность будет воссоздана из-за изменения конфигурации, ViewModel не нужно ничего делать, поскольку оно будет сохранено и передано следующему экземпляру Activity. Если действие не будет воссоздано заново, то ViewModel будет вызывать метод onCleared(), где он может очистить любые данные, которые ему нужны, перед уничтожением.
Вы можете провести различие между этими двумя сценариями с помощью метода isFinishing().
Если действие завершается, onDestroy() - это последний обратный вызов жизненного цикла, который получает действие. Если onDestroy() вызывается в результате изменения конфигурации, система немедленно создает новый экземпляр activity, а затем вызывает onCreate() для этого нового экземпляра в новой конфигурации.
Полезные ссылки:
Жизненный цикл мобильного приложения на Android: намерения и фрагменты
Телеграм: https://t.me/the_cybermania
