Жизненный цикл активности Android - для чего все эти методы? - PullRequest
396 голосов
/ 15 декабря 2011

Каков жизненный цикл активности Android? Почему во время инициализации вызывается так много похожих методов (onCreate(), onStart(), onResume()) и так много других (onPause(), onStop(), onDestroy()) в конце?

Когда эти методы вызываются и как их правильно использовать?

Ответы [ 8 ]

726 голосов
/ 15 декабря 2011

См. В Жизненный цикл активности (у разработчиков Android).

Enter image description here

OnCreate () :

Вызывается при первом создании действия. Это где вы должны сделать все ваши обычные статические настройки: создавать представления, привязывать данные к спискам, и т.д. Этот метод также предоставляет вам Bundle, содержащий ранее замороженное состояние активности, если таковое было. Всегда следовал от onStart ().

onRestart ()

Вызывается после того, как ваша деятельность была остановлена, до того, как она была запущена снова. Всегда следует onStart ()

OnStart ()

Вызывается, когда активность становится видимой для пользователя. С последующим onResume (), если действие выходит на передний план.

onResume ()

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

onPause () :

Вызывается как часть жизненного цикла действия, когда действие продолжается на задний план, но не был (пока) убит. Аналог onResume (). Когда действие B запускается перед действием A, этот обратный вызов будет вызван на A. B не будет создан до тех пор, пока функция onPause () не будет возвращена, поэтому обязательно не сделайте что-нибудь длинное здесь.

OnStop ()

Вызывается, когда вы больше не видны пользователю. Вы будете дальше получить либо onRestart (), onDestroy (), либо ничего, в зависимости от позже активность пользователя. Обратите внимание, что этот метод никогда не может быть вызван, в ситуациях с нехваткой памяти где система не имеет достаточно памяти, чтобы сохранить ваши действия процесс выполняется после вызова метода onPause ().

OnDestroy ()

Последний звонок, который вы получите до того, как ваша деятельность будет уничтожена. это может произойти либо потому, что деятельность заканчивается завершить (), или потому что система временно уничтожает это экземпляр деятельности для экономии места. Вы можете различить эти два сценария с помощью метода 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");
    }
}
150 голосов
/ 02 февраля 2012

Вся путаница вызвана тем, что 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] 

Диаграмма действий может интерпретироваться как:

enter image description here

146 голосов
/ 28 февраля 2015

Активность имеет шесть состояний

  • Создано
  • Начато
  • Возобновлено
  • Приостановлено
  • Остановлено
  • Уничтожено

Жизненный цикл активности имеет семь методов

  • onCreate()
  • onStart()
  • onResume()
  • onPause()
  • onStop()
  • onRestart()
  • onDestroy()

activity life cycle

Ситуации

  • При открытии приложения

    onCreate() --> onStart() -->  onResume()
    
  • Когда нажата кнопка назад ивыход из приложения

    onPaused() -- > onStop() --> onDestory()
    
  • Когда нажата домашняя кнопка

    onPaused() --> onStop()
    
  • ПослеНажмите кнопку «Домой», когда снова откроете приложение из списка недавних задач, или нажмите на значок

    onRestart() --> onStart() --> onResume()
    
  • Когда откройте приложение другое приложение из панели уведомлений или откройте настройки

    onPaused() --> onStop()
    
  • BacПри нажатии кнопки k в другом приложении или настройках, которые затем используются, можно увидеть наше приложение

    onRestart() --> onStart() --> onResume()
    
  • Когда на экране открывается любое диалоговое окно

    onPause()
    
  • После закрытия диалогового окна или кнопки возврата из диалогового окна

    onResume()
    
  • Любой телефон звонит и пользователь вприложение

    onPause() --> onResume() 
    
  • Когда пользователь нажал кнопку ответа телефона

    onPause()
    
  • Послезавершение вызова

    onResume()
    
  • Когда экран телефона выключен

    onPaused() --> onStop()
    
  • Когда экранснова включается

    onRestart() --> onStart() --> onResume()
    
