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

Question

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

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

Answer 1

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

onCreate ():

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

onRestart ():

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

onStart ():

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

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");
    }
}

Answer 2

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

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

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

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

Answer 3

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

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

Answer 4

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

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

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

---

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

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

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

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

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

onPause() - - -> onStop()

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

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

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

onStop() - - -> onDestroy()

---

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

• Начальное состояние
• Состояние бега
• Приостановлено состояние
• Остановленное состояние

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

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

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

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

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

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

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

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

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

Answer 5

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

Answer 6

Со страницы разработчиков 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 требуется память для других операций.

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

Answer 7

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

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

onCreate(),

onStart() and 

onResume()

Когда вы запускаете приложение из Android Studio:

onCreate(),

onStart() and 

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

Answer 8

Добавление дополнительной информации поверх высоко оцененного ответа (добавлен дополнительный раздел 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() вызывается, даже если он не указан как метод жизненного цикла.

Answer 9

Я провожу несколько журналов в соответствии с ответами выше, и вот результат:

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

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 - в каждом случае выхода (за исключением закрытия приложения).

Answer 10

Начните с основ. У меня есть много уроков, связанных с компонентами, осведомленными о жизненном цикле. Вы изучаете жизненный цикл, поскольку ваш вопрос будет https://www.youtube.com/watch?v=e-ews5dRMwI