Активность и её жизненный цикл

Автор: | 16.06.2018

Класс Acitvity является важнейшим компонентом Android-приложения, а способ запуска и компоновки является фундаментальной частью платформы Android. В отличие от парадигм программирования, где приложение запускается в методе main(), система Android инициирует код в экземпляре Activity, вызывая специальные коллбэки, которые соответствуют конкретным этапам жизненного цикла активности (подробнее о жизненном цикле активности будет сказано ниже).

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

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

Есть различные разновидности активностей, хотя все они так или иначе являются наследниками базового класса Activity. Например, если используется библиотека поддержки, то при создании нового проекта Android Studio  генерирует класс MainActivity, который наследует от AppCompatAcitivty. Если посмотреть иерархию наследования, то в результате можно увидеть, что в начале этой иерархии будет находиться класс Activity.

Активность представляет собой окно, в котором приложение рисует свой UI. Это окно обычно полностью заполняет экран, но может быть меньше экрана или находиться поверх других окон. Как правило, одна активность представляет собой один экран в приложении. Например, одна активность может реализовывать окно настроек, в то время как другая — окно с выбором фото.

Большинство приложений имеют несколько экранов, из чего можно сделать вывод, что они содержат несколько активностей. Как правило, одна из активностей определяется как главная и является первым экраном, появляющимся при запуске пользователем приложения. Затем каждая активность может запустить другую активность для выполнения каких-либо действий. На примере Gmail можно увидеть, что главной активностью является экран со списком писем. Из этой активности можно запустить активность, которая отвечает за создание и отправку новых писем, или любую другую.

Несмотря на то, что активности работают вместе, чтобы организовать хороший пользовательский интерфейс в приложении, каждая активность слабо связано с другими: обычно в приложении есть минимальные зависимости между активностями. Кроме того, активности часто запускают активности других приложений. Например, активность веб-браузера может запустить активность приложения социальной сети.

Рассмотрим на примере, как добавить в приложение новую активность. Создадим в Android Studio новый пустой проект. По умолчанию, в приложении создаётся одна главная активность, называемая MainActivity. При этом в проекте происходят следующие действия.

Создаётся одноимённый класс MainActivity.java. В этом классе будет реализовываться вся работа активности, при создании в ней уже есть переопределённый метод onCreate() и загрузка разметки активности.

public class MainActivity extends AppCompatActivity {
  @Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
  }
}

Как уже говорилось выше, метод setContentView() загружает разметку активности. Эта разметка берётся из XML-файла, который размещается в /res/layout. При создании проекта там уже находится сгенерированный файл activity_main.xml, идентификатор которого и передаётся в параметры setContentView(). Как правило, идентификатор идентичен названию файла. Если заглянуть в этот файл, то можно увидеть там TextView с надписью Hello World!, размещённое в центре экрана. Таким образом, то, что будет в коде этого файла, и увидит пользователь при запуске активности, для которой эта разметка установлена.

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity"
    >

  <TextView
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:text="Hello World!"
      app:layout_constraintBottom_toBottomOf="parent"
      app:layout_constraintLeft_toLeftOf="parent"
      app:layout_constraintRight_toRightOf="parent"
      app:layout_constraintTop_toTopOf="parent"
      />

</android.support.constraint.ConstraintLayout>

Чтобы приложение могло использовать активность, она должна быть зарегистрирована в манифесте приложения. IDE уже сделала это за разработчика, если открыть файл AndroidManifest.xml, то можно обнаружить там внутри <application> элемент <activity> с именем, аналогичным имени активности.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="ru.androidtools.test">

  <application
      android:allowBackup="true"
      android:icon="@mipmap/ic_launcher"
      android:label="@string/app_name"
      android:roundIcon="@mipmap/ic_launcher_round"
      android:supportsRtl="true"
      android:theme="@style/AppTheme">
    <activity android:name=".MainActivity">
      <intent-filter>
        <action android:name="android.intent.action.MAIN"/>

        <category android:name="android.intent.category.LAUNCHER"/>
      </intent-filter>
    </activity>
  </application>

</manifest>

Как уже говорилось выше, одна из активностей в приложении должна быть главной. Поэтому внутри <activity> был автоматически добавлен интент-фильтр со следующими параметрами:

  • android.intent.action.MAIN — сообщает системе о том, что данная активность является главной.
  • android.intent.category.LAUNCHER — сообщает системе о том, что приложение должно показываться в списке приложений.

