Сохранение состояния Активности. Часть 3 (практика)

Мое приложение AP003 продолжает эволюционировать.

Я добавил два поля EditText, одно с ID другое без него (бирюзового цвета). А так же еще одно поле TextView, в которое буду записывать сохраненные данные из поля EditText. Приведу скрин для наглядности:



Розовое поле EditText имеет ID, бирюзовое – нет. В элемент TextView с текстом “Просто текст”, будет писаться сохраненное значение из розового поля EditText.

Код разметки layout_a.xml

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#f20808"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context=".ActivityA" >

    <TextView
        android:id="@+id/textView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/strA" />

    <Button
        android:id="@+id/buttonStartB"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentLeft="true"
        android:layout_below="@+id/textView1"
        android:onClick="onClickStartB"
        android:text="Start Activity B" />

    <TextView
        android:id="@+id/textStateActA"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignLeft="@+id/buttonStartB"
        android:layout_below="@+id/buttonStartB"
        android:background="#fffcfc"
        android:text="Этот экземпляр АсtivityA запущен в первый раз" />

    <TextView
        android:id="@+id/textActCountA"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignLeft="@+id/textStateActA"
        android:layout_below="@+id/textStateActA"
        android:layout_marginTop="15dp"
        android:background="#fffcfc"
        android:text="TextView" />

    <EditText
        android:id="@+id/editTextA"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignLeft="@+id/textActCountA"
        android:layout_below="@+id/textActCountA"
        android:layout_marginTop="15dp"
        android:background="#ffaacc"
        android:ems="10" />

    <TextView
        android:id="@+id/textViewA"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignLeft="@+id/editTextA"
        android:layout_below="@+id/editTextA"
        android:layout_marginTop="14dp"
        android:background="#faaaaa"
        android:text="Просто текст" />

    <EditText
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignLeft="@+id/textViewA"
        android:layout_below="@+id/textViewA"
        android:layout_marginTop="18dp"
        android:background="#22ddff"
        android:ems="10" >

        <requestFocus />
    </EditText>

</RelativeLayout>

В строке 47 определен ID для EditText android:id="@+id/editTextA". Как видно из кода от строки 67 у другого элемента EditText нет ID. Это сделано для демонстрации того, что текст в данном поле не будет сохранятся системой при смене ориентации экрана.

В поле TextView с ID android:id="@+id/textViewA" будет писаться текст, введенный в поле с ID android:id="@+id/editTextA".

Теперь код ActivityA.java:

package com.example.ap0003;

import java.util.List;

import android.app.Activity;
import android.app.ActivityManager;
import android.app.ActivityManager.RunningTaskInfo;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.EditText;
import android.widget.TextView;

public class ActivityA extends Activity {

