Как определить что activity было завершено методом finish
Методы активности
Методы
В статье приведены только часть методов. Остальные изучайте самостоятельно через документацию.
При переходе активности от одного состояния к другому, она получает уведомления через защищенные методы:
Из перечисленных методов в вашем классе обязательно должен быть метод onCreate(), которая задаёт начальную установку параметров при инициализации активности. Вторым по популярности является метод onPause(), используемый для сохранения пользовательских настроек активности и подготовиться к прекращению взаимодействия с пользователем.
При реализации любого из этих методов необходимо всегда сначала вызывать версию этого метода из суперкласса. Например:
Семь перечисленных методов определяют весь жизненный цикл активности. Есть три вложенных цикла, которые вы можете отслеживать в классе активности:
Можно написать код с заглушками для методов внутри Активности, которые обрабатывают изменения состояний. Комментарии к каждой такой заглушке описывают действия, которые нужно учитывать при обработке этих событий.
Как видно из кода, переопределяя эти обработчики, вы всегда должны вызывать одноимённые методы родительского класса.
Методы жизненного цикла описаны в отдельной статье. Здесь их опишем кратко и рассмотрим другие методы.
Метод addContentView()
Метод addContentView() добавляет компонент к уже существующей разметке. Пример смотрите здесь.
Метод findViewById()
Метод findViewById() позволяет получить ссылку на View, которая размещена в разметке через его идентификатор.
Если вы используете фрагменты, то когда они загружаются в активность, то компоненты, входящие в состав фрагмента, становятся частью иерархии активности. И вы можете использовать метод findViewById() для получения ссылки к компоненту фрагмента.
Не путать с одноимённым методом для класса View.
Метод finish()
C помощью метода finish() можно завершить работу активности. Если приложение состоит из одной активности, то этого делать не следует, так как система сама завершит работу приложения. Если же приложение содержит несколько активностей, между которыми нужно переключаться, то данный метод позволяет экономить ресурсы.
Метод getFragmentManager()
Каждая активность включает в себя Менеджер фрагментов для управления фрагментами, если они используются. Метод getFragmentManager() позволяет получить доступ к данному менеджеру. На сайте есть отдельные статьи, посвящённые фрагментам.
Метод getParentActivityIntent()
Возвращает намерение, которое может запускать активность, являющей родительской. Родительская активность прописывается в манифесте. Вы можете переопределить данное намерение для своих целей. Метод появился в API 16.
Метод onActivityResult()
Дочерняя активность может произвольно возвратить назад объект Intent, содержащий любые дополнительные данные. Вся эта информация в родительской активности появляется через метод обратного вызова Activity.onActivityResult(), наряду с идентификатором, который она первоначально предоставила.
Если дочерняя активность завершится неудачно или будет закрыта пользователем без подтверждения ввода через кнопку Back, то родительская активность получит результат с кодом RESULT_CANCELED.
Метод принимает несколько параметров:
Метод onBackPressed()
Метод, позволяющий отследить нажатине на кнопку Back. Появился в Android 2.0 (API 5). Пример использования можно посмотреть в статье Кнопка Back: Вы уверены, что хотите выйти из программы?.
Метод onConfigurationChanged()
Метод, который вызывается при изменении конфигурации устройства. Если в манифесте были установлены специальные параметры у атрибута android:configChanges, то данный метод не будет вызван.
Метод onKeyShortcut()
Метод onPostCreate()
Новый метод, который появился в API 21. Он вызывается позже onCreate() и в нём можно получить значения размеров компонентов, которые недоступны при построении интерфейса в методе onCreate().
Метод overridePendingTransition()
Метод overridePendingTransition() позволяет задать анимацию при переходе от одной активности к другой. Пример смотрите здесь.
Метод onRestoreInstanceState()
У метода onRestoreInstanceState() есть такой же параметр Bundle, как у onCreate(), и вы можете восстанавливать сохранённые значения из метода onSaveInstanceState(). Во многих случаях это пример личных предпочтений, какой из двух методов использовать для восстановления данных.
Метод вызывается после метода onStart(). Система вызывает метод onRestoreInstanceState() только в том случае, если имеются сохранённые данные для восстановления. Таким образом вам не нужно проверять Bundle на null, как в методе onCreate():
Метод onSaveInstanceState()
Когда система завершает активность в принудительном порядке, чтобы освободить ресурсы для других приложений, пользователь может снова вызвать эту активность с сохранённым предыдущим состоянием. Чтобы зафиксировать состояние активности перед её уничтожением, в классе активности необходимо реализовать метод onSaveinstancestate().
Сам метод вызывается прямо перед методом onPause(). Он предоставляет возможность сохранять состояние пользовательского интерфейса активности в объект Bundle, который потом будет передаваться в методы onCreate() и onRestoreInstanceState(). В объект Bundle можно записать параметры, динамическое состояние активности как пары «ключ-значение». Когда активность будет снова вызвана, объект Bundle передаётся системой в качестве параметра в методы onCreate() и onRestoreInstanceState(), которые вызываются после onStart(), чтобы один из них или они оба могли установить активность в предыдущее состояние. Прежде чем передавать изменённый параметр Bundle в обработчик родительского класса, сохраните значения с помощью методов putXXX() и восстановите с помощью getXXX().
Используйте обработчик onSaveInstanceState() для сохранения состояния интерфейса (например, состояния флажков, текущего выделенного элемента или введенных, но не сохранённых данных), чтобы объект Activity при следующем входе в активное состояние мог вывести на экран тот же UI. Рассчитывайте, что перед завершением работы процесса во время активного состояния будут вызваны обработчики onSaveInstanceState и onPause.
В отличие от базовых методов, методы onSaveInstanceState() и onRestoreInstanceState() не относятся к методам жизненного цикла активности. Система будет вызывать их не во всех случаях. Например, Android вызывает onSaveinstancestate() прежде, чем активность становится уязвимой к уничтожению системой, но не вызывает его, когда экземпляр активности разрушается пользовательским действием (при нажатии клавиши BACK). В этом случае нет никаких причин для сохранения состояния активности.
Метод onSaveInstanceState() вызывается системой в случае изменения конфигурации устройства в процессе выполнения приложения (например, при вращении устройства пользователем или выдвижении физической клавиатуры устройства.
Поскольку метод onSaveinstanceState() вызывается не во всех случаях, его необходимо использовать только для сохранения промежуточного состояния активности. Для сохранения данных лучше использовать метод onPause().
Этот обработчик будет срабатывать всякий раз, когда жизненный цикл активности начнёт подходить к концу, но только в том случае, если её работа не будет завершена явно (при вызове метода finish()). Вследствие этого обработчик используется для проверки целостности состояния активности между активными жизненными циклами одиночной пользовательской сессии.
Сохранённый параметр Bundle передается методам onRestoreInstanceState() и onCreate(), если приложение принудительно перезапускается на протяжении сессии. В листинге показано, как извлечь значения из этого параметра и использовать их для обновления состояния экземпляра активности.
В API 28 метод вызывается после метода onStop(), в ранних версиях до метода onStop().
Метод onUserLeaveHint()
Позволяет отследить нажатие кнопки Home
Метод requestWindowFeature()
Метод позволяет задействовать дополнительные возможности для активности, например, выводить экран активности без заголовка. Примеры смотрите здесь.
Метод onWindowFocusChanged()
Метод позволяет определить момент получения фокуса вашим приложением.
Метод может быть полезен, так как он срабатывает позже метода onCreate(). Например, для вычисления размеров кнопки на экране этот метод предпочтительнее, так как уже известно, что все элементы загрузились и доступны, тогда как в onCreate() могут возвратиться пустые значения ширины и высоты кнопки. Пример использования.
Метод setContentView()
Изначально экран активности пуст. Чтобы разместить пользовательский интерфейс, необходимо вызвать метод setContentView(). У метода есть две перегруженные версии. Вы можете передать в параметре либо экземпляр компонента (View), либо идентификатор ресурса (наиболее распространённый способ).
Пример с использованием экземпляра компонента:
В этом примере вы увидите на экране текстовое поле с текстом. Но при таком способе вы можете использовать только один компонент. А если экран состоит из множества кнопок и прочих элементов управления, то нужно использовать разметку.
Метод setFeatureDrawableResource()
С помощью данного метода можно вывести значки в правой части заголовка. Смотри пример.
Метод setRequestedOrientation()
Метод позволяет программно изменить ориентацию экрана. Пример использования.
Метод startActivity()
Чтобы запустить новую активность, используется метод startActivity(Intent). Этот метод принимает единственный параметр — объект Intent, описывающий активность, которая будет запускаться. Смотри пример Activity.
Метод startActivityForResult()
Иногда требуется вернуть результат активности, когда она закрывается. Например, можно запустить активность, которая позволяет пользователю выбирать человека в списке контактов. При закрытии активность возвращает данные человека, который был выбран: его полное имя и телефон. В этом случае необходимо вызвать метод startActivityForResult()
Метод startActivityForResult(Intent, int) со вторым параметром, идентифицирующим запрос позволяет возвращать результат. Когда дочерняя активность закрывается, то в родительской активности срабатывает метод onActivityResult(int, int, Intent), который содержит возвращённый результат, определённый в родительской активности.
Метод setResult()
Когда активность завершится, вы можете вызвать метод setResult(int), чтобы возвратить данные назад в родительскую активность (до метода finish()). Этот метод возвращает код результата закрытия активности, который может быть стандартными результатами Activity.RESULT_CANCELED, Activity.RESULT_OK или определяемым пользователем результатом RESULT_FiRST_USER (можете придумать любую константу с целочисленным значением).
Если в дочерней активности есть кнопка отмены, то код может быть следующим:
Если метод finish() вызвать раньше метода setResult(), то результирующий код установится в RESULT_CANCELED автоматически, а возвращённое намерение покажет значение null.
Что именно делает метод Activity.finish ()?
Я разрабатываю приложения для Android на некоторое время и слежу за множеством сообщений о жизненном цикле активности и жизненном цикле приложения.
Я пришел на этот пост – отказывается от заявления, нахмурившегося? И прочитал ответ Марка Мерфи.
Есть ли шанс, что я назову finish() и onDestroy() не будет вызван?
При вызове функции finish() для операции выполняется метод onDestroy() этот метод может выполнять такие действия, как:
Кроме того, onDestroy() не является деструктором. Это фактически не уничтожает объект. Это просто метод, который называется на основе определенного состояния. Таким образом, ваш экземпляр все еще жив и очень хорошо * после onDestroy() и onDestroy() суперкласса onDestroy() поддерживает процессы в случае, если пользователь хочет перезапустить приложение, это ускоряет этап запуска. Процесс не будет делать ничего, и если память должна быть исправлена, процесс будет убит
Мои 2 цента на @K_Anas отвечают. Я выполнил простой тест по методу finish (). Перечислены важные методы обратного вызова в жизненном цикле активности
Я хочу сказать, что аналогичные методы вместе с любыми методами между ними вызываются при выполнении функции finish ().
onDestroy() предназначен для окончательной очистки – освобождая ресурсы, которые вы можете самостоятельно, закрывая открытые соединения, читателей, писателей и т. Д. Если вы не отмените его, система сделает то, что ему нужно.
Метод Finish () уничтожит текущую активность. Вы можете использовать этот метод в случаях, когда вы не хотите, чтобы эта активность загружалась снова и снова, когда пользователь нажимает кнопку «Назад». В основном он очищает активность из стека.
Различные ответы и заметки утверждают, что finish () может пропустить onPause () и onStop () и непосредственно выполнить onDestroy (). Справедливости ради следует отметить, что в документации на Android ( http://developer.android.com/reference/android/app/Activity.html ) отмечается, что «активность заканчивается или уничтожается системой», что довольно неоднозначно, но может предполагать, что Finish () может перейти к onDestroy ().
JavaDoc on finish () также разочаровывает ( http://developer.android.com/reference/android/app/Activity.html#finish () ) и фактически не замечает, какие методы (ы) вызываются в ответ на завершение ().
Поэтому я написал это мини-приложение, ниже которого записывается каждое состояние при входе. Он включает кнопку, которая вызывает finish () – чтобы вы могли видеть журналы, из которых запускаются методы. Этот эксперимент предположил бы, что finish () действительно также вызывает onPause () и onStop (). Вот результат, который я получаю:
Также обратите внимание, если вы назовете finish () после намерения, вы не сможете вернуться к предыдущему действию с помощью кнопки «Назад»
Диаграмма не показывает прямой путь от [Activity Running] до [ onDestroy() ], вызванного системой.
OnStop () doc говорит: « Обратите внимание, что этот метод никогда не может быть вызван в ситуациях с низкой памятью, когда в системе недостаточно памяти, чтобы поддерживать работу вашего процесса после вызова метода onPause () ».
Вызов end в onCreate () не будет вызывать onDestroy () напрямую, как сказал @prakash. Операция finish() не начнется, пока вы не вернете управление Android.
Для получения дополнительной справки посмотрите на это oncreate непрерывное после финиша и о финише ()
Мое исследование показывает, что метод finish() фактически помещает некоторые операции уничтожения в очередь, но Activity не сразу уничтожается. Планируется разрушение.
Кажется, единственный верный ответ, который до сих пор был дан romnex: «onDestroy () вообще не может быть вызван». Хотя на практике почти во всех случаях это будет, нет никакой гарантии: документация на финише () только обещает, что результат активности будет передан обратно вызывающему, но не более того. Более того, в документации по жизненному циклу разъясняется, что эта активность может быть уничтожена операционной системой, как только onStop () заканчивается (или даже раньше на старых устройствах), что, хотя и маловероятно и поэтому редко наблюдается в простом тесте, может означать, что активность Может быть убит во время или даже до выполнения onDestroy ().
Поэтому, если вы хотите удостовериться, что какая-то работа выполняется, когда вы вызываете finish (), вы не можете поместить ее в onDestroy (), но вам нужно будет сделать то же самое место, где вы вызываете finish (), прямо перед тем, как на самом деле его называть.
Finish () просто отправляет обратно предыдущую активность в android, или, может быть, вы можете сказать, что она идет на один шаг назад в приложении
Основы Android
Материал из AOW
Содержание
Жизненный цикл Android activity
Что в этом случае происходит?
На этот вопрос, мы постараемся ответить разобрав модель жизненного цикла приложения.
Модель жизненного цикла приложения можно изобразить в виде следующей схемы:
Обратите внимание, после метода onPause() и onStop() система может просто завершить ваш процесс (process killed) и методы onStop() и onDestroy() не будут вызваны. Это вполне обычная ситуация, поэтому с самого начала разработки вашего приложения для Google Android (андроид) вы должны учитывать возможность возникновения такого события.
Также необходимо понимать, когда Activity остановлено или приостановлено его состояние сохраняется т.к. Activity все еще хранится в памяти, и вся информация о его элементах и текущем состоянии ни куда не девается.
Но, когда система завершает процесс для того, чтобы освободить память (process killed), уже нет возможности возобновить состояние Activity. Как правило, пользователь об этом ничего не подозревает и ожидает увидеть Activity таким, каким он его запомнил. В данной ситуации, мы можем помочь сохранить состояние Activity, реализовав дополнительный метод onSaveInstanceState(Bundle).
Затем, при помощи любого из методов onCreate(Bundle) и onRestoreInstanceState(Bundle) мы можете извлечь сохраненное состояние Activity для восстановления.
Понимать то, как работает модель жизненного цикла приложения очень важно при построении приложений. Ниже, я приведу ряд рекомендаций по применению методов:
В одной из книг Эда Бурнета, был предложен способ быстрого тестирования корректной работы кода по сохранению состояния приложения. Способ этот заключается в том, что изменение ориентации экрана (между портретным и ландшафтным режимом) приводит к тому, что текущая Activity проходит весь жизненный цикл. В процессе разработки приложений, мы будем использовать предложенный способ тестирования.
Основные методы жизненного цикла приложения
onCreate()
Вызывается при создании активности. Система может запускать и останавливать текущие окна в зависимости от происходящих событий. Android вызывает метод onCreate() после запуска или перезапуска Activity. Внутри этого метода настраивают статический интерфейс активности. Инициализирует статические данные активности, связывают данные со списками и т. д.. Связывает с необходимыми данными и ресурсами. Задает внешний вид через метод 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() и выполнять любые другие инициализации, которые должны происходить, когда активность вновь активна.
Пытайтесь размещать относительно быстрый и легковесный код, чтобы ваше приложение оставалось отзывчивым при скрытии с экрана или выходе на передний план.
Метод onResume может быть довольно легковесным. Вам не нужно перезагружать состояние пользовательского интерфейса внутри него, так как эти функции возложены на обработчики onCreate и onRestoreInstanceState.
Используйте метод onResume для регистрации любых широковещательных приемников или других процессов, которые должны приостанавливаться внутри обработчика onPause().
Например, после метода onPause(), в котором мы приостановили работу камеры (см. ниже) снова запускаем камеру:
onPause()
Когда пользователь решает перейти к работе с новым окном, система вызовет для прерываемого окна метод onPause(). По сути происходит свертывание активности. Сохраняет незафиксированные данные. Деактивирует и выпускает монопольные ресурсы. Останавливает воспроизведение видео, аудио и анимацию. От onPause() можно перейти к вызову либо onResume(), либо onStop().
В этом методе необходимо остановить анимацию и другие действия, которые загружают процессор. Зафиксировать несохранённые данные, например, черновик письма. Освободить системные ресурсы, например, обработку данных от GPS.
Пытайтесь размещать относительно быстрый и легковесный код, чтобы ваше приложение оставалось отзывчивым при скрытии с экрана или выходе на передний план.
В большинстве реализаций класса Activity переопределяется как минимум метод onPause(). Внутри него фиксируются несохраненные изменения, потому как после его выполнения работа активности может прерваться без предупреждения. Исходя из архитектуры своего приложения, вы также можете приостановить выполнение потоков, процессов или широковещательных приемников, пока активность не появится на переднем плане.
Например, при работе с камерой метод используется следующим образом:
В тоже время вы не должны использовать OnPause() для хранения пользовательских изменений (таких, как персональные данные, введенные в форму) для постоянного хранения. Искключение допускается, когда вы уверены, что пользователи ожидают изменения, которые будут автоматически сохранены (например, при составлении электронной почты). Тем не менее, вы должны избегать выполнения интенсивной работы в OnPause(), таких как запись в базе данных, так как это может замедлить переход к следующей активности (вместо него вы должны выполнять тяжелую нагрузку во время операции отключения OnStop()).
Когда активность приостановлена, то все компоненты сохраняются в памяти и при возобновления нет необходимости повторно инициализировать их.
onStop()
Метод onStop() вызывается, когда окно становится невидимым для пользователя. Это может произойти при ее уничтожении, или если была запущена другая активность (существующая или новая), перекрывшая окно текущей активности. Всегда сопровождает любой вызов метода onRestart(), если активность возвращается, чтобы взаимодействовать с пользователем, или метода onDestroy(), если эта активность уничтожается.
Когда ваша деятельность останавливается, объекты активности хранятся в памяти и восстанавливаются, когда активность возобновляется. Вам не нужно повторно инициализировать компоненты, которые были созданы ранее. Кроме того, система отслеживает текущее состояние для каждого представления, поэтому, если пользователь введёт текст в текстовое поле EditText, то его содержание сохраняется и вам не нужно сохранять и восстанавливать его.
Примечание: Даже если система закрыла вашу активность, когда она была остановлена, она по-прежнему сохраняет состояние объектов, таких как текст в EditText в специальном объекте Bundle (в виде ключ-значение) и восстанавливает их, если пользователь переходит обратно к тому же экземпляру активности.
В этом методе можно сделать сложные операции по сохранению данных: для приостановки сложной анимации, потоков, отслеживания показаний датчиков, запросов к GPS, таймеров, Сервисов или других процессов, которые нужны исключительно для обновления пользовательского интерфейса. Нет смысла потреблять ресурсы (такты центрального процессора или сетевой трафик) для обновления интерфейса, в то время как он не виден на экране. Примените методы onStart() или onRestart() для возобновления или повторного запуска этих процессов, когда Активность опять станет видимой.
onRestart()
Если окно возвращается в приоритетный режим после вызова onStop(), то в этом случае вызывается метод onRestart(). Т.е. вызывается после того, как активность была остановлена и снова была запущена пользователем. Всегда сопровождается вызовом метода onStart().
onRestart предшествует вызовам метода onStart (кроме самого первого). Используйте его для специальных действий, которые должны выполняться только при повторном запуске Активности в рамках «полноценного» состояния.
onDestroy()
Метод вызывается по окончании работы активности, при вызове метода finish() или в случае, когда система уничтожает этот экземпляр активности для освобождения ресурсов. Эти два сценария уничтожения можно определить вызовом метода isFinishing(). Вызывается перед уничтожением активности. Это последний запрос, который получает активность от системы. Если определенное окно находится в верхней позиции в стеке, но невидимо пользователю и система решает завершить это окно, вызывается метод onDestroy(). В этом случае метод удаляет все статические данные активности. Отдаёт все используемые ресурсы.
Так как все необходимые операции по освобождению ресурсов вы сделали в методе onStop(), то в этом методе вы можете подстраховаться и проверить ещё раз все неосвобождённые ресурсы.
На практике вам чаще всего придется сталкиваться с методами onCreate(), onResume() и onPause(). Метод onCreate() будет вызываться при создании пользовательского интерфейса для работы с окном. Данный метод позволит вам связывать данные с виджетами и подключать обработчики событий к компонентам пользовательского интерфейса. При помощи onPause() вы сможете сохранить важную информацию в базе данных вашего приложения. Это последний безопасный метод, который будет вызываться перед тем, как система завершит работу приложения. Метод onDestroy() не обязательно будет вызываться, поэтому не полагайтесь на этот метод при реализации критическом логики. Пример
Для наглядности создадим пример, где для каждого метода подготовим всплывающее сообщение. И мы сможем воочию увидеть весь жизненный цикл.
Запускайте проект и следите за сообщениями. Они будут всплывать в нужной последовательности, давая вам представление о жизненном цикле приложения. Обратите внимание на следующий момент. Когда ваше приложение запущено, то нажмите на первую кнопку, чтобы изменить текст в TextView. Затем нажмите кнопку Home (не Back!), чтобы попасть на Рабочий стол. После чего снова запустите ваше приложение. Вы увидите, что приложение не вызывает метод onCreate(), и текст в TextView будет свидетельствовать, что приложение не было закрыто, а только свернуто. Это очень важный момент, который нужно понять. Понимание этих вещей поможет вам правильно выстраивать логику приложения.
Методы Activity
При переходе активности от одного состояния к другому, она получает уведомления через защищенные методы:
Из перечисленных методов в вашем классе обязательно должен быть метод onCreate(), которая задает начальную установку параметров при инициализации активности. Вторым по популярности является метод onPause(), используемый для сохранения пользовательских настроек активности и подготовиться к прекращению взаимодействия с пользователем.
При реализации любого из этих методов необходимо всегда сначала вызывать версию этого метода из суперкласса. Например:
Семь перечисленных методов определяют весь жизненный цикл активности. Есть три вложенных цикла, которые вы можете отслеживать в классе активности:
Можно написать код с заглушками для методов внутри Активности, которые обрабатывают изменения состояний. Комментарии к каждой такой заглушке описывают действия, которые нужно учитывать при обработке этих событий.
Как видно из кода, переопределяя эти обработчики, вы всегда должны вызывать одноименные методы родительского класса.
Методы жизненного цикла описаны в отдельной статье. Здесь их опишем кратко и рассмотрим другие методы.
Метод onSaveInstanceState()
Прямо перед onPause() вызывается обработчик onSaveInstanceState. Он предоставляет возможность сохранять состояние пользовательского интерфейса Активности в объект Bundle, который потом будет передаваться в методы onCreate() и onRestoreInstanceState(). Используйте обработчик onSaveInstanceState для сохранения состояния интерфейса (например, состояния флажков, текущего выделенного элемента или введенных, но не сохраненных данных), чтобы объект Activity при следующем входе в активное состояние мог вывести на экран тот же UI. Рассчитывайте, что перед завершением работы процесса во время активного состояния будут вызваны обработчики onSaveInstanceState и onPause.
Когда система завершает активность в принудительном порядке, чтобы освободить ресурсы для других приложений, пользователь может снова вызвать эту активность с сохраненным предыдущим состоянием. Чтобы зафиксировать состояние активности перед ее уничтожением, в классе активности необходимо реализовать метод onSaveinstancestate(). Android вызывает этот метод перед созданием активности, т.е. раньше вызова onPause().
Система передает методу объект Bundle, в который можно записать параметры, динамическое состояние активности как пары имя-значение. Когда активность будет снова вызвана, объект Bundle передается системой в качестве параметра в метод onCreate() и в метод onRestoreInstanceState(), которыЙ вызывается после onStart(), чтобы один из них или они оба могли установить активность в предыдущее состояние.
В отличие от базовых методов, методы onSaveInstanceState() и onRestoreInstanceState() не относятся к методам жизненного цикла активности. Система будет вызывать их не во всех случаях. Например, Android вызывает onSaveinstancestate() прежде, чем активность становится уязвимой к уничтожению системой, но не вызывает его, когда экземпляр активности разрушается пользовательским действием (при нажатии клавиши BACK). В этом случае нет никаких причин для сохранения состояния активности.
Метод onSaveInstanceState() вызывается системой в случае изменения конфигурации устройства в процессе выполнения приложения (например, при вращении устройства пользователем или выдвижении физической клавиатуры устройства.
Поскольку метод onSaveinstanceState() вызывается не во всех случаях, его необходимо использовать только для сохранения промежуточного состояния активности. Для сохранения данных лучше использовать метод onPause().
С помощью переопределения обработчика событий активности onSaveInstanceState вы можете вызвать его параметр Bundle для сохранения переменных экземпляра пользовательского интерфейса. Прежде чем передавать измененный параметр Bundle в обработчик родительского класса, сохраните значения с помощью методов get и put.
Этот обработчик будет срабатывать всякий раз, когда жизненный цикл активности начнёт подходить к концу, но только в том случае, если её работа не будет завершена явно (при вызове метода finish()). Вследствие этого обработчик используется для проверки целостности состояния активности между активными жизненными циклами одиночной пользовательской сессии.
Сохранённый параметр Bundle передается методам onRestoreInstanceState() и onCreate(), если приложение принудительно перезапускается на протяжении сессии. В листинге показано, как извлечь значения из этого параметра и использовать их для обновления состояния экземпляра активности.
Помните, что обработчик onSaveInstanceState вызывается только тогда, когда активность переходит в пассивное состояние, а не когда она закрывается при вызове метода finish() или пользователь нажимает кнопку Назад.
Метод onRestoreInstanceState()
У метода onRestoreInstanceState() есть такой же параметр Bundle, как у onCreate(), и вы можете восстанавливать сохранённые значения из метода onSaveInstanceState().
Метод вызывается после метода onStart(). Система вызывает метод onRestoreInstanceState() только в том случае, если имеются сохранённые данные для восстановления. Таким образом вам не нужно проверять Bundle на null, как в методе onCreate():
Метод finish()
C помощью метода finish() можно завершить работу активности. Если приложение состоит из одной активности, то этого делать не следует, так как система сама завершит работу приложения. Если же приложение содержит несколько активностей, между которыми нужно переключаться, то данный метод позволяет экономить ресурсы.
Метод startActivity()
Чтобы запустить новую активность, используется метод startActivity(Intent). Этот метод принимает единственный параметр — объект Intent, описывающий активность, которая будет запускаться. Смотри пример Activity.
Метод startActivityForResult()
Иногда требуется вернуть результат активности, когда она закрывается. Например, можно запустить активность, которая позволяет пользователю выбирать человека в списке контактов. При закрытии активность возвращает данные человека, который был выбран: его полное имя и телефон. В этом случае необходимо вызвать метод startActivityForResult()
Метод startActivityForResult(Intent, int) со вторым параметром, идентифицирующим запрос позволяет возвращать результат. Результат возвращается через метод обратного вызова onActivityResult(int, int, Intent), определенный в родительской активности.
Метод setResult()
Когда активность завершится, она может вызвать метод setResult(int), чтобы возвратить данные назад в родительскую активность. Этот метод возвращает код результата закрытия активности, который может быть стандартными результатами RESULT_CANCELED, RESULT_OK или определяемым пользователем результатом RESULT_FiRST_USER.
Метод onActivityResult()
Кроме того, дочерняя активность может произвольно возвратить назад объект Intent, содержащий любые дополнительные данные. Вся эта информация в родительской активности появляется через метод обратного вызова Activity.onActivityResult(), наряду с идентификатором, который она первоначально предоставила.
Если дочерняя активность завершится неудачно или будет закрыта пользователем без подтверждения ввода, то родительская активность получит результат с кодом RESULT_CANCELED.
Метод overridePendingTransition()
Метод overridePendingTransition() позволяет задать анимацию при переходе от одной активности к другой. Пример смотрите здесь. Классы Activity в Android