Вот всё, что нужно для того, чтобы создать активность. Подводя итог, можно сказать, что для создания активности Android Studio выполняет 3 шага:

  1. Создание класса, наследующего от класса Activity.
  2. Создание XML-файла разметки.
  3. Регистрация активности в манифесте приложения.

Ничто не мешает разработчику выполнять эти шаги вручную, однако намного проще воспользоваться возможностями Android Studio, которая в разы ускоряет этот процесс. Допустим, нам понадобилось добавить в проект вторую активность. Для того, чтобы добавить новую активность нужно в контекстном меню выбрать New — Activity. В списке будет предложено выбрать несколько активностей с уже готовыми компонентами (например, активность с настройками). Чтобы создать активность без лишних компонентов, нужно выбрать Empty Activity.

Откроется окно, в котором будет предложено ввести название новой активности и название XML-файла разметки.

Жмём Finish и видим, что Android Studio добавила все необходимые файлы для активности.

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

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

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

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

Для навигации между этапами жизненного цикла активности класс Activity предоставляет базовый набор из шести коллбэков: onCreate(), onStart(), onResume(), onPause(), onStop() и onDestroy(). Система вызывает каждый из этих коллбэков как только активность переходит в новое состояние.

По мере того, как пользователь начинает покидать активность, система вызывает методы для её демонтажа. В некоторых случаях этот демонтаж является лишь частичным, активность по-прежнему сохраняется в памяти (например, когда пользователь переключается на другое приложение) и все ещё может вернуться на передний план. Если пользователь возвращается к активности, она возобновляется с того места, где пользователь остановился. Вероятность, что система ликвидирует процесс  — вместе с активностью — зависит от состояния активности в этот момент времени.

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

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

public void onCreate() {
  super.onCreate();
  // пишем код после вызова суперкласса
}

Во время деинициализации наоборот нужно выполнить всю работу и только потом вызвать суперкласс:

public void onPause() {
  // пишем код перед вызовом суперкласса
  super.onPause();
}

onCreate()

Этот метод обратного вызова срабатывает, когда система создаёт активность. Его наличие обязательно, поскольку здесь выполняется первоначальная настройка активности. В этом методе активность переходит в состояние Created. В методе onCreate() нужно выполнять основную логику запуска, которая должна выполниться только один раз. Например, реализация onCreate() может привязать данные к спискам, ассоциировать активность с ViewModel и создать экземпляры некоторых переменных. Этот метод принимает в качестве параметра savedInstanceState, который представляет собой объект Bundle, содержащий ранее сохраненное состояние активности. Если активность ранее не существовала, значение объекта Bunde будет равно null.

После того, как onCreate() завершит выполнение, активность переходит в состояние Started и система следом вызывает onStart() и onResume().

onStart()

Когда активность переходит в состояние Started, система вызывает этот метод. Вызов onStart() делает активность видимой для пользователя, так как приложение готовится к переходу активности на передний план и становится интерактивной. Например, здесь можно реализовывать код, который будет поддерживать пользовательский интерфейс.

Метод onStart() завершается очень быстро и, как и с onCreate(), активность не остаётся в состоянии Started, а переходит в состояние Resumed, после чего система вызывает метод onResume().

onResume()

Когда активность переходит в состояние Resumed, она выходит на передний план, а затем система вызывает метод onResume(). Это состояние, в котором приложение взаимодействует с пользователем. Приложение остается в этом состоянии, пока не произойдёт что-то, что переключит фокус с приложения. К таким событиям можно отнести, например, входящий вызов, переход пользователя на другую активность или выключение экрана устройства.

Когда происходит событие, прерывающее текущее состояние, активность переходит в состояние Paused и система вызывает метод onPause().

onPause()

Метод onPause() является первым признаком того, что пользователь покидает активность. Это не всегда означает, что активность уничтожается, она просто перестаёт находиться на переднем плане (хотя может оставаться видимой, если пользователь находится в многооконном режиме). Метод onPause() следует использовать для приостановки или регулирования операций, которые не должны продолжаться пока активность находится в состоянии Paused и ожидает возобновления. Существует несколько причин, по которым активность может войти в это состояние:

  • Некоторые события прерывают выполнение приложения, как описано в части про onResume(). Это самый распространенный случай.
  • В Android 7.0 (API 24) или выше несколько приложений могут работать в многооконном режиме. Поскольку только одно из приложений имеет фокус в момент времени, система приостанавливает работу всех других приложений.
  • Открывается новая полупрозрачная активность (например, диалог). Пока активность ещё частично видимо, но не в фокусе, она остаётся приостановленной.

