Каков жизненный цикл активности Android? Почему так много подобных методов звучания (onCreate(), onStart(), onResume()), вызываемых во время инициализации, и так много других (onPause(), onStop(), onDestroy()), вызываемых в конце?
Когда эти методы называются и как их следует использовать должным образом?
Смотрите это в Activity Lifecycle (у разработчиков Android).
Вызывается при первом создании действия. Здесь вы должны выполнить все ваши обычные статические настройки: создавать представления, привязывать данные к спискам и т.д. Этот метод также предоставляет пакет, содержащий ранее замороженное состояние активности, если оно было. Всегда сопровождается onStart().
Вызывается после того, как ваша деятельность была остановлена, прежде чем она будет запущена снова. Всегда сопровождается onStart()
Вызывается, когда активность становится видимой для пользователя. Затем следует onResume(), если действие выходит на передний план.
Вызывается, когда действие начнет взаимодействовать с пользователем. На данный момент ваша активность находится на вершине стека активности, и пользовательский ввод идет к нему. Всегда сопровождается onPause().
Вызывается как часть жизненного цикла действия, когда действие переходит в фоновый режим, но еще не было уничтожено. Аналог onResume(). Когда действие B запускается перед действием A, этот обратный вызов будет вызываться для A. B не будет создан до тех пор, пока не вернется A onPause(), поэтому убедитесь, что здесь ничего не происходит.
Вызывается, когда вы больше не видны пользователю. Затем вы получите либо onRestart(), onDestroy(), либо ничего, в зависимости от дальнейшей пользовательской активности. Обратите внимание, что этот метод никогда не может быть вызван в ситуациях нехватки памяти, когда системе не хватает памяти для поддержания процесса вашей активности после вызова метода onPause().
Последний звонок, который вы получите до того, как ваша деятельность будет уничтожена. Это может произойти либо из-за того, что действие заканчивается (кто-то вызвал finish() на нем, либо из-за того, что система временно уничтожает этот экземпляр действия для экономии места. Вы можете различить> эти два сценария с помощью метода isFinishing().
Когда активность загружается впервые, события вызываются так:
onCreate()
onStart()
onResume()
Когда вы нажимаете кнопку "Телефон", действие переходит в фоновый режим и вызываются следующие события:
onPause()
onStop()
Выйдите из номеронабирателя телефона, и будут вызваны следующие события:
onRestart()
onStart()
onResume()
Когда вы нажимаете кнопку " Назад" ИЛИ пытаетесь завершить() действие, события вызываются, как показано ниже:
onPause()
onStop()
onDestroy()
ОС Android использует очередь с приоритетами для управления действиями, выполняемыми на устройстве. В зависимости от состояния, в котором находится конкретное действие Android, ему будет присвоен определенный приоритет в ОС. Эта система приоритетов помогает Android определять действия, которые больше не используются, что позволяет ОС восстанавливать память и ресурсы. Следующая диаграмма иллюстрирует состояния, через которые может проходить активность в течение ее жизненного цикла:
Эти состояния можно разбить на три основные группы следующим образом:
Активно или работает - Действия считаются активными или выполняющимися, если они находятся на переднем плане, также известном как верхняя часть стека действий. Это считается активностью с наивысшим приоритетом в стеке активности Android, поэтому ОС будет уничтожена только в экстремальных ситуациях, например, если активность пытается использовать больше памяти, чем доступно на устройстве, так как это может привести к тому, что пользовательский интерфейс стать неотзывчивым
Приостановлено - когда устройство переходит в спящий режим, или активность все еще видна, но частично скрыта новым, не в натуральную величину или прозрачным действием, действие считается приостановленным. Приостановленные действия все еще живы, то есть они хранят всю информацию о состоянии и членах и остаются привязанными к оконному менеджеру. Это считается вторым по приоритету действием в стеке активности Android и, как таковое, будет уничтожено ОС только в том случае, если уничтожение этого действия удовлетворит требования к ресурсам, необходимые для поддержания активной/активной активности в стабильном и отзывчивом состоянии.
Остановлено - действия, которые полностью скрыты другим действием, считаются остановленными или в фоновом режиме. Остановленные действия по-прежнему пытаются сохранить информацию о своем состоянии и членах как можно дольше, но остановленные действия считаются самым низким приоритетом из трех состояний, и, как таковая, ОС вначале уничтожит действия в этом состоянии, чтобы удовлетворить требования к ресурсам. приоритетных видов деятельности.
* Пример деятельности, чтобы понять жизненный цикл **
import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
public class MainActivity extends Activity {
String tag = "LifeCycleEvents";
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
Log.d(tag, "In the onCreate() event");
}
public void onStart()
{
super.onStart();
Log.d(tag, "In the onStart() event");
}
public void onRestart()
{
super.onRestart();
Log.d(tag, "In the onRestart() event");
}
public void onResume()
{
super.onResume();
Log.d(tag, "In the onResume() event");
}
public void onPause()
{
super.onPause();
Log.d(tag, "In the onPause() event");
}
public void onStop()
{
super.onStop();
Log.d(tag, "In the onStop() event");
}
public void onDestroy()
{
super.onDestroy();
Log.d(tag, "In the onDestroy() event");
}
}
Вся путаница вызвана тем, что Google выбрал неинтуитивные имена вместо следующего:
onCreateAndPrepareToDisplay() [instead of onCreate() ]
onPrepareToDisplay() [instead of onRestart() ]
onVisible() [instead of onStart() ]
onBeginInteraction() [instead of onResume() ]
onPauseInteraction() [instead of onPause() ]
onInvisible() [instead of onStop]
onDestroy() [no change]
Диаграмма активности может быть интерпретирована как:
Активность имеет шесть состояний
Жизненный цикл деятельности имеет семь методов
onCreate()onStart()onResume()onPause()onStop()onRestart()onDestroy() 
Ситуации
При открытии приложения
onCreate() --> onStart() --> onResume()
При нажатии кнопки "Назад" и выходе из приложения
onPaused() -- > onStop() --> onDestory()
При нажатии домашней кнопки
onPaused() --> onStop()
После нажатия кнопки "домой", когда снова откроется приложение из недавнего списка задач или щелкните значок
onRestart() --> onStart() --> onResume()
При открытии приложения другое приложение из панели уведомлений или открытых настроек
onPaused() --> onStop()
Кнопка "Назад", нажатая из другого приложения или настроек, затем используется наше приложение
onRestart() --> onStart() --> onResume()
Когда любой диалог открывается на экране
onPause()
После отклонения диалогового окна или кнопки возврата из диалогового окна
onResume()
Любой телефон звонит и пользователь в приложении
onPause() --> onResume()
Когда пользователь нажал кнопку ответа на звонок
onPause()
После завершения вызова
onResume()
Когда экран телефона выключен
onPaused() --> onStop()
Когда экран снова включен
onRestart() --> onStart() --> onResume()
Существует семь методов управления жизненным циклом приложения для Android:
Давайте рассмотрим простой сценарий, в котором знание того, в каком порядке эти методы будут вызваны, поможет нам дать ясность, почему они используются.
onCreate() - - → onStart() - - → onResume()
onPause() - - → onStop()
onRestart() - - → onStart() - - → onResume()
onStop() - - → onDestroy()
Начальное состояние включает в себя:
Создание нового процесса Linux, выделение новой памяти для новых объектов пользовательского интерфейса и настройка всего экрана. Поэтому большая часть работы здесь задействована.
Состояние выполнения включает в себя:
Это действие (состояние), которое в настоящее время находится на экране. Это состояние в одиночку обрабатывает такие вещи, как ввод текста на экране и касание и нажатие кнопок.
Приостановленное состояние включает в себя:
Если действие не находится на переднем плане, а вместо этого оно находится в фоновом режиме, то действие считается приостановленным.
Остановленное состояние включает в себя:
Прекращенная деятельность может быть куплена только на переднем плане, перезапустив ее, а также ее можно уничтожить в любой момент времени.
Менеджер активности обрабатывает все эти состояния таким образом, чтобы пользовательский опыт и производительность всегда были в лучшем состоянии даже в сценариях, где новая активность добавляется к существующим действиям.
Мне нравится этот вопрос и ответы на него, но пока не охвачены менее часто используемые обратные вызовы, такие как onPostCreate() или onPostResume(). Стив Померой попытался включить диаграмму, в том числе и о том, как они относятся к жизненному циклу Android Фрагмент, https://github.com/xxv/android-lifecycle. Я пересмотрел большую диаграмму Стива, чтобы включить только часть Активность и отформатировал ее для распечатки одной страницы на одну страницу. Я разместил его как текст PDF в https://github.com/code-read/android-lifecycle/blob/master/AndroidActivityLifecycle1.pdf, а ниже - его изображение:
На странице разработчиков Android,
OnPause():
Вызывается, когда система начнет возобновление предыдущего действия. Обычно это используется для переноса несохраненных изменений в постоянные данные, останавливать анимацию и другие вещи, которые могут потреблять процессор и т.д. Реализации этого метода должны быть очень быстрыми, потому что следующий активность не будет возобновлена до тех пор, пока этот метод не вернется. С последующим либо onResume(), если операция возвращается на передний план, или onStop(), если он становится невидимым для пользователя.
OnStop():
Вызывается, когда действие больше не отображается пользователю, потому что другая деятельность была возобновлена и охватывает этот. Это может происходят либо потому, что начинается новая деятельность, а существующая предстает перед этим, или этот уничтожается. За ним следует либо onRestart(), если это действие возвращается взаимодействовать с пользователем или onDestroy(), если эта активность уходит.
Теперь предположим, что есть три действия, и вы переходите от A к B, тогда onPause из A будет вызываться теперь от B до C, тогда onPause B и onStop of A будут вызываться.
Приостановленное действие получает "Возобновить", а "Остановить" перезапускается.
Когда вы вызываете this.finish(), вызывается onPause-onStop-onDestroy. Главное, что нужно помнить: приостановлено. Действия прекращаются, и прекращенная деятельность получает Destroyed, когда Android требует памяти для других операций.
Я надеюсь, что это достаточно ясно.
Добавление дополнительной информации поверх высоко оцененного ответа (добавлен дополнительный раздел KILLABLE и следующий набор методов, которые будут вызываться в жизненном цикле):
Источник: developer.android.com
Обратите внимание на столбец " Killable" в приведенной выше таблице - для тех методов, которые отмечены как подлежащие уничтожению, после того, как этот метод возвращает процесс, в котором эта активность может быть убита системой в любое время без выполнения другой строки своего кода.
Из-за этого вы должны использовать метод onPause() для записи любых постоянных данных (например, прав пользователя) на хранение. Кроме того, вызывается метод onSaveInstanceState(Bundle) перед тем, как помещать активность в такое фоновое состояние, позволяя сэкономить любое динамическое состояние экземпляра в вашей деятельности в данном Bundle, которое будет позже получено в onCreate(Bundle), если действие необходимо воссоздать.
Обратите внимание, что важно сохранить постоянные данные в onPause() вместо onSaveInstanceState(Bundle), потому что последнее не является частью обратных вызовов жизненного цикла, поэтому не будет вызываться в каждой ситуации, как описано в его документации.
Я хотел бы добавить еще несколько методов. Они не перечислены как методы жизненного цикла, но они будут называться во время жизненного цикла в зависимости от некоторых условий. В зависимости от вашего требования, возможно, вам придется реализовать эти методы в своем приложении для правильной обработки состояния.
onPostCreate(Bundle savedInstanceState)
Вызывается, когда запуск активности завершен (после того, как были вызваны
onStart()иonRestoreInstanceState(Bundle)).
onPostResume()
Вызывается, когда возобновление активности завершено (после вызова
onResume()).
onSaveInstanceState(Bundle outState)
Вызывается для извлечения состояния каждого экземпляра из активности перед тем, как его убить, чтобы состояние можно было восстановить в
onCreate(Bundle)илиonRestoreInstanceState(Bundle)(пакет, заполненный этим методом, будет передан обоим).
onRestoreInstanceState(Bundle savedInstanceState)
Этот метод вызывается после
onStart(), когда активность повторно инициализируется из ранее сохраненного состояния, указанного здесь вsavedInstanceState.
Мой код приложения, используя все эти методы:
public class MainActivity extends AppCompatActivity implements View.OnClickListener{
private EditText txtUserName;
private EditText txtPassword;
Button loginButton;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Log.d("Ravi","Main OnCreate");
txtUserName=(EditText) findViewById(R.id.username);
txtPassword=(EditText) findViewById(R.id.password);
loginButton = (Button) findViewById(R.id.login);
loginButton.setOnClickListener(this);
}
@Override
public void onClick(View view) {
Log.d("Ravi", "Login processing initiated");
Intent intent = new Intent(this,LoginActivity.class);
Bundle bundle = new Bundle();
bundle.putString("userName",txtUserName.getText().toString());
bundle.putString("password",txtPassword.getText().toString());
intent.putExtras(bundle);
startActivityForResult(intent,1);
// IntentFilter
}
public void onActivityResult(int requestCode, int resultCode, Intent resIntent){
Log.d("Ravi back result:", "start");
String result = resIntent.getStringExtra("result");
Log.d("Ravi back result:", result);
TextView txtView = (TextView)findViewById(R.id.txtView);
txtView.setText(result);
Intent sendIntent = new Intent();
//sendIntent.setPackage("com.whatsapp");
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, "Message...");
sendIntent.setType("text/plain");
startActivity(sendIntent);
}
@Override
protected void onStart() {
super.onStart();
Log.d("Ravi","Main Start");
}
@Override
protected void onRestart() {
super.onRestart();
Log.d("Ravi","Main ReStart");
}
@Override
protected void onPause() {
super.onPause();
Log.d("Ravi","Main Pause");
}
@Override
protected void onResume() {
super.onResume();
Log.d("Ravi","Main Resume");
}
@Override
protected void onStop() {
super.onStop();
Log.d("Ravi","Main Stop");
}
@Override
protected void onDestroy() {
super.onDestroy();
Log.d("Ravi","Main OnDestroy");
}
@Override
public void onPostCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
super.onPostCreate(savedInstanceState, persistentState);
Log.d("Ravi","Main onPostCreate");
}
@Override
protected void onPostResume() {
super.onPostResume();
Log.d("Ravi","Main PostResume");
}
@Override
public void onSaveInstanceState(Bundle outState, PersistableBundle outPersistentState) {
super.onSaveInstanceState(outState, outPersistentState);
}
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
}
}
Вход в систему:
public class LoginActivity extends AppCompatActivity {
private TextView txtView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_login);
txtView = (TextView) findViewById(R.id.Result);
Log.d("Ravi","Login OnCreate");
Bundle bundle = getIntent().getExtras();
txtView.setText(bundle.getString("userName")+":"+bundle.getString("password"));
//Intent intent = new Intent(this,MainActivity.class);
Intent intent = new Intent();
intent.putExtra("result","Success");
setResult(1,intent);
// finish();
}
}
вывод: (до паузы)
D/Ravi: Main OnCreate
D/Ravi: Main Start
D/Ravi: Main Resume
D/Ravi: Main PostResume
вывод: (после возобновления паузы)
D/Ravi: Main ReStart
D/Ravi: Main Start
D/Ravi: Main Resume
D/Ravi: Main PostResume
Обратите внимание, что onPostResume() вызывается, даже если он не цитируется как метод жизненного цикла.
Лучшее демо-приложение для понимания жизненного цикла активности здесь прикреплен файл apk.
onCreate: этот метод выполняется при создании Activity. Здесь мы получаем все готовое приложение, включая UI (например, вызов setContentView), графику и звук.
onStart: этот метод выполняется, когда приложение находится в начальной фазе.
onResume: этот метод запускается после onStart, но также может быть введен, возможно, наиболее логично, если наша активность возобновляется после предварительного приостановки. Мы могли бы перезагрузить ранее сохраненные пользовательские данные (например, важную заметку), когда приложение было прервано, возможно, по телефону или у пользователя, запускающего другое приложение.
onPause: Вероятно, вы получаете возможность использовать эти методы. Это происходит, когда наше приложение приостанавливается. Здесь мы можем сохранить несохраненные данные (например, заметку), которые можно перезагрузить в onResume. Действия всегда переходят в приостановленное состояние, когда другой элемент пользовательского интерфейса отображается поверх текущей активности (например, всплывающее диалоговое окно) или когда действие останавливается (например, когда пользователь переходит к другому активность).
onStop: Это относится к фазе остановки. Здесь мы можем отменить все, что мы сделали в onCreate, например, освобождение системных ресурсов или запись информации в базу данных. Если мы достигнем здесь, мы, вероятно, скоро будем уничтожены.
onDestroy: Это когда наша деятельность, наконец, уничтожается. На этом этапе нет возврата. Это наш последний шанс демонтировать наше приложение в упорядоченном виде. Если мы достигнем здесь, мы обязательно будем проходить фазы жизненного цикла с самого начала в следующий раз.
Каков жизненный цикл активности Android?
В Android SDK Framework, Каждая активность Android (окно), имеющие методы жизненного цикла. Это означает, что когда пользователь входит в приложение, он может видеть действие, созданное в методе жизненного цикла onCreate(). Макеты, прикрепленные в окне только в методе onCreate().
Активность (окно) имеет следующие состояния жизненного цикла:
Create - Activity is created.
Start - Current activity gets started.
Resume - Current activity has been in resumed state.
Restart - Current activity has been in restarted.
Pause - Current activity has been in Paused state.
Stop - Current activity has been in stopped state.
destroy - Current activity has been in destroyed state.
Почему во время инициализации вызывается так много похожих методов (onCreate(), onStart(), onResume()) и так много других (onPause(), onStop(), onDestroy()) в конце?
First time user enter into an application:
При открытии приложения мы видим одно окно (активность). onCreate (создано) → onStart (запущено) → onResume (состояние возобновления).
Close the application from background:
при закрытии приложения из фона активность должна быть уничтожена, чтобы освободить память. Итак, будут вызываться методы onPause → onStop → onDestroy.
Когда эти методы вызываются и как их следует использовать правильно?
Запускает приложение:
Когда пользователь впервые входит в действие или приложение:
onCreate()
onStart()
onResume()
Когда вы запускаете приложение из Android Studio:
onCreate()
onStart()
onResume()
Переход деятельности:
При переходе от первого занятия → второе занятие:
first_activity : onPause()
second_activity : onCreate()
second_activity : onStart()
second_activity : onResume()
first_activity : onStop()
При переходе от Второго занятия → Первое занятие:
second_activity : onPause()
first_activity : onRestart()
first_activity : onStart()
first_activity : onResume()
second_activity : onStop()
second_activity : onDestroy()
Кнопка обзора:
Когда пользователь нажимает кнопку обзора (аппаратная третья кнопка - недавний список):
onPause()
onStop()
После того как пользователь отклонил кнопку обзора (или), пользователь перешел к некоторым другим приложениям из недавнего списка и вернулся в приложение:
onRestart()
onStart()
onResume()
Главная кнопка:
Когда пользователь нажимает кнопку "Домой":
onPause()
onStop()
Пользователь выполняет поиск на главном экране и нажимает на значок приложения, чтобы вернуться к активности:
onRestart()
onStart()
onResume()
Пользователь получает телефонный звонок:
Когда пользователь в Деятельности, позвонил:
onPause()
onStop()
Если пользователь не посещает вызов, он автоматически отключается и возвращается к активности (пропущенный вызов):
onRestart()
onStart()
onResume()
Если пользователь не посещает звонок:
N/A - жизненный цикл не будет вызван.
Кнопка выключения питания:
Когда пользователь выключает кнопку:
onPause()
onStop()
Когда разблокирует устройство:
onRestart()
onStart()
onResume()
Всплывающее диалоговое окно:
Когда всплывающее диалоговое окно появилось - жизненный цикл не будет вызван
Перезапустите устройство или выключите:
Когда пользователь перезапускает или выключает устройство:
onPause()
onStop()
Когда пользователь нажимает на значок приложения на главном экране:
onCreate()
onStart()
onResume()