 final String TAG = "States";
 TextView tvTextLife, MyTextA, vTextA;
 List<ActivityManager.RunningTaskInfo> list;
 ActivityManager am;
 Integer TotalActCount;
 Boolean FirstStart;
 Boolean NextAct;
 static final String SaveTextEditA = "TEXTEDIT_A_STATE";
 SharedPreferences sPref;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState); //супер класс всегда вызывайте первым
  setContentView(R.layout.layout_a);
  
  // флаг что активность запущена впервые
  FirstStart = true;
  // кнопка запуска следующей Активности не нажималась
  NextAct = false;
  if (savedInstanceState != null) {
         // Restore value of members from saved state
   // находим текстовое поле по его идентификатору
   vTextA = (TextView) findViewById(R.id.textViewA);
   // и присваиваем ему сохраненное в методе onSaveInstanceState значение
   vTextA.setText(savedInstanceState.getString(SaveTextEditA));
   Log.d(TAG, "ActivityA: onCreate() NOT NULL: " + vTextA.getText().toString());
     } else {
         // Probably initialize members with default values for a new instance
      Log.d(TAG, "ActivityA: onCreate() NULL");
     }
  
  Log.d(TAG, "ActivityA: onCreate()");

 }

 @Override
 protected void onStart() {
  super.onStart();
  Log.d(TAG, "ActivityA: onStart()");
 }

 @Override
 protected void onResume() {
  super.onResume();
  Log.d(TAG, "ActivityA: onResume()");
  // получаем список 10 последних задач
  am = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
  list = am.getRunningTasks(10);
  // перебираем список задач и выбираем свою по имени пакета
  // com.example.ap0003
  for (RunningTaskInfo task : list) {
   if (task.baseActivity.flattenToShortString().startsWith(
     "com.example.ap0003")) {
    // находим поле для вывода информации о количестве запущенных
    // Активностей
    tvTextLife = (TextView) findViewById(R.id.textActCountA);
    TotalActCount = task.numActivities;
    // коррекция счетчика для кнопки ОБРАТНО
    if (NextAct == true & FirstStart == false)
     TotalActCount = TotalActCount - 1;
    // выводим количество Активностей в задаче
    tvTextLife.setText("Activites in task " + TotalActCount);
    // коррекция счетчика для кнопки ДОМОЙ
    NextAct = false;
   }
  }
 }

 @Override
 protected void onPause() {
  super.onPause();
  Log.d(TAG, "ActivityA: oPause()");
  // флаг что активность уже была запущена
  FirstStart = false;
  // находим текстовое поле по его идентификатору
  tvTextLife = (TextView) findViewById(R.id.textStateActA);
  // присваиваем значение атрибуту Text для выбранного TextView
  tvTextLife.setText("Этот экземпляр ActivityA уже был запущен!");

 }

 @Override
 protected void onStop() {
  super.onStop();
  Log.d(TAG, "ActivityA: onStop()");
 }

 @Override
 protected void onRestart() {
  super.onRestart();
  Log.d(TAG, "ActivityA: onRestart()");
 }

 @Override
 protected void onDestroy() {
  super.onDestroy();
  Log.d(TAG, "ActivityA: onDestroy()");
 }

 public void onClickStartB(View v) {
  Intent intent = new Intent(ActivityA.this, ActivityB.class);
  startActivity(intent);
  // кнопка запуска следующей Активности была нажата
  NextAct = true;

 }

 @Override
 protected void onSaveInstanceState(Bundle savedInstanceState) {
  // получаем ссылку на поле ввода текста
  MyTextA = (EditText) findViewById(R.id.editTextA);
  // сохраняем состояние поля ввода текста
  savedInstanceState.putString(SaveTextEditA, MyTextA.getText()
    .toString());
  Log.d(TAG, "onSaveInstanceState A text: "
    + MyTextA.getText().toString());
  // всегда вызывайте супер класс чтобы сохранить
  // состояние всех view активности
  super.onSaveInstanceState(savedInstanceState);

 }

 @Override
 protected void onRestoreInstanceState(Bundle savedInstanceState) {
  super.onRestoreInstanceState(savedInstanceState);
  // находим текстовое поле по его идентификатору
  vTextA = (TextView) findViewById(R.id.textViewA);
  // и присваиваем ему сохраненное в методе onSaveInstanceState значение
  vTextA.setText(savedInstanceState.getString(SaveTextEditA));
  Log.d(TAG, "onRestoreInstanceState A: " + vTextA.getText().toString());
 }

}

Теперь приведу скрины и логи работы приложения.

И так запускаем приложение и вводим в поля для ввода текста следующий текст:



И так приложение было запущенно впервые. Мы ввели текст в соответствующие поля. Теперь посмотрим логи работы приложения.



В логах видим как отработали строки кода 46 (поскольку еще не было сохранения данных в Bundle) и строка 49.

Теперь нажмем кнопку HOME и посмотрим что будет.



И так мы видим что сработал метод onSaveInstanceState() перед методом onPause(). При выводе в отладке текста который мы ввели в поле сработала строка 132. Теперь наша Активность А находится в остановленном состоянии. Вернемся к ней жмакнув по ее иконке в списке приложений.

Мы увидим следующее



Текст сохранился в обоих полях ввода, так как Активность А не была уничтожена, а была просто остановлена. Посмотрим логи.



Логи это же и показывают, что активность была выведена из остановленного состояния в активное. Метод onCreate() не был запущен, так как Активность А не уничтожалась.

Теперь повернем экран. И посмотрим что будет.



Посмотрим логи.



Как видно из логов, при повороте экрана Активность А уничтожается, но перед этим вызывается метод onSaveInstanceState(). Затем в методе onCreate() происходит восстановление данных и их запись в поле TextView (строки 30 и 42), так как объект Bundle у нас уже не равен null. Так же восстановление данных происходит в методе onRestoreInstanceState(). Эти два метода дублирую друг друга, можно было бы обойтись любым из них, но так как это учебный пример, то это сделано для наглядности и пущего понимания процессов.

Теперь добавим в розовое поле ввода текста три восклицательных знака, а в бирюзовое снова введем любой текст.



А затем снова повернем экран.



