Как вызываются и выполняются функции Activity, такие как onStart (), onCreate (), onResume ()? [Дубликат]

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

ANDROID LIFE-CYCLE

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

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

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

Возьмем простой сценарий, в котором знание того, в каком порядке эти методы

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

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

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

onPause() - - -> onStop()

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

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

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

onStop() - - -> onDestroy()

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

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

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

Создание нового процесса Linux, выделение новой памяти для нового UI и настройку всего экрана. Поэтому основная часть работы здесь задействована.

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

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

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

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

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

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

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

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

Диаграмма активности может быть интерпретирована как:

[/g0]

На странице Android Developers

onPause ():

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

onStop ():

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

Теперь предположим, что есть три действия, и вы переходите от От A до B, то onPause от A будет теперь вызываться от B до C, затем на Pause B и onStop A будет вызываться.

Приостановленное действие получает Возобновление и Stopped перезапускается.

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

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

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

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

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

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

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

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

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

[/g6]

Ситуации

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

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