Метод onPause() можно также использовать для освобождения системных ресурсов, регулирования сенсоров или любых других ресурсов, которые могут влиять на расход батареи, пока активность приостановлена. Однако, как уже говорилось, активность в состоянии Paused может быть ещё частично видимой, поэтому лучше всего использовать для освобождения ресурсов onStop() вместо onPause().

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

Завершение метода onPause() не означает, что активность выходит из состояния Paused. Скорее активность останется в этом состоянии до тех пор, пока не возобновится или не станет полностью невидимой для пользователя. Если активность возобновляется, система снова вызывает метод onResume(). Если активность возвращается из состояния Paused в состояние Resumed, система сохраняет экземпляр Activity в памяти, вызывает его в методе onResume(). В этом случае не нужно повторно инициализировать компоненты, созданные ранее. Если активность становится полностью невидимой, система вызывает метод onStop().

onStop()

Когда активность больше не видна пользователю, она переходит в состояние Stopped, и система вызывает метод onStop(). Это может произойти, например, когда вновь запущенная активность охватывает весь экран. Система также может вызвать onStop(), когда активность завершила свою работу и вот-вот будет уничтожена.

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

onStop() также следует использовать для выполнения относительно затратных в плане расхода CPU операций. Например, если не удается найти более подходящее время для сохранения информации в базе данных, это можно сделать в onStop().

Когда активность переходит в состояние Stopped, экземпляр Activity сохраняется в памяти: он содержит всю необходимую информацию, но не привязан к менеджеру окон. Поэтому при восстановлении не нужно заново инициализировать все компоненты. Система также отслеживает текущее состояние для каждого объекта View в разметке, поэтому, если пользователь вводит текст в виджет EditText, то этот контент сохранится и затем восстановится.

Примечание: Как только активность окажется остановленной, система может уничтожить процесс, который содержит активность, чтобы чтобы освободить память для своих нужд. Даже если система уничтожит процесс, она продолжает сохранять состояния объектов View (например, текст в EditText) в Bundle (парах «ключ-значение«) и восстанавливать их, когда пользователь возвращается в активность.

В состоянии Stopped активность либо возвращается для взаимодействия с пользователем, либо полностью завершается. Если активность возвращается, система вызывает onRestart(). Если активность завершается, система вызывает метод onDestroy().

onDestroy()

Метод onDestroy() вызывается до того, как активность будет уничтожена. Система вызывает этот метод по следующим причинам:

  • Активность завершает свою работу поскольку пользователь закрывает активность либо в приложении вызывается метод finish().
  • Система временно уничтожает активность из-за изменения конфигурации (например, поворот устройства или использование многооконного режима).

Если активность прекращает работу, то onDestroy() — это последний коллбэк жизненного цикла активности. Если onDestroy() вызывается в результате изменения конфигурации, система немедленно создаёт новый экземпляр активности и затем вызывает onCreate() в новом экземпляре.

Метод onDestroy() освобождает все ресурсы, которые ещё не были освобождены в методах ранее, такими как onStop().

Посмотрим на примере приложения, как это всё работает. Возьмём проект, который создали ранее, и переопределим в коде MainActivity все коллбэки жизненного цикла активности. Затем добавим в них показ всплывающих сообщений, чтобы знать, в какой момент какое состояние вызывается. В результате получается следующий код:

public class MainActivity extends AppCompatActivity {

  @Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    Toast.makeText(this, "Вызван onCreate()", Toast.LENGTH_SHORT).show();
  }

  @Override protected void onStart() {
    super.onStart();
    Toast.makeText(this, "Вызван onStart()", Toast.LENGTH_SHORT).show();
  }

  @Override protected void onPause() {
    Toast.makeText(this, "Вызван onPause()", Toast.LENGTH_SHORT).show();
    super.onPause();
  }

  @Override protected void onResume() {
    super.onResume();
    Toast.makeText(this, "Вызван onResume()", Toast.LENGTH_SHORT).show();
  }

  @Override protected void onStop() {
    Toast.makeText(this, "Вызван onStop()", Toast.LENGTH_SHORT).show();
    super.onStop();
  }

  @Override protected void onDestroy() {
    Toast.makeText(this, "Вызван onDestroy()", Toast.LENGTH_SHORT).show();
    super.onDestroy();
  }
}

Читайте также

Активность и её жизненный цикл: 1 комментарий

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *