Что такое activity в android
Перейти к содержимому

Что такое activity в android

  • автор:

Activity (Активность, Деятельность)

Термин Activity еще не устоялся в русском языке у разработчиков. Некоторые используют слово Активность, другие — Деятельность. Чтобы не путаться в названиях, я буду использовать термин Активность (смотри примечание).

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

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

Примечание: Если у слова activity взять первые три символа и перемешать, то получим cat, впрочем из слова активность тоже можно получить кота.

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

Чтобы создать активность, нужно унаследоваться от класса Activity и вызвать метод onCreate(). В результате мы получим пустой экран. Толку от такого экрана никакого. Поэтому в активность добавляют компоненты, фрагменты с помощью разметки.

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

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

  • активная (active или running) — активность находится на переднем плане экрана. Пользователь может взаимодействовать с активным окном;
  • приостановленная (paused) — активность потеряла фокус, но все еще видима пользователю. То есть активность находится сверху и частично перекрывает данную активность. Приостановленная активность может быть уничтожена системой в критических ситуациях при нехватке памяти;
  • остановленная (stopped) — если данная активность полностью закрыта другой активностью. Она больше не видима пользователю и может быть уничтожена системой, если память необходима для более важного процесса.

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

Активность в виде диалогового окна

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

Напишем код для запуска:

 @Override public void onCreate(Bundle savedInstanceState)

Обратите внимание, что в данном примере мы не используем разметку, а программно создаём экземпляр класса TextView с необходимыми свойствами (текст, отступы) и передаём его в метод setContentView().

Dialog

Програмнное создание активности

В основном мы пользуемся XML-разметкой для формирования внешнего вида активности. Это рекомендованный способ и в 99% вы будете использовать именно его. Но в некоторых случаях возможно вам понадобится создать активность программно. Сложного там ничего нет, для общего развития пригодится.

Если в стандартном случае мы подключаем XML-файл в методе setContentView(R.layout.activity_main), то при программном создании данный метод нам не понадобится. Удаляем его и пишем код:

 package ru.alexanderklimov.test; import android.app.Activity; import android.content.Context; import android.content.Intent; import android.os.Bundle; import android.view.View; import android.view.View.OnClickListener; import android.widget.ImageView; import android.widget.LinearLayout; import android.widget.LinearLayout.LayoutParams; import android.widget.TextView; import android.widget.Toast; public class TestActivity extends Activity < /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) < super.onCreate(savedInstanceState); // этот метод нам не нужен // setContentView(R.layout.activity_test); LinearLayout layout = new LinearLayout(TestActivity.this); layout.setId(R.id.layout_id); LayoutParams layoutParams = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT); layout.setLayoutParams(layoutParams); layout.setOrientation(LinearLayout.VERTICAL); ImageView imageView = new ImageView(TestActivity.this); imageView.setId(R.id.image_id); imageView.setImageResource(R.drawable.ic_launcher); LayoutParams imageViewLayoutParams = new LayoutParams( LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT); imageView.setLayoutParams(imageViewLayoutParams); layout.addView(imageView); setContentView(layout); layout.setOnClickListener(onViewClickListener); imageView.setOnClickListener(onViewClickListener); >OnClickListener onViewClickListener = new OnClickListener() < @Override public void onClick(View v) < int myId = v.getId(); Toast.makeText(TestActivity.this, "ID: " + String.valueOf(myId) + " clicked", Toast.LENGTH_LONG).show(); >>; > 

Принцип формирования следующий — создаем объект LinearLayout (или другой контейнер) и настраиваем необходимые свойства. Далее создаём необходимые дочерние элементы и также настраиваем их свойства. Не забываем подключить дочерний элемент к родительскому через метод addView().

В данном примере мы также присваиваем компонентам идентификаторы через метод setId(), хотя необходимости в этом не было. В примере эта возможность показана для демонстрации. Если вы используете идентификаторы, то в файле res/values/stings.xml добавьте строчки:

Обычно опытные программисты создают отдельный файл для идентификаторов, например, res/values/ids.xml.

Классы Activity в Android

Android SDK включает набор классов, наследованных от Activity. Они предназначены для упрощения работы с виджетами, которые часто встречаются в обычном пользовательском интерфейсе. Перечислим некоторые из них (наиболее полезные).

  • MapActivity. Инкапсулирует обработку ресурсов, необходимых для поддержки элемента MapView внутри Активности.
  • ListActivity. Обертка для класса Activity, главная особенность которой — виджет ListView, привязанный к источнику данных, и обработчики, срабатывающие при выборе элемента из списка.
  • ExpandableListActivity. То же самое, что и ListActivity, но вместо ListView поддерживает ExpandableListView.
  • TabActivity. Позволяет разместить несколько Активностей или Представлений в рамках одного экрана, используя вкладки для переключения между элементами.

Activity

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

public class MainActivity extends AppCompatActivity < // содержимое класса >

Все объекты activity представляют собой объекты класса android.app.Activity , которая содержит базовую функциональность для всех activity. В приложении из прошлой темы мы напрямую с этим классом не работали, а MainActivity наследовалась от класса AppCompatActivity . Однако сам класс AppCompatActivity, хоть и не напрямую, наследуется от базового класса Activity.

Жизненный цикл приложения

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

Все объекты activity, которые есть в приложении, управляются системой в виде стека activity, который называется back stack . При запуске новой activity она помещается поверх стека и выводится на экран устройства, пока не появится новая activity. Когда текущая activity заканчивает свою работу (например, пользователь уходит из приложения), то она удаляется из стека, и возобновляет работу та activity, которая ранее была второй в стеке.

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

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

Схематично взаимосвязь между всеми этими обратными вызовами можно представить следующим образом

Жизненный цикл приложения Android

onCreate()

onCreate — первый метод, с которого начинается выполнение activity. В этом методе activity переходит в состояние Created. Этот метод обязательно должен быть определен в классе activity. В нем производится первоначальная настройка activity. В частности, создаются объекты визуального интерфейса. Этот метод получает объект Bundle , который содержит прежнее состояние activity, если оно было сохранено. Если activity заново создается, то данный объект имеет значение null. Если же activity уже ранее была создана, но находилась в приостановленном состоянии, то bundle содержит связанную с activity информацию.

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

onStart

В методе onStart() осуществляется подготовка к выводу activity на экран устройства. Как правило, этот метод не требует переопределения, а всю работу производит встроенный код. После завершения работы метода activity отображается на экране, вызывается метод onResume , а activity переходит в состояние Resumed.

onResume

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

onPause

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

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

После выполнения этого метода activity становится невидимой, не отображается на экране, но она все еще активна. И если пользователь решит вернуться к этой activity, то система вызовет снова метод onResume , и activity снова появится на экране.

Другой вариант работы может возникнуть, если вдруг система видит, что для работы активных приложений необходимо больше памяти. И система может сама завершить полностью работу activity, которая невидима и находится в фоне. Либо пользователь может нажать на кнопку Back (Назад). В этом случае у activity вызывается метод onStop .

onStop

В этом методе activity переходит в состояние Stopped. В этом состоянии activity полностью невидима. В методе onStop следует особождать используемые ресурсы, которые не нужны пользователю, когда он не взаимодействует с activity. Здесь также можно сохранять данные, например, в базу данных.

При этом во время состояния Stopped activity остается в памяти устройства, сохраняется состояние всех элементов интерфейса. К примеру, если в текстовое поле EditText был введен какой-то текст, то после возобновления работы activity и перехода ее в состояние Resumed мы вновь увидим в текстовом поле ранее введенный текст.

Если после вызова метода onStop пользователь решит вернуться к прежней activity, тогда система вызовет метод onRestart . Если же activity вовсе завершила свою работу, например, из-за закрытия приложения, то вызывается метод onDestroy() .

onDestroy

Ну и завершается работа activity вызовом метода onDestroy , который возникает либо, если система решит убить activity в силу конфигурационных причин (например, поворот экрана или при многоконном режиме), либо при вызове метода finish() .

Также следует отметить, что при изменении ориентации экрана система завершает activity и затем создает ее заново, вызывая метод onCreate .

В целом переход между состояниями activity можно выразить следующей схемой:

Состояния Activity в Android

Расмотрим несколько ситуаций. Если мы работаем с Activity и затем переключаемся на другое приложение, либо нажимаем на кнопку Home, то у Activity вызывается следующая цепочка методов: onPause -> onStop . Activity оказывается в состоянии Stopped. Если пользователь решит вернуться к Activity, то вызывается следующая цепочка методов: onRestart -> onStart -> onResume .

Другая ситуация, если пользователь нажимает на кнопку Back (Назад), то вызывается следующая цепочка onPause -> onStop -> onDestroy . В результате Activity уничтожается. Если мы вдруг захотим вернуться к Activity через диспетчер задач или заново открыв приложение, то activity будет заново пересоздаваться через методы onCreate -> onStart -> onResume

Управление жизненным циклом

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

package com.example.viewapp; import androidx.appcompat.app.AppCompatActivity; import android.os.Bundle; import android.util.Log; public class MainActivity extends AppCompatActivity < private final static String TAG = "MainActivity"; @Override protected void onCreate(Bundle savedInstanceState) < super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); Log.d(TAG, "onCreate"); >@Override protected void onDestroy() < super.onDestroy(); Log.d(TAG, "onDestroy"); >@Override protected void onStop() < super.onStop(); Log.d(TAG, "onStop"); >@Override protected void onStart() < super.onStart(); Log.d(TAG, "onStart"); >@Override protected void onPause() < super.onPause(); Log.d(TAG, "onPause"); >@Override protected void onResume() < super.onResume(); Log.d(TAG, "onResume"); >@Override protected void onRestart() < super.onRestart(); Log.d(TAG, "onRestart"); >>

Для логгирования событий здесь используется класс android.util.Log .

В данном случае обрабатываются все ключевые методы жизненного цикла. Вся обработка сведена к вызову метода Log.d() , в который передается TAG — случайное строковое значение и строка, которая выводится в консоли Logcat в нижней части Android Studio, выполняя роль отладочной информации. Если эта консоль по умолчанию скрыта, то мы можем перейти к ней через пункт меню View -> Tool Windows -> Logcat .

И при запуске приложения мы сможем увидеть в окне Logcat отладочную информацию, которая определяется в методах жизненного цикла activity:

Activity (Активность, Операция)

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

По сути активити — это окно, с которым пользователь взаимодействует. И в этом окне можно “нарисовать” какой-либо пользовательский интерфейс. При этом окно может быть как на весь экран, так и занимать только заданную его часть и даже размещаться поверх других окон. Но, как правило, каждая активити реализует только одно окно. Однако, у каждого приложения может быть несколько активити.

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

Мне встречалась интересная аналогия, что активити — это как страницы разных сайтов, открываемых в браузере по ссылке.

Создание новой активити

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

1 2 3 4 5 6 7
class MainActivity : AppCompatActivity() < override fun onCreate(savedInstanceState: Bundle?) < super.onCreate(savedInstanceState) . >>

Таким образом мы получим пустое окно. Чтобы в этом окне хоть что-то отображалось нужно создать разметку — layout. Добавляется она в ресурсах (папка res) в подпапке layout.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
// res/layout/activity_main.xml   

Теперь эту разметку нужно “подключить” к активити в методе onCreate() .

1 2 3 4 5 6 7
class MainActivity : AppCompatActivity() < override fun onCreate(savedInstanceState: Bundle?) < super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) // подключаем разметку >>

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

1 2 3 4 5 6 7 8 9
// src/main/AndroidManifest.xml      

Все вышеперечисленные шаги можно сократить до одного благодаря наличию в Android Studio стандартных шаблонов: правой кнопкой мыши вызываем контекстное меню и в нём выбираем New -> Activity -> “выбрать нужный шаблон”.

new-activity-patterns

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

Настройка активити в манифесте

Рассмотрим более подробно, какую информацию нужно или можно добавлять для элемента в манифесте.

Объявление активити

Как упоминалось выше, все активити приложения обязательно нужно регистрировать в манифесте. Для этого предназначен элемент . У этого элемента есть только один обязательный атрибут — android:name , который ссылается на имя класса активити.

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

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

Объявление intent-фильтров

Скорее всего данная тема будет не особо понятна новичкам, поэтому сначала рекомендую ознакомиться с тем, что такое Intent.

Intent-фильтры — это выражение в файле манифеста, которое указывает, какие объекты Intent может обработать текущее приложение. Т.е. они позволяют настроить, на что будет реагировать активити.

Если у приложения отсутствуют intent-фильтры, то запустить его можно будет только с помощью явного Intent (по имени класса).

Например, активити можно добавить intent-фильтр, который будет говорить, что она умеет отправлять данные.

1 2 3 4 5 6 7 8 9 10 11 12
  // указывает, что активити умеет отправлять данные // позволяет активити получать запросы на запуск // тип данных, которые активити умеет отправлять   

Выше упоминалось, что активити можно отметить как основную. Это тоже осуществляется с помощью intent-фильтра.

1 2 3 4 5 6

Объявление разрешений

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

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

1 2 3 4 5

И чтобы иметь возможность запускать SocialApp вы должны в своем приложении добавить идентичное разрешение:

1 2 3

Жизненный цикл

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

Для чего это делать? Чтобы избежать следующих ситуаций:

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

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

Методы обратного вызова

onCreate()

Вызывается при создании и перезапуске активити. После создания активити она переходит в состояние “Создана” (Created state), но существует в нём недолго. Как только метод onCreate() будет выполнен, активити переходит в статус “Запущена” (Started state).

Этому методу передается объект Bundle , который содержит в себе сохранённое состояние активити (если она перезапустилась), либо null (если активити ранее не существовала).

Что в нём должно происходить:
Выполнение базовой логики запуска приложения, которая должна происходить только один раз за весь период действия. Например, создание пользовательского интерфейса, привязка данных, создание сервисов (service) и потоков.

Следующий метод:
onStart() .

onStart()

Вызывается при переходе активити в состояние “Запущена” (Started state), т.е. сразу после выполнения метода onCreate() . В этом состоянии активити существует пока метод onStart() не будет выполнен. После чего переходит в состояние “Возобновлена” (Resumed state).

Также этот метод делает активити видимой для пользователя, но с ней еще нельзя взаимодействовать.

Что в нём должно происходить:
Выполнение кода, который поддерживает пользовательский интерфейс

Следующий метод:
onResume()

onResume()

Вызывается при переходе активити в состояние “Возобновлена” (Resumed state), т.е. сразу после выполнения метода onStart() . В этом состоянии активити взаимодействует с пользователем. И продолжается это до тех пор пока пользователя что-то не отвлечёт, например, телефонный звонок, переход к другому приложению или отключение экрана устройства. В этом случае активити перейдёт в состояние “Приостановлена” (Paused state).

Что в нём должно происходить:
Включение функциональности, которая должна работать, пока активити видна и находится на переднем плане. Возобновить работу того, что было приостановлено в методе onPause() .

Следующий метод:
onPause()

onPause()

Вызывается, когда активити теряет фокус и переходит в состояние “Приостановлена” (Paused state). Т.е. активити больше не находится на переднем плане, хотя может быть всё ещё видна пользователю.

Завершение работы метода onPause() не означает, что активити перейдёт в другое состояние. Она будет оставаться в состоянии “Приостановлена” до тех пор, пока либо не перейдёт обратно на передний план (вызовется метод onResume() ), либо пока полностью не станет невидимой (вызовется метод onStop() ).

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

Следующий метод:
onResume() или onStop() .

onStop()

Вызывается, когда активити больше не видна пользователю и переходит в состояние “Остановлена”. Это может произойти, если активити уничтожается, запускается новая активити или возобновляет работу существующая активити, закрывая собой текущую. Несмотря на это, активити остаётся в памяти, но она больше не привязана к диспетчеру окон.

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

Что в нём должно происходить:
Остановка функций, работа которых не нужна пока активити невидима для пользователя. Например, остановка анимаций, сохранение информации в базе данных.

Следующий метод:
onRestart() или onDestroy() .

onRestart()

Вызывается, когда активити в состоянии “Остановлена” повторно отображается пользователю.

Что в нём должно происходить:
Выполнение действий, которые должны выполняться при повторном запуске активити в рамках одного жизненного цикла приложения.

Следующий метод:
onStart() .

onDestroy()

Вызывается перед тем, как активити будет уничтожена и переходит в состояние “Уничтожена” (Destroyed state). Это происходит в следующих случаях: если пользователь её закрыл; был вызван метод finish() ; произошла смена конфигурации активити (например, поворот экрана). При этом в первых двух случаях метод onDestroy() будет последним обратным вызовом в жизненном цикле активити. Если же onDestroy() был вызван из-за смены конфигурации, система немедленно создаст новый экземпляр активити и вызовет для него метод onCreate() .

Что в нём должно происходить:
Освобождение всех оставшихся ресурсов, которые не были освобождены в методах onPause() и onStop() .
Не использовать для какой-либо критически важной логики, так как данный метод может быть и не вызван.

Следующий метод:
Последний метод жизненного цикла.

Схема состояний активити

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

Activity: определение и его жизненный цикл в Android

Lorem ipsum dolor

Что такое жизненный цикл Activity? Для того чтобы попытаться ответить на этот вопрос, необходимо понимать , что такое Activity в Android , — тогда ответ на этот вопрос появится сам по себе.

Activity — это фундаментальный компонент каждого Android-приложения. Через этот компонент происходит взаимодействие между пользователем и приложением. При помощи него пользователь телефона может «путешествовать» между окнами приложения или между разными приложениями.

Фактическ и к омпонент Activity — это окно , которое открывается пользователю при запуске приложения. В этом компоненте создается интерфейс приложения, который виден пользователю со всеми кнопками, меню, формами и др. У одного Android-приложения может быть несколько окон Activity, н о о бычн о р еализуют только одно-единственное. При многокомпонентном Activity всегда определяют «главный экран», который запускается при активации приложения ; остальные экраны активируются по необходимости. Если провести аналоги ю с веб-сайтами, тогда можно сказать, что Activity в Андроид-приложениях — это главная страница на веб-сайтах, с которой посетитель сайта начинает знакомит ь ся с ресурсом.

Жизненный цикл Activity

Каждое запущенное Андроид-прило же ние имеет жизненный цикл, который ему определяет операционная система. Пр и активации приложени я о но получает самый высокий приоритет, а операционная система выделяет ему отдельный процесс. Именно поэтому ОС и может определять приоритетность приложений, потому что она контролирует процессы. «Приоритет» приложений означает, что активному приложению предоставляют максимальное количество ресурсов телефона, однако другие приложения также работают. Например, открыв любое приложение на телефоне, всегда можно принять звонок, получить SMS или получить сообщение в мессенджер е .

Поясняем , пр и ч ем здесь жизненный цикл Activity. Activity — это «экран взаимодействия» с приложением. Соответственно, если активно приложение, значит , будет актив на и Activity ; если нет — тогда нет. На практике это выглядит так : к огда запущено приложение, пользователь видит его Activity. Если запускается новое приложение, тогда его Activity выводится на экран, а старая «скрывается». Когда новая Activity прекращает работу, тогда она удаляется из стека, а старая Activity появляется на экране.

Жизненный цикл А ктивити связан с рядом событий, которые определяют его длительность.

Жизненный цикл А ктивити: события

  1. «onCreate()». Это первое событие, которое активируется при запуске приложения , и с него начинает свой жизненный цикл А ктивити. Он определяет первоначальную настройку «экрана», например, создает визуальные компоненты интерфейса приложения. После завершения работы этого состояни я п риложение переходит в следующее.
  2. «onStart()». Во время выполнения этого события приложение готовит ся показать Activity на экране устройства. После окончания этого событи я р абота приложения переходит к следующему событию.
  3. «onResume()». Это событие , во время которого Activity появляется на экране устройства и пользователь начинает взаимодействовать с интерфейсом приложения. Это «рабочее» состояние Activity, которое останется таким, пока пользователь взаимодействует с приложением и не закрывает его или не переходит в другое приложение.
  4. «onPause()». Это событие включается в том случае, если пользователь открыл другое приложение, не закрывая предыдущее. То ест ь п риложение не закрывается полностью, а лишь приостанавливает свою деятельность, чтобы освободить ресурсы телефона для работы другого приложения. Еще это состояние называют «фоновой» работой приложения. Приложение может оставаться в таком состоянии до тех пор , пока пользователь его не закроет или система сама его не закроет. Система может самостоятельно закрыть приложение в том случае, если им давно не пользовались, а в «фоне» работа е т слишком большое количество приложений и телефону не хватает ресурсов их поддерживать.
  5. «onStop()». Это событие , при котором Activity и приложение полностью останавливают свою работу и ее вообще не видно на экране. В о время этого события происходит полное высвобождение ресурсов телефона , о днако в памяти телефона во время этого события еще остаются настройки интерфейса. То есть, если во время этого события пользователь возобновит работу приложения, тогда на экране Activity отразятся настройки и работа пользователя с интерфейсом. К примеру, пользователь начал заполнять поля формы, но не закончил. Такие моменты пока еще сохраняются памяти. По окончани и этого события приложение переходит к следующему.
  6. «onDestroy()». Этим событием приложение завершает собственную деятельность. Оно возникает тогда, когда приложение было закрыто пользователем или операционной системой. Во время этого события высвобождаются все ресурсы системы, которые не были высвобождены в предыдущих этапах. Жизненный цикл Activity на этом этапе заканчивается.

Заключение

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

Мы будем очень благодарны

если под понравившемся материалом Вы нажмёте одну из кнопок социальных сетей и поделитесь с друзьями.

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

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