Как видим текст в полях стал одинаковым. Так как сработали вышеописанные методы.

Посмотрим логи.



Собственно из логов видно, что перед уничтожением Активности А, измененный текст (с добавленными !!!) был сохранен, а затем восстановлен. Текст же в бирюзовом поле все время, после уничтожения Активности А, исчезает, так как у этого поля нет ID.

В общем все как было описано в матчасти.

Теперь, ради более полного понимания, закомментируем строки 136 и 142 которые вызывают суперкласс в методах onSaveInstanceState() и onRestoreInstanceState(). И посмотрим что будет.

Примечание: Вызов суперкласса в методе onCreate() закомментировать нельзя, иначе приложение просто не запуститься.

И так запускаем измененное приложение и вводим текст в поля.



Логи:



Теперь повернем экран



И посмотрим логи



Как видим сработали все наши методы, НО текст в розовом поле не был восстановлен, так как мы не вызвали СУПЕРКЛАСС и поэтому было сохранено и сделано только то, что мы явно указали.

И так, опять, все как в матчасти.

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

И на последок еще линки для внимательного изучения по данной теме, и немного текста с этих источников, а то вдруг они исчезнут.

Методы Активности.

И текст по теме от туда.

Метод onSaveInstanceState()

Когда система завершает активность в принудительном порядке, чтобы освободить ресурсы для других приложений, пользователь может снова вызвать эту активность с сохранённым предыдущим состоянием. Чтобы зафиксировать состояние активности перед её уничтожением, в классе активности необходимо реализовать метод onSaveinstancestate().

Сам метод вызывается прямо перед методом onPause(). Он предоставляет возможность сохранять состояние пользовательского интерфейса активности в объект Bundle, который потом будет передаваться в методы onCreate() и onRestoreInstanceState(). В объект Bundle можно записать параметры, динамическое состояние активности как пары имя-значение. Когда активность будет снова вызвана, объект Bundle передается системой в качестве параметра в метод onCreate() и в метод onRestoreInstanceState(), которыЙ вызывается после onStart(), чтобы один из них или они оба могли установить активность в предыдущее состояние. Прежде чем передавать изменённый параметр Bundle в обработчик родительского класса, сохраните значения с помощью методов getXXX() и putXXX().

Используйте обработчик onSaveInstanceState() для сохранения состояния интерфейса (например, состояния флажков, текущего выделенного элемента или введенных, но не сохраненных данных), чтобы объект Activity при следующем входе в активное состояние мог вывести на экран тот же UI. Рассчитывайте, что перед завершением работы процесса во время активного состояния будут вызваны обработчики onSaveInstanceState и onPause.

В отличие от базовых методов, методы onSaveInstanceState() и onRestoreInstanceState() не относятся к методам жизненного цикла активности. Система будет вызывать их не во всех случаях. Например, Android вызывает onSaveinstancestate() прежде, чем активность становится уязвимой к уничтожению системой, но не вызывает его, когда экземпляр активности разрушается пользовательским действием (при нажатии клавиши BACK). В этом случае нет никаких причин для сохранения состояния активности.

