Жизненный цикл активности Android - для чего все эти методы?

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

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

Смотрите это в Activity Lifecycle (у разработчиков Android).

onCreate () :

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

onRestart () :

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

onStart () :

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

onResume () :

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

onPause () :

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

onStop () :

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

onDestroy () :

Последний звонок, который вы получите до того, как ваша деятельность будет уничтожена Это может произойти либо из-за того, что действие заканчивается (кто-то вызвал 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");
    }
}

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

• созданный
• Начал
• Возобновился
• Приостановлено
• Остановился
• разрушенный

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

• 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()

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

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

ЖИЗНЕННЫЙ ЦИКЛ АНДРОИДА

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

• OnCreate ()
• OnStart ()
• onResume ()
• onRestart ()
• OnPause ()
• OnStop ()
• OnDestroy ()

Ответьте за то, что все эти методы для:

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

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

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 of A теперь будет вызываться из B в C, затем вызывается onPause of B и onStop of A.

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

Когда вы звоните this.finish(), вызывается onPause-onStop-onDestroy. Главное, что нужно запомнить: приостановленные действия останавливаются, а остановленные действия уничтожаются всякий раз, когда 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()вызывается, даже если он не указан как метод жизненного цикла.

Я веду некоторые журналы согласно ответам выше, и вот вывод:

Начальная деятельность

On Activity Load (First Time)
————————————————————————————————————————————————
D/IndividualChatActivity: onCreate: 
D/IndividualChatActivity: onStart: 
D/IndividualChatActivity: onResume: 
D/IndividualChatActivity: onPostResume: 

Reload After BackPressed
————————————————————————————————————————————————
D/IndividualChatActivity: onCreate: 
D/IndividualChatActivity: onStart: 
D/IndividualChatActivity: onResume: 
D/IndividualChatActivity: onPostResume: 

OnMaximize(Circle Button)
————————————————————————————————————————————————
D/IndividualChatActivity: onRestart: 
D/IndividualChatActivity: onStart: 
D/IndividualChatActivity: onResume: 
D/IndividualChatActivity: onPostResume: 

OnMaximize(Square Button)
————————————————————————————————————————————————
D/IndividualChatActivity: onRestart: 
D/IndividualChatActivity: onStart: 
D/IndividualChatActivity: onResume: 
D/IndividualChatActivity: onPostResume: 

Остановка деятельности

On BackPressed
————————————————————————————————————————————————
D/IndividualChatActivity: onPause:
D/IndividualChatActivity: onStop: 
D/IndividualChatActivity: onDestroy: 

OnMinimize (Circle Button)
————————————————————————————————————————————————
D/IndividualChatActivity: onPause: 
D/IndividualChatActivity: onStop: 

OnMinimize (Square Button)
————————————————————————————————————————————————
D/IndividualChatActivity: onPause: 
D/IndividualChatActivity: onStop: 

Going To Another Activity
————————————————————————————————————————————————
D/IndividualChatActivity: onPause:
D/IndividualChatActivity: onStop: 

Close The App
————————————————————————————————————————————————
D/IndividualChatActivity: onDestroy: 

По моему личному мнению, только два требуются onStart и onStop.

onResume, кажется, в каждом случае возврата, а onPause в каждом случае ухода (кроме закрытия приложения).