Жизненный цикл Activity в Android (часть 3)

Опять же по следам этой статьи (не всей):
http://developer.alexanderklimov.ru/android/theory/activity_methods.php
Автор забыл в начале статьи приложить блок схему, что мы исправим для пущего понимания

При переходе активности от одного состояния к другому, она получает уведомления через защищенные методы:

• protected void onCreate();
• protected void onStart();
• protected void onRestart();
• protected void onResume();
• protected void onPause();
• protected void onStop();
• protected void onDestroy()

Семь перечисленных методов определяют весь жизненный цикл активности. Есть три вложенных цикла, которые вы можете отслеживать в классе активности:

• полное время жизни (Full Lifetime) — время с момента первого вызова метода onCreate() до вызова onDestroy(). Активность делает всю начальную установку своего глобального состояния в методе onCreate() и освобождает все остающиеся ресурсы в onDestroy(). Например, если активность порождает дополнительный поток, выполняющийся в фоновом режиме, можно создать этот поток в методе onCreate() и затем остановить поток в методе onDestroy();
• видимое время жизни (Visible Lifetime) — время между вызовом метода onStart() и вызовом onStop(). В это время пользователь может видеть окно активности на экране, хотя окно может не быть на переднем плане и может не взаимодействовать с пользователем. Между этими двумя методами вы можете поддерживать в коде ресурсы, которые необходимы, чтобы отображать активность пользователю;
• активное время жизни (Active Lifetime) — время между вызовами onResume() и onPause(). В это время окно активности находится на переднем плане и взаимодействует с пользователем. Активность в процессе работы приложения может часто переходить между состояниями active и paused, поэтому код в этих двух методах должен быть или небольшим по объему (чтобы не замедлять работу приложения во время выполнения), или порождать дополнительные потоки, если требуется выполнение задач, занимающих длительное время.Можно написать код с заглушками для методов внутри Активности, которые обрабатывают изменения состояний. Комментарии к каждой такой заглушке описывают действия, которые нужно учитывать при обработке этих событий.

import android.app.Activity;
import android.os.Bundle;

public class MyActivity extends Activity {
    // Вызывается при входе в "полноценное" состояние.
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // Инициализируйте Активность.
    }
    
    // Вызывается, когда метод onCreate завершил свою работу, 
    // и используется для восстановления состояния пользовательского 
    // интерфейса
    @Override
    public void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
        // Восстановите состояние UI из переменной savedInstanceState.
        // Этот объект типа Bundle также был передан в метод onCreate.
    }
    
    // Вызывается перед тем, как Активность становится "видимой".
    @Override
    public void onRestart(){
        super.onRestart();
        // Загрузите изменения, учитывая то, что Активность
        // уже стала "видимой" в рамках данного процесса.
    }
    
    // Вызывается в начале "видимого" состояния.
    @Override
    public void onStart(){
        super.onStart();
        // Примените к UI все необходимые изменения, так как
        // Активность теперь видна на экране.
    }
    
    // Вызывается в начале "активного" состояния.
    @Override
    public void onResume(){
        super.onResume();
        // Возобновите все приостановленные обновления UI,
        // потоки или процессы, которые были "заморожены",
        // когда данный объект был неактивным.
    }
    
    // Вызывается для того, чтобы сохранить пользовательский интерфейс
    // перед выходом из "активного" состояния.
    @Override
    public void onSaveInstanceState(Bundle savedInstanceState) {
        // Сохраните состояние UI в переменную savedInstanceState.
        // Она будет передана в метод onCreate при закрытии и
        // повторном запуске процесса.
        super.onSaveInstanceState(savedInstanceState);
    }
    
    // Вызывается перед выходом из "активного" состояния
    @Override
    public void onPause(){
        // "Замораживает" пользовательский интерфейс, потоки 
        // или трудоемкие процессы, которые могут не обновляться, 
        // пока Активность не находится на переднем плане.
        super.onPause();
    }
    
    // Вызывается перед тем, как Активность перестает быть "видимой".
    @Override
    public void onStop(){
        // "Замораживает" пользовательский интерфейс, потоки 
        // или операции, которые могут подождать, пока Активность
        // не отображается на экране. Сохраняйте все введенные
        // данные и изменения в UI так, как будто после вызова
        // этого метода процесс должен быть закрыт.
        super.onStop();
    }
    
    // Вызывается перед выходом из "полноценного" состояния.
    @Override
    public void onDestroy(){
        // Очистите все ресурсы. Это касается завершения работы
        // потоков, закрытия соединений с базой данных и т. д.
        super.onDestroy();
    }
}

Как видно из кода, переопределяя эти обработчики, вы всегда должны вызывать одноименные методы родительского класса.

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

При реализации любого из этих методов необходимо всегда сначала вызывать версию этого метода из суперкласса. Например:

public void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
        ...
}

protected void onPause()
{
    super.onPause();
    ...
}