Метод onSaveInstanceState() вызывается системой в случае изменения конфигурации устройства в процессе выполнения приложения (например, при вращении устройства пользователем или выдвижении физической клавиатуры устройства.

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


Метод onRestoreInstanceState()

У метода onRestoreInstanceState() есть такой же параметр Bundle, как у onCreate(), и вы можете восстанавливать сохранённые значения из метода onSaveInstanceState().

Метод вызывается после метода onStart(). Система вызывает метод onRestoreInstanceState() только в том случае, если имеются сохранённые данные для восстановления. Таким образом вам не нужно проверять Bundle на null, как в методе onCreate().

Сохранение состояния Активности. Часть 2

Все таки еще немножко теории будет с альма-матер. Сделаю очень краткий и очень вольный перевод.

И еще немножко будет из этой статьи.

Существует несколько вариантов при которых ваша Активность может быть уничтожена в следствии естественного поведения приложения, например, если пользователь нажимает кнопку ОБРАТНО или же если ваша активность получает сигнал от метода finish(). Система так же может уничтожить вашу Активность если она в данный момент остановлена и не используется уже долгое время находясь в фоновом режиме. В этом случае если системе будут нужны ресурсы, она может уничтожить вашу Активность.

Когда Активность уничтожается естественным образом, например, если пользователь нажимает кнопку ОБРАТНО или же Активность уничтожает сама себя, система полагает что экземпляр Активности больше не нужен, так как это понятно из поведения самой Активности, и не запоминает ее состояние. Однако же, если система уничтожает Активность находящуюся в фоновом режиме, для высвобождения ресурсов, то система понимает, что состояние Активности надо сохранить, чтобы когда она будет создана заново, данные которые были в ней, вновь бы в ней отобразились. Сохраненные данные, которые система использует для восстановления состояния Активности, называются instance state, и они содержат пары в виде “ключ-значение” которые хранятся в объекте Bundle.

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

По умолчанию, система использует объект Bundle, чтобы сохранить состояние каждого View в разметке (layout), например текст введенный в поле EditText. Таким образом, если Активность уничтожается, то ее состояние восстанавливается АВТОМАТИЧЕCКИ и вам не надо писать для этого ни какой дополнительный код. Однако, ваша Активности может иметь какие-то дополнительные данные которые надо сохранять и восстанавливать, то в этом случае вам надо переопределить метод  onSaveInstanceState() для сохранения этих данных. При вызове этого метода система передает данные для сохранения в объект Bundle, который будет сохранен, даже если ваша Активность будет уничтожена. Когда же Активность создается, то она получает тот же объект Bundle в методах onCreate() и onRestoreInstanceState().

Еще раз напомним что для того чтобы система Андроид автоматически восстанавливала данные каждого View он должен иметь уникальный идентификатор ID, определяемый атрибутом android:id.



На рисунке показано, что когда система начинает останавливать вашу Активность, то перед этим вызывается метод onSaveInstanceState() (1), в котором вы можете так же сохранить дополнительные нужные вам данные, которые затем можете восстановить когда Активность будет создана заново. После уничтожения Активности, когда ее экземпляр создается заново, система передает ей данные сохраненные на этапе (1) в методах  onCreate() (2) и onRestoreInstanceState() (3).

Сохранение состояния Активности

Когда ваша Активность останавливается системой, то вызывается метод onSaveInstanceState(), который сохраняет состояние Активности в наборе пар “ключ-значение”. По умолчанию этот метод сохраняет состояние всех View в layout, например текст введенный в поле EditText или же положение прокрутки в ListView. Чтобы сохранить дополнительные данные из вашей Активности вы должны переопределить метод   onSaveInstanceState() и добавить дополнительные пары “ключ-значение” в объект Bundle. Например:

static final String STATE_SCORE = "playerScore";
static final String STATE_LEVEL = "playerLevel";
...

@Override
public void onSaveInstanceState(Bundle savedInstanceState) {
    // Save the user's current game state
    savedInstanceState.putInt(STATE_SCORE, mCurrentScore);
    savedInstanceState.putInt(STATE_LEVEL, mCurrentLevel);
    
    // Always call the superclass so it can save the view hierarchy state
    super.onSaveInstanceState(savedInstanceState);
}

Внимание! Всегда вызывайте суперкласс метода onSaveInstanceState(), чтобы сохранить значение всех View.


Восстановление состояния Активности

Когда ваша активность воссоздаётся после того как была разрушена вы можете восстановить ее состояние из объекта Bundle, который система передает в вашу активность. Оба метода onCreate() и onRestoreInstanceState() при вызове получают один и тот же объект Bundle, содержащий информацию для восстановления состояния.

Поскольку метод onCreate() вызывается когда экземпляр вашей Активности создается заново, вы должны проверить состояние объекта Bundle на null, перед тем как пытаться прочитать из него данные. Если его состояние равно null, тогда система создаст новый экземпляр активности, а не будет восстанавливать предыдущий, который был уничтожен.

Пример восстановления состояния в методе onCreate():

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState); // Always call the superclass first
   
    // Check whether we're recreating a previously destroyed instance
    if (savedInstanceState != null) {
        // Restore value of members from saved state
        mCurrentScore = savedInstanceState.getInt(STATE_SCORE);
        mCurrentLevel = savedInstanceState.getInt(STATE_LEVEL);
    } else {
        // Probably initialize members with default values for a new instance
    }
    ...
}

Так же вы можете восстанавливать состояние Активности в методе onRestoreInstanceState(), который вызывается после метода onStart(). Система вызывает метод onRestoreInstanceState() только в том случае если имеются сохраненные данные для восстановления, поэтому нет ни какой необходимости проверять Bundle на null. Например:

public void onRestoreInstanceState(Bundle savedInstanceState) {
    // Always call the superclass so it can restore the view hierarchy
    super.onRestoreInstanceState(savedInstanceState);
   
    // Restore state members from saved instance
    mCurrentScore = savedInstanceState.getInt(STATE_SCORE);
    mCurrentLevel = savedInstanceState.getInt(STATE_LEVEL);
}

Внимание! Всегда вызывайте суперкласс метода onRestoreInstanceState(), чтобы сохранить значение всех View.

Далее попрактикуемся в этом чуть больше, чтобы понять получше эту тему.

Сохранение состояния Активности. Часть 1

Продолжаем перевод статьи с альма-матер. Начало статьи тут.

В начале надо сказать, что пользоваться эмулятором AVD для Android 2.3.3, крайне не рекомендуется, так как он крайне глюкавый, как оказалось. Выражалось это в том, что он ни как не отображал вызов метода onRestoreInstanceState, а так же не корректно отображал поведение приложения при повороте экрана. Поэтому рекомендую использовать Genymotion или же реальное устройство для тестирования приложения которое я приведу ниже.

А сейчас продолжение перевода.

Система вызывает метод onSaveInstanceState() перед тем как активность может быть уничтожена. Система передает в этот метод объект Bundle, в котором вы можете сохранить состояние параметров активности в виде пар “параметр”-“значение”, используя такие методы как putString() и putInt(). Затем, если система уничтожает процесс вашего приложения, а пользователь решает вернуться к вашей Актиновсти, то система восстанавливает Активность и передает ей объект Bundle в методах onCreate() и onRestoreInstanceState().Используя эти методы вы можете извлечь сохраненные данные из объекта Bundle и восстановить состояние Активности. Если же ни какой информации для восстановления нет, то объект Bundle вернет вам значение null (обычно такое бывает в случае когда активность создается в первый раз).

На рисунке показано два варианта когда Активность получает фокус и ее состояние сохраняется и восстанавливается или остается не тронутым. Если Активность уничтожается и затем воссоздается, то ее состояние восстанавливается из сохраненного состояния. Если же Активность была приостановлена и затем ее работа была возобновлена, то ее состояние остается нетронутым.

И еще раз приведу интересное замечание из предыдущей статьи.

Нет ни какой гарантии что onSaveInstanceState() будет вызвана перед тем как ваша Активность будет уничтожена, поскольку есть случаи в которых сохранение состояния не является необходимым (например, когдапользователь покидает вашу активность используя кнопку ОБРАТНО, то это означает, что пользователь сам прекратил работу с Активностью). Если система вызывает onSaveInstanceState(), то делает это до onStop() ивозможно перед onPause().

Однако, даже если вы не используете метод onSaveInstanceState(), некоторые данные состояния Активности восстанавливаются классом Активности по умолчанию поскольку к ним по умолчанию применяется метод onSaveInstanceState(). В частности метод onSaveInstanceState(), по умолчанию, сохраняется состояние каждого View в разметке (layout). Почти каждый виджет в Андроид использует этот метод для сохранения своего состояния, так чтобы любые видимые изменения в UI сохранялись и восстанавливались автоматически при воссоздании Активности. Например, виджет EditText сохраняет любой текст введенный в него пользователем, а виджет CheckBox сохраняет состояние был он отмечен или нет. Единственное что от вас требуется для этого, то это присвоить каждому виджету, состояние которого вы хотите сохранить, уникальный идентификатор ID (атрибут android:id). Если у виджета нет ID, то система не сможет сохранить его состояние.

Хотя метод onSaveInstanceState() и сохраняет, по умолчанию, состояние UI Активности, все же иногда может потребоваться его переопределить, чтобы сохранить дополнительную информацию. Для этого вы всегда должны вызывать суперкласс метода onSaveInstanceState() перед тем как сделаете, что либо еще. Так же необходимо будет переопределить и метод onRestoteInstanceState() вызвав его суперкласс и восстановив необходимую дополнительную информацию.

При необходимости, вы можете предотвратить чтобы представления (view) сохраняли свое состояние установив значение атрибута android:saveEnabled в false или же воспользовавшись методом setSaveEnabled(). Хотя обычно в этом нет необходимости, но все же у вас есть возможность сохранять состояние UI активности другим способом.

Примечание: Поскольку не гарантируется что метод onSaveInstanceState() будет вызван, вы должны использовать его только для сохранения временных данных состояния UI Активности и ни когда не использовать его для сохранения постоянных данных. Вместо него вы должны использовать метод onPause() для сохранения постоянных данных, если это необходимо, кода пользователь покидает Активность.

В следующей части будет немного практики на эту тему.