Что такое activity: Что такое Activity и его жизненный цикл в Android

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

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

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

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

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

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

Поясняем, при чем здесь жизненный цикл Activity. 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 на этом этапе заканчивается.

Заключение

В данной статье мы описали, из каких событий может состоять жизненный цикл Activity. При программировании Андроид-приложений важно отслеживать все происходящие события, чтобы правильно управлять работоспособностью приложения и сохраняемыми данными во время наступления разных событий. Такой «контроль» поможет избежать сбоев приложения. Например:

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

• пользователь не пользуется вашим приложением активно, а оно потребляет много ресурсов устройства;

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

• пользователь сменил положение экрана, а все, что он делал в вашем приложении, удалилось;

• и др.

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

ACTIVITY — Перевод на русский

You can see this is a major shipping airport, and there’s all kinds of activity there.

Can you tell me more about the invalid click activity you detected?

They’ve also discovered that there’s a heck of a lot of activity going on producing aroma as well.

They have come up with, in a sense, a different method for organizing activity.

We found activity in the brain region, in exactly the same brain region associated with intense romantic love.

Sixty-eight percent of Americans now believe that human activity is responsible for global warming.

And it’s very much an in-the-moment activity that they’re engaged in.

And somehow all that content of consciousness is accomplished by the busy activity of those hoards of neurons.

Now a lot of people know that music is not always a solo activity — sometimes it’s done communicatively.

And as I told you just now, neural activity can change the connectome.

activity analysis of production and allocation

activity analysis of production and allocation

Because the land is so infertile, they largely are shepherds, which occasions regular, low-intensity physical activity.

And we found activity in a lot of brain regions.

Report unauthorized AdWords activity »

activity — это… Что такое activity?

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

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

<LinearLayout
    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:orientation="vertical"
    tools:context=".MainActivity">
    <TextView
        android:id="@+id/tv_info"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Hello World"/>
</LinearLayout>

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

1
2
3
4
5
6
7

class MainActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)  // подключаем разметку
  }
}

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

1
2
3
4
5
6
7
8
9

// src/main/AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest ... >
    <application ... >
        <activity android:name=".MainActivity" />
    </application>

</manifest>

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

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

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

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

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

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

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

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

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

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

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

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

Объявляются они при помощи атрибута <intent-filter> внутри элемента <activity>. При этом <intent-filter> должен обязательно содержать атрибут <action> и может содержать необязательные атрибуты <category> и <data>. Все вместе эти элементы указывают на тип объекта Intent, на который текущая активити сможет реагировать.

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

1
2
3
4
5
6
7
8
9
10
11
12

<activity android:name=".MainActivity">
    <intent-filter>
        // указывает, что активити умеет отправлять данные
        <action android:name="android.intent.action.SEND" />

        // позволяет активити получать запросы на запуск
        <category android:name="android.intent.category.DEFAULT" />

        // тип данных, которые активити умеет отправлять
        <data android:mimeType="text/plain" />
    </intent-filter>
</activity>

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

1
2
3
4
5
6

<activity android:name=".MainActivity">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

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

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

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

1
2
3
4
5

<manifest>
<activity android:name="...."
   android:permission=”com.google.socialapp.permission.SHARE_POST”

/>

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

1
2
3

<manifest>
   <uses-permission android:name="com.google.socialapp.permission.SHARE_POST" />
</manifest>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Полезные ссылки

Introduction to Activities — официальная документация.

Как работает Android, часть 3 / Хабр

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

Статьи серии:

Web vs desktop

Если задуматься об отличиях современных веб-приложений от «обычных» десктопных приложений, можно — среди недостатков — выделить несколько преимуществ веба:

• Веб-приложения переносимы между архитектурами и платформами, как и Java.
• Веб-приложения не требуют установки и всегда обновлены, как и Android Instant Apps.

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

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

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

Activities & intents

Основной вид компонентов приложений под Android — это activity. Activity — это один «экран» приложения. Activity можно сравнить со страницей в вебе и с окном приложения в традиционном оконном интерфейсе.

Собственно окна в Android тоже есть на более низком уровне — уровне window manager. Каждой activity обычно соответствует своё окно. Чаще всего окна activity развёрнуты на весь доступный экран, но:

• Во-первых, Android поддерживает мультиоконный режим — split-screen, picture-in-picture и даже freeform.
• Во-вторых, Android поддерживает подключение нескольких дисплеев.
• В-третьих, activity может намеренно занимать небольшую часть экрана (Theme_Dialog).

Например, в приложении для электронной почты (email client) могут быть такие activity, как Inbox Activity (список входящих писем), Email Activity (чтение одного письма), Compose Activity (написание письма) и Settings Activity (настройки).

Как и страницы одного сайта, activity одного приложения могут запускаться как друг из друга, так и независимо друг от друга (другими приложениями). Если в вебе на другую страницу обращаются по URL (ссылке), то в Android activity запускаются через intent’ы.

Intent — это сообщение, которое указывает системе, что нужно «сделать» (например, открыть данный URL, написать письмо на данный адрес, позвонить на данный номер телефона или сделать фотографию).

Приложение может создать такой intent и передать его системе, а система решает, какая activity (или другой компонент) будет его выполнять (handle). Эта activity запускается системой (в существующем процессе приложения или в новом, если он ещё не запущен), ей передаётся этот intent, и она его выполняет.

Стандартный способ создавать intent’ы — через соответствующий класс в Android Framework. Для работы с activity и intent’ами из командной строки в Android есть команда am — обёртка над стандартным классом Activity Manager:

# передаём -a ACTION -d DATA
# открыть сайт
$ am start -a android.intent.action.VIEW -d http://example.com
# позвонить по телефону
$ am start -a android.intent.action.CALL -d tel:+7-916-271-05-83

Intent’ы могут быть явными (explicit) и неявными (implicit). Явный intent указывает идентификатор конкретного компонента, который нужно запустить — чаще всего это используется, чтобы запустить из одной activity другую внутри одного приложения (при этом intent может даже не содержать другой полезной информации).

Неявный intent обязательно должен указывать действие, которое нужно сделать. Каждая activity (и другие компоненты) указывают в манифесте приложения, какие intent’ы они готовы обрабатывать (например, ACTION_VIEW для ссылок с доменом https://example.com). Система выбирает подходящий компонент среди установленных и запускает его.

Если в системе есть несколько activity, которые готовы обработать intent, пользователю будет предоставлен выбор. Обычно это случается, когда установлено несколько аналогичных приложений, например несколько браузеров или фоторедакторов. Кроме того, приложение может явно попросить систему показать диалог выбора (на самом деле при этом переданный intent оборачивается в новый intent с ACTION_CHOOSER) — это обычно используется для создания красивого диалога Share:

Кроме того, activity может вернуть результат в вызвавшую её activity. Например, activity в приложении-камере, которая умеет обрабатывать intent «сделать фотографию» (ACTION_IMAGE_CAPTURE) возвращает сделанную фотографию в ту activity, которая создала этот intent.

При этом приложению, содержащему исходную activity, не нужно разрешение на доступ к камере.

Таким образом, правильный способ приложению под Android сделать фотографию — это не потребовать разрешения на доступ к камере и использовать Camera API, а создать нужный intent и позволить системному приложению-камере сделать фото. Аналогично, вместо использования разрешения READ_EXTERNAL_STORAGE и прямого доступа к файлам пользователя стоит дать пользователю возможность выбрать файл в системном файловом менеджере (тогда исходному приложению будет разрешён доступ именно к этому файлу).

A unique aspect of the Android system design is that any app can start another app’s component. For example, if you want the user to capture a photo with the device camera, there’s probably another app that does that and your app can use it instead of developing an activity to capture a photo yourself. You don’t need to incorporate or even link to the code from the camera app. Instead, you can simply start the activity in the camera app that captures a photo. When complete, the photo is even returned to your app so you can use it. To the user, it seems as if the camera is actually a part of your app.

При этом «системное» приложение — не обязательно то, которое было предустановлено производителем (или автором сборки Android). Все установленные приложения, которые умеют обрабатывать данный intent, в этом смысле равны между собой. Пользователь может выбрать любое из них в качестве приложения по умолчанию для таких intent’ов, а может выбирать нужное каждый раз. Выбранное приложение становится «системным» в том смысле, что пользователь выбрал, чтобы именно оно выполняло все задачи (то есть intent’ы) такого типа, возникающие в системе.

Само разрешение на доступ к камере нужно только тем приложениям, которые реализуют свой интерфейс камеры — например, собственно приложения-камеры, приложения для видеозвонков или дополненной реальности. Наоборот, обыкновенному мессенджеру доступ к камере «чтобы можно было фото отправлять» не нужен, как не нужен и доступ к совершению звонков приложению крупного банка.

Этой логике подчиняются даже такие «части системы», как, например, домашний экран (лончер, launcher). Лончер — это специальное приложение со своими activity (которые используют специальные флаги вроде excludeFromRecents и launchMode="singleTask").

Нажатие кнопки «домой» создаёт intent категории HOME, который дальше проходит через обычный механизм обработки intent’ов — в том числе, если в системе установлено несколько лончеров и ни один не выбран в качестве лончера по умолчанию, система отобразит диалог выбора.

«Запуск» приложения из лончера тоже происходит через intent. Лончер создаёт явный intent категории LAUNCHER, который «обрабатывается» запуском основной activity приложения.

Приложение может иметь несколько activity, которые поддерживают такой intent, и отображаться в лончере несколько раз (при этом может понадобиться указать им разную taskAffinity). Или не иметь ни одной и не отображаться в лончере вообще (но по-прежнему отображаться в полном списке установленных приложений в настройках). «Обычные» приложения так делают довольно редко; самый известный пример такого поведения — Google Play Services.

Многие операционные системы делятся на собственно операционную систему и приложения, установленные поверх, ничего друг о друге не знающие и не умеющие взаимодействовать. Система компонентов и intent’ов Android позволяет приложениям, по-прежнему абсолютно ничего друг о друге не зная, составлять для пользователя один интегрированный системный user experience — установленные приложения реализуют части одной большой системы, они составляют из себя систему. И это, с одной стороны, происходит прозрачно для пользователя, с другой — представляет неограниченные возможности для кастомизации.

По-моему, это очень красиво.

Tasks & back stack

Как я уже говорил, в браузере пользователь может переключаться не между сайтами, а между вкладками, история каждой из которых может содержать много страниц разных сайтов. Аналогично, в Android пользователь может переключаться между задачами (tasks), которые отображаются в виде карточек на recents screen. Каждая задача представляет собой back stack — несколько activity, «наложенных» друг на друга.

Когда одна activity запускает другую, новая activity помещается в стек поверх старой. Когда верхняя activity в стеке завершается — например, когда пользователь нажимает системную кнопку «назад» — предыдущая activity в стеке снова отображается на экране.

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

При запуске новой activity могут быть указаны специальные флаги, такие как singleTop, singleTask, singleInstance и CLEAR_TOP, которые модифицируют этот механизм. Например, приложения-браузеры обычно разрешают запуск только одной копии своей основной activity, и для переключения между открытыми страницами реализуют собственную систему вкладок. С другой стороны, Custom Tabs — пример activity в браузере (чаще всего Chrome), которая ведёт себя почти «как обычно», то есть показывает только одну страницу, но позволяет одновременно открывать несколько своих копий.

App lifecycle

Одно из основных ограничений встраиваемых и мобильных устройств — небольшое количество оперативной памяти (RAM). Если современные флагманские устройства уже оснащаются несколькими гигабайтами оперативной памяти, то в первом смартфоне на Android, HTC Dream (он же T-Mobile G1), вышедшем в сентябре 2008 года, её было всего 192 мегабайта.

Проблема ограниченной памяти дополнительно осложняется тем, что в мобильных устройствах, в отличие от «обычных» компьютеров, не используются swap-разделы (и swap-файлы) — в том числе и из-за низкой (по сравнению с SSD и HDD) скорости доступа к SD-картам и встроенной флеш-памяти, где они могли бы размещаться. Начиная с версии 4.4 KitKat, Android использует zRAM swap, то есть эффективно сжимает малоиспользуемые участки памяти. Тем не менее, проблема ограниченной памяти остаётся.

Если все процессы представляют собой для системы чёрный ящик, лучшая из возможных стратегия поведения в случае нехватки свободной памяти — принудительно завершать («убивать») какие-то процессы, что и делает Linux Out Of Memory (OOM) Killer. Но Android знает, что происходит в системе, ему известно, какие приложения и какие их компоненты запущены, что позволяет реализовать гораздо более «умную» схему освобождения памяти.

Во-первых, когда свободная память заканчивается, Android явно просит приложения освободить ненужную память (например, сбросить кэш), вызывая методы onTrimMemory/onLowMemory. Во-вторых, Android может эффективно проводить сборку мусора в фоновых приложениях, освобождая память, которую они больше не используют (на уровне Java), при этом не замедляя работу текущего приложения.

Но основной механизм освобождения памяти в Android — это завершение наименее используемых приложений. Система автоматически выбирает приложения, наименее важные для пользователя (например, те, из которых пользователь давно ушёл), даёт их компонентам шанс дополнительно освободить ресурсы, вызывая такие методы, как onDestroy, и завершает их, полностью освобождая используемую ими память и ресурсы.

Если пользователь возвращается в activity приложения, завершённого системой из-за нехватки памяти, эта activity запускается снова. При этом перезапуск происходит прозрачно для пользователя, поскольку activity сохраняет своё состояние при завершении (onSaveInstanceState) и восстанавливает его при последующем запуске. Реализованные в Android Framework виджеты используют этот механизм, чтобы автоматически сохранить состояние интерфейса (UI) при перезапуске — с точностью до введённого в EditText текста, положения курсора, позиции прокрутки (scroll) и т.д. Разработчик приложения может дополнительно реализовать сохранение и восстановление каких-то ещё данных, специфичных для этого приложения.

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

С точки зрения пользователя этот механизм похож на использование swap: в обоих случаях при возвращении в выгруженную часть приложения приходится немного подождать, пока она загружается снова — в одном случае, с диска, в другом — пересоздаётся по сохранённому состоянию.

Именно этот механизм автоматического перезапуска и восстановления состояния создаёт у пользователя ощущение, что приложения «запущены всегда», избавляя его от необходимости явно запускать и закрывать приложения и сохранять введённые в них данные.

Services

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

Такую функциональность нельзя реализовывать, просто запуская отдельный поток — это было бы для системы чёрным ящиком; в том числе, процесс был бы завершён при завершении всех activity, независимо от состояния таких фоновых операций. Вместо этого Android предлагает использовать ещё один вид компонентов — сервис.

Сервис нужен, чтобы сообщить системе, что в процессе приложения выполняются действия, которые не являются частью activity этого приложения. Сам по себе сервис не означает создание отдельного потока или процесса — его точки входа (entry points) запускаются в основном потоке приложения. Обычно реализация сервиса запускает дополнительные потоки и управляет ими самостоятельно.

Сервисы во многом похожи на activity: они тоже запускаются с помощью intent’ов и могут быть завершены системой при нехватке памяти.

Запущенные сервисы могут быть в трёх состояниях:

• Foreground service — сервис, выполняющий действие, состояние которого важно для пользователя, например, загрузка файла или воспроизведение музыки. Такой сервис обязан отображать уведомление в системной шторке уведомлений (примеры: состояние загрузки, название текущей песни и управление воспроизведением). Система считает такой сервис примерно настолько же важным для пользователя, как и текущая activity, и завершит его только в крайнем случае.

• Background service — сервис, выполняющий фоновое действие, состояние которого не интересует пользователя (чаще всего, синхронизацию). Такие сервисы могут быть завершены при нехватке памяти с гораздо большей вероятностью. В старых версиях Android большое количество одновременно запущенных фоновых сервисов часто становилось причиной «тормозов»; начиная с версии 8.0 Oreo, Android серьёзно ограничивает использование фоновых сервисов, принудительно завершая их через несколько минут после того, как пользователь выходит из приложения.

  
  

• Bound service — сервис, обрабатывающий входящее Binder-подключение. Такие сервисы предоставляют какую-то функциональность для других приложений или системы (например, WallpaperService и Google Play Services). В этом случае система может автоматически запускать сервис при подключении к нему клиентов и останавливать его при их отключении.

  
  

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

• Доступность сети. Здесь приложение может указать, требуется ли этому сервису наличие сетевого подключения, и если да, то возможна ли работа в роуминге или при использовании лимитного (metered) подключения.
• Подключение к источнику питания, что позволяет сервисам выполняться, не «сажая батарею».
• Бездействие (idle), что позволяет сервисам выполняться, пока устройство не используется, не замедляя работу во время активного использования.
• Обновления контента — например, появление новой фотографии.
• Период и крайний срок запуска — например, очистка кэша может производиться ежедневно, а синхронизация событий в календаре — каждый час.

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

Как можно заметить, использование JobScheduler не может заменить собой одного из вариантов использования фоновых сервисов — поддержания TCP-соединения с сервером для получения push-уведомлений. Если бы Android предоставлял приложениям такую возможность, устройству пришлось бы держать все приложения, соединяющиеся со своими серверами, запущенными всё время, а это, конечно, невозможно.

Решение этой проблемы — специальные push-сервисы, самый известный из которых — Firebase Cloud Messaging от Google (бывший Google Cloud Messaging).

Клиентская часть FCM реализована в приложении Google Play Services. Это приложение, которое специальным образом исключается из обычных ограничений на фоновые сервисы, поддерживает одно соединение с серверами Google. Разработчик, желающий отправить своему приложению push-уведомление, пересылает его через серверную часть FCM, после чего приложение Play Services, получив сообщение, передаёт его приложению, которому оно предназначено.

Такая схема позволяет, с одной стороны, мгновенно доставлять push-уведомления всем приложениям (не дожидаясь следующего периода синхронизации), с другой стороны, не держать множество приложений одновременно запущенными.

Broadcast receivers & content providers

Кроме activity и сервисов, у приложений под Android есть два других вида компонентов, менее интересных для обсуждения — это broadcast receiver’ы и content provider’ы.

Broadcast receiver — компонент, позволяющий приложению принимать broadcast’ы, специальный вид сообщений от системы или других приложений. Исходно broadcast’ы, как следует из названия, в основном использовались для рассылки широковещательных сообщений всем подписавшимся приложениям — например, система посылает сообщение AIRPLANE_MODE_CHANGED при включении или отключении самолётного режима.

Сейчас вместо подписки на такие broadcast’ы, как NEW_PICTURE и NEW_VIDEO, приложения должны использовать JobScheduler. Broadcast’ы используются либо для более редких событий (таких как BOOT_COMPLETED), либо с явными intent’ами, то есть именно в качестве сообщения от одного приложения к другому.

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

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

Взаимодействие с content provider’ом во многом похоже на доступ к удалённой базе данных через REST API. Приложение-клиент запрашивает данные по URI (например, content://com.example.Dictionary.provider/words/42) через ContentResolver. Приложение-сервер определяет, к какому именно набору данных был сделан запрос, используя UriMatcher, и выполняет запрошенное действие (query, insert, update, delete).

Именно поверх content provider’ов реализован Storage Access Framework, позволяющий приложениям, хранящим файлы в облаке (например, Dropbox и Google Photos) предоставлять доступ к ним остальным приложениям, не занимая место на устройстве полной копией всех хранящихся в облаке файлов.

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

перевод, произношение, транскрипция, примеры использования

Каких результатов вы ожидаете от всех этих действий? 

Результатом этой деятельности является радиация. 

Единицей измерения радиоактивности является кюри. 

I have several very high activity trips planned this year. 

На этот год у меня запланировано несколько очень напряжённых поездок. 

Skiing is my favorite winter activity. 

Катание на лыжах — это мой любимый зимний вид отдыха. 

Watching television is now the nation’s most popular leisure activity. 

Сейчас просмотр телевизора является наиболее популярным видом проведения досуга в стране. 

Their fields of activity are so wide apart. 

Сферы их деятельности абсолютно разные и никак не пересекаются. 

The office was a beehive of activity. 

В офисе кипела бурная деятельность. 

We planned an activity for the children. 

Мы запланировали для детей одно мероприятие. 

The government has promised to clamp down on criminal activity. 

Правительство пообещало подавить преступную деятельность. 

This office is buzzing with activity. 

В офисе идёт кипучая деятельность. 

The end product of this activity is radiation. 

Конечным результатом этой деятельности является радиация. 

Regular physical activity helps to control your weight. 

Регулярная физическая активность помогает контролировать вес. 

The level of activity declines with age. 

С возрастом уровень активности снижается. 

She was at the hub of all the activity. 

Она была в самом центре всего происходящего. 

The whole house was alive with activity. 

Весь дом ходил ходуном. 

The day started with a flurry of activity. 

День начался с бурной деятельности. 

This marketplace was once a hive of activity. 

Когда-то на этом рынке кипела жизнь. 

The graph showed peaks and troughs of activity. 

На диаграмме были показаны пики и спады активности. 

The focus of activity shifted to molecular biology 

Основное внимание сместилось в направлении молекулярной биологии. 

I had been running around southern England in a whirlwind of activity. 

Я мотался по югу Англии, втянутый в водоворот дел. 

Political activity is closely controlled. 

Политическая деятельность строго контролируется. 

The town green was the center of activity. 

Центром активности стал городской выпас. 

The next two days passed in a whirl of activity. 

Следующие два дня прошли в вихре событий. 

Communist activity was prohibited on pain of death. 

Деятельность коммунистов была запрещена под страхом смерти. 

On Saturdays the city’s downtown bustles with activity as a farmers’ market sets up shop. 

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

Android. Activity. Активность — GSS Education

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

onCreate()  — вызывается при первой инициализации Activity. Вам нужно выполнить этот метод для выполнения любой инициализации в вашей Activity.

onStart() — вызывается, когда Activity готова, и отображается пользователю в первый раз, так как Activity готовится стать интерактивной и выйти на передний план. После завершения вызова этого метода, будет вызван метод onResume().

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

onPause() — метод используется для приостановки действий, которые не должны происходить, пока Activity в стадии паузы. Вызов этого метода указывает на то, что пользователь покинул приложение. К примеру, входящий звонок может перевести, проигрыватель музыки в состояние паузы. Это должно заглушить или остановить воспроизводящуюся музыку. Когда пользователь возвращается в приложение, вызывается метод onResume().

onStop() — метод вызывается, если Activity больше не видна в приложении. Такое может случится, если подгружена другая Activity и она занимает весь экран устройства. Когда вызывается этот метод, Activity переходит в состояние прекращения работы. В этом состоянии, система либо вызывает onRestart() для возврата взаимодействия с Activity, либо вызывает метод onDestroy(), чтобы убрать Activity.

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

onRestart() — вызывается, если Activity перезапускается, после того, как было остановлено.

Деятельность Определение и значение | Британский словарь