20 голосов
/ 10 сентября 2013

ЖИЗНЕННЫЙ ЦИКЛ ANDROID

Существует семь методов, управляющих жизненным циклом приложения Android:


Ответьте за все эти методыfor:

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

  • Предположим, вы используете приложение калькулятора.,Три метода вызываются последовательно для запуска приложения.

onCreate() - - -> onStart() - - -> onResume()

  • Когда я использую приложение калькулятора, неожиданно приходит звонок.Активность калькулятора уходит на задний план, а другая активность, скажем.Работа с вызовом выходит на первый план, и теперь два метода вызываются по очереди.

onPause() - - -> onStop()

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

onRestart() - - -> onStart() - - -> onResume()

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

onStop() - - -> onDestroy()


Существует четыре состояния, в которых может существовать активность:

  • Начальное состояние
  • Рабочее состояние
  • Состояние паузы
  • Состояние останова

Исходное состояние включает в себя:

Созданиеновый процесс Linux, выделение новой памяти для новых объектов пользовательского интерфейса и настройка всего экрана.Таким образом, большая часть работы здесь задействована.

Состояние выполнения включает в себя:

Это действие (состояние), которое в данный момент отображается на экране.Только в этом состоянии обрабатываются такие вещи, как набор текста на экране и касание и нажатие кнопок.

Состояние паузы включает:

Когда действие не на переднем плане, а вместо этогооно находится в фоновом режиме, тогда считается, что действие находится в состоянии паузы.

Остановленное состояние включает в себя:

Остановленное действие можно приобрести только на переднем плане путем перезапускаего, а также его можно уничтожить в любой момент времени.

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

11 голосов
/ 10 июня 2016

Мне нравится этот вопрос и ответы на него, но пока нет покрытия менее часто используемых обратных вызовов, таких как onPostCreate () или onPostResume () . Стив Померой попытался изобразить диаграмму, включающую эти и их связь с жизненным циклом Android Fragment , на https://github.com/xxv/android-lifecycle.. Я пересмотрел большую диаграмму Стива, включив в нее только часть Activity , и отформатировал это для одностраничной распечатки размера письма. Я разместил его в виде текстового PDF на https://github.com/code-read/android-lifecycle/blob/master/AndroidActivityLifecycle1.pdf и ниже его изображение:

Android Activity Lifecycle

7 голосов
/ 15 декабря 2011

Со страницы разработчиков Android,

OnPause ():

Вызывается, когда система собирается возобновить предыдущее действие. Обычно это используется для фиксации несохраненных изменений в постоянных данных, остановить анимацию и другие вещи, которые могут потреблять процессор и т. д. Реализации этого метода должны быть очень быстрыми, потому что следующий активность не будет возобновлена, пока этот метод не вернется. С последующим либо onResume (), если действие возвращается назад, или onStop (), если он становится невидимым для пользователя.

OnStop ():

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

Теперь предположим, что есть три действия, и вы идете от А к В, затем onPause из A будет теперь вызываться из B в C, затем будут вызываться onPause для B и onStop of A.

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

Когда вы вызываете this.finish(), вызывается onPause-onStop-onDestroy. Главное, что нужно запомнить: приостановленные действия останавливаются, а остановленные действия уничтожаются, когда Android требует памяти для других операций.

Надеюсь, это достаточно ясно.

1 голос
/ 19 марта 2019

Запускает приложение:

Когда пользователь впервые входит в действие или приложение:

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()
1 голос
/ 10 февраля 2017

Добавление дополнительной информации поверх высоко оцененного ответа (добавлен дополнительный раздел KILLABLE и следующий набор методов, которые будут вызываться в жизненном цикле):

Источник: разработчик.android.com

enter image description here

Обратите внимание на столбец " 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() вызывается, даже если он не указан как lifeциклический метод.

...