Текст книги "Программирование приложений для мобильных устройств под управлением Android. Часть 1"

Евгений Сенько
Программирование приложений для мобильных устройств под управлением Android. Часть 1

Основные принципы создания приложения

Сначала мы поговорим о четырех фундаментальных строительных блоках, из которых строятся все Android-приложения. Эти блоки реализованы в виде Java-классов. И первый из этих строительных блоков – класс Activity. Это основной класс, который видят пользователи при запуске приложения. Activity разработаны с целью обеспечения графического пользовательского интерфейса или GUI, и они позволяют пользователям передавать и получать информацию из приложения.

Остальные три компонента работают «за кулисами», поэтому они не имеют пользовательских интерфейсов. Эти компоненты включают в себя:

Service для поддержки длительных или работающих в фоновом режиме операций;

Broadcast receiver – для прослушивания и реагирования на события, которые происходят на устройстве;

Content provider, который позволяет нескольким приложениям хранить и обмениваться данными.

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

Во-первых, давайте поговорим о классе Activity. Этот класс предоставляет графический интерфейс пользователя и обеспечивает взаимодействие с пользователем через этот интерфейс. Как правило, Activity должна поддерживать одно конкретное действие, которое пользователь может сделать. Такое действие, как набор телефонного номера или ввод контактной информации для одного человека, и так далее. Хотя сейчас уже появились устройства с большими экранами, особенно планшеты, и то, что мы называем одним конкретным действием, которое пользователь может сделать, конечно, может измениться. Теперь, в качестве примера Activity, давайте взглянем на приложение «Номеронабиратель».

Вы наверняка знаете, что приложение «Телефон» может открыть пользовательский интерфейс с несколькими вкладками. Одна – для набора номера телефона, одна – для списка вызовов, одна – для контактов. В Android 4.2 исходный код этого приложения фактически является частью приложения «Контакты».

Следующий компонент – это класс Service (сервис). В отличие от Activity сервисы выполняются в фоновом режиме. Поэтому нет необходимости в пользовательских интерфейсах. Вместо этого сервисы имеют две главные цели. Первое – они могут выполнять длительные операции, как правило, отдельно от основного потока пользовательского интерфейса. И второе – они обеспечивают взаимодействие различных процессов для обмена данными.

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

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

Следующий компонент – это Broadcast receiver (приемник сообщений и событий). Broadcast receiver «слушает» и реагирует на события. И, по сути, он играет роль подписчика в модели «публикация-подписка».

В Android события представлены классом Intent. О нем мы поговорим подробнее немного позже. «Издатели» создают этот Intent и затем рассылают его, используя специальные методы, как бы отправляя в эфир. Далее его принимает Broadcast receiver, который и подписан на этот конкретный Intent. И, приняв Intent, он может отреагировать на произошедшее событие.

Пример приложения, которое использует Broadcast receiver – приложение для обмена сообщениями. Давайте представим, что кто-то хочет отправить мне SMS-сообщение. SMS-сообщение будет создано и отправлено через телефонную сеть и в конечном счете достигнет моего телефона. И когда это произойдет, Android выставит значок уведомления в панели уведомлений, который даст мне знать, что для меня пришло сообщение. Но вы, конечно, никогда не можете точно знать, в какой момент вы получите такое сообщение. Поэтому Android имеет некоторое программное обеспечение, которое просто «сидит» и «ждет» когда придет SMS-сообщение. И когда оно приходит, это программное обеспечение передает в эфир Intent SMS_received. И есть еще один Broadcast receiver, который слушает этот Intent SMS_received, и он, получив этот Intent, запустит сервис, который загрузит и сохранит входящее SMS-сообщение.

Последний компонент – это Content provider. Content provider позволяет приложениям хранить и обмениваться данными. Content provider использует интерфейс, подобный базам данных, но он больше, чем просто база данных. Например, Content provider сможет обрабатывать связи между процессами. Так что приложения, работающие в отдельных процессах, могут взаимодействовать и обмениваться данными безопасно и легко. Приложение «Браузер» является одним из примеров приложений, использующих Content provider. Если запустить «Браузер» и нажать на значок рядом с адресной строкой в браузере, откроется список закладок и сохраненных адресов веб-сайтов для быстрого доступа в будущем. Когда пользователь добавляет одну из этих закладок, браузер сохраняет ее в Content provider.

Если посмотреть на простейшее приложение «Hello Android», мы увидим всего одну Activity. Но мы будем рассматривать более сложные приложения, в нашем случае, включающее в себя две Activity. И, конечно, как вы понимаете, если можно использовать две Activity, то можно добавить и третью, и четвертую и так далее – просто будет больше одной.

Например, приложение «MapLocation» одним из видов Activity позволяет пользователю ввести почтовый адрес. Эта Activity имеет кнопку, которую пользователь может нажать, как только он ввёл адрес. И, нажав на эту кнопку, запустить вторую Activity – «Google Maps», которая представляет собой карту, отцентрированную на адрес, который пользователь только что ввёл.

Следующая схема показывает процесс написания и построения приложений под Android.

Во-первых, вы создаете исходный код и код ресурсов, которые составляют приложение. Далее, вы компилируете исходный код и подготавливаете свои ресурсы. Результатом этого шага является пакет Android или APK, который является исполняемым файлом приложения. Далее APK подписывается цифровой подписью, чтобы идентифицировать вас как разработчика и, наконец, APK устанавливается на устройство или эмулятор и запускается.

Ваше участие в процессе сборки как разработчика, как правило, включает следующие четыре шага:

• определение ресурсов;

• реализация классов приложения;

• упаковка приложения;

• установка и запуск приложения, в частности для тестирования и отладки.

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

Один распространенный тип ресурсов – strings (строки). В Android существует три типа строковых ресурсов. Отдельные строки – strings, массивы строк – arrays и формы множественного числа – plurals. Строки и массивы строк довольно понятны, давайте поговорим о plurals. Plurals в основном – это массивы строк, которые могут использоваться, чтобы выбрать определенные строки, связанные с определенной величиной (количеством), например, одна книга или две книги.

Строки обычно хранятся в xml-файлах в каталоге приложения res/values. Строка может включать форматирование и информацию о стилях. Такие вещи, как HTML-теги, например. Основным преимуществом хранения строковых констант в файле ресурсов является простота интернационализации Android-приложений, т. е. их перевод на иностранные языки. Если вы хотите создать приложение, переведенное на несколько разных языков, то рекомендуется выбрать язык по умолчанию – английский и поместить строки на английском языке в xml-файл strings в папку ресурсов, используемую по умолчанию – res/values. А файлы со строками на других языках – в соответствующие папки, например, для русского языка – в res/values-ru, для французского – в res/values-fr, немецкого – в res/values-de и так далее.

Во время компиляции приложения автоматически генерируется класс R.java. Java-код использует R-класс для доступа к ресурсам.

Наконец, другие файлы ресурсов могут ссылаться на строки, которые вы определили как @string/string_name. Вы также можете получить доступ к этим строкам из java-кода, но на этот раз вы делаете это так: R.string.string_name.

Другой вид ресурса – Layout или файл лейаута. Layout-файл определяет на что будет похож пользовательский интерфейс для каждой части (каждого экрана) вашего приложения. Эти файлы так же записаны в xml, несмотря на то, что некоторые инструменты позволяют вам создавать лейаут визуально, вручную, и затем эти инструменты сгенерируют xml для вас.

К примеру, Eclipse создает Layout-файлы в каталоге res/layout вашего приложения. И вы можете получить доступ к Layout в Java как R.layout.layout_name. Так же вы можете получить доступ к Layout в других файлах ресурсов как @layout/layout_name.

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

Давайте рассмотрим файл R.java. Как уже упоминалось, этот файл автоматически сгенерирован Android, таким образом вы не должны изменять его. Файл определяет класс R, и этот класс R содержит другой класс под названием Layout, у которого есть поле под названием Main. И это фактически дает вам ссылку или дескриптор к файлу main.xml.

Есть также класс ID, обеспечивающий дескрипторы для различных лейаутов, текстовых полей, полей редактирования и к кнопкам, определенным в файле main.xml. Если вы вернетесь и посмотрите main.xml-файл, вы увидите, что есть строки, в которых написано «Android: ID». Это – то, откуда эти поля и ID появляются.

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

Следующий шаг в разработке приложений – это реализация ваших Java-классов. Это обычно включает в себя написание по крайней мере одной Activity. Точка входа для Activity – метод onCreate. Это – то, где вы будете обычно инициализировать свое приложение.

Давайте рассмотрим метод onCreate немного более детально. В onCreate вы обычно делаете следующие четыре вещи:

• вы восстанавливаете сохраненное состояние приложения;

• вы устанавливаете визуальное представление content view, которое сообщает андроиду, что необходимо вывести на экран в качестве пользовательского интерфейса Activity;

• вы инициализируете определенные элементы пользовательского интерфейса своего Activity;

• и последнее – вы присоединяете код к элементам пользовательского интерфейса так, чтобы определенные действия были выполнены, когда пользователи будут взаимодействовать с этими элементами Activity.

Давайте посмотрим, как эти шаги реализованы в «MapLocation». Исходный код «MapLocation» реализует класс под названием MapLocation, который является подклассом Activity.

На первом шаге onCreate должен вызвать super.onCreate, передав сохраненное состояние в качестве параметра. Это сохраненное состояние (savedInstanceState) – в основном структура данных, содержащая любую информацию, которую Android, возможно, сохранил с прошлого раза, когда эта Activity работала.

Мы будем говорить больше об этом далее, когда мы погрузимся глубже в класс Activity. Но на данный момент просто знайте, что onCreate должен вызвать super.onCreate, или вы получите ошибку.

Затем идет вызов setContentView. В нашем случае для вывода на экран содержимого файла лейаута этого приложения – R.layout.main. После этого идет некоторый код, который устанавливает соответствия отдельных элементов UI с лейаутом. Такие как текстовое поле редактирования, которое сохранено в вызываемой переменной addrText, и кнопка, которая сохранена в переменной button. Как видите, эти ссылки получены вызовом метода activity.findViewById, содержащем в параметре идентификатор желаемого элемента.

И наконец, есть некоторый код, который определяет что сделать, когда пользователь нажимает кнопку Show Map. Этот код реализует интерфейс onClickListener («слушатель» кликов), в котором есть метод onClick, вызывающийся каждый раз, когда пользователь кликает по кнопке. Код в методе onClick сначала считывает текст, который пользователь ввел в поле адреса. Затем он обрабатывает этот текст, чтобы удалить пробелы, и преобразовывает его в формат, который понимает «Google Maps». Затем он запускает приложение «Google Maps» и передает ему этот преобразованный адрес.

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

Следующим шагом в создании Android-приложений является предоставление информации, которая позволяет Андроиду создать пакет приложения или APK, и эта информация записывается в манифесте – xml-файле androidmanifest.xml. Файл androidmanifest.xml содержит большое разнообразие упаковочной информации, включая имя приложения и список компонентов, которые составляют это приложение. Он также включает другую информацию, которую мы обсудим позже. Это такие вещи как: Permissions (полномочия), которые необходимы, чтобы запустить это приложение, аппаратные функции, такие как камера, если она нужна для работы этого приложения, и самая ранняя версия платформы, на которой это приложение сможет работать. Давайте рассмотрим файл androidmanifest.xml для «MapLocation».

Файл androidmanifest.xml находится в корневом каталоге приложения. Один из элементов, который мы видим здесь, является элементом uses-SDK. Этот элемент включает атрибут minSdkVersion, который определяет минимальный уровень API для этого приложения. И в нашем случае этот уровень равняется 13, что соответствуют Android 3.2.

Этот элемент также включает другой атрибут – targetSdkVersion, который определяет последний уровень API, для которого было протестировано это приложение. В данном случае это уровень 19, что соответствует версии Android 4.4.2.

Следующий элемент манифеста – application, который содержит различные атрибуты: иконку для этого приложения, метку, которая показана в строке заголовка приложения, элемент Activity, который перечисляет в нашем случае всего одну Activity – MapLocation, которое включает это приложение.

И последним шагом мы устанавливаем приложение на устройство или эмулятор, чтобы протестировать и отладить его.

Класс Activity

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

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

Таким образом задача (Task) в Android – это ряд связанных Activity. Эти связанные Activity могут, но не должны быть частью одного приложения. Одна задача (Task) может охватить несколько приложений.

Большинство задач запускается с домашнего экрана. Таким образом, когда пользователь запускает приложение с домашнего экрана, обычно запускается новая задача (Task). И когда пользователь нажимает кнопку «Домой», чтобы возвратиться назад к домашнему экрану, текущая задача, по крайней мере временно, приостанавливается.

Стек задачи (Task backstack) работает следующим образом. Когда Activity запущена, она заносится в верхнюю ячейку стека как часть текущей задачи. А когда эта Activity позже будет уничтожена, например, потому что пользователь нажал кнопку «Назад», или потому что Activity сама завершила свою работу программно, или даже потому что сам Android решил уничтожить эту Activity, чтобы освободить занимаемые ей ресурсы, тогда Activity удаляется из верхней ячейки стека задач.

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

Activity имеют жизненный цикл. И что важно для вас как для разработчика, приложения не контролируют свой жизненный цикл. Некоторые изменения жизненного цикла зависят от выбора, который делает пользователь, например нажатие кнопки «Назад» или кнопки «Домой». Другие изменения жизненного цикла зависят от самого Android. Например, если ваше устройство испытывает нехватку памяти, Android может уничтожить activity, которые в настоящее время приостановлены.

Как только Activity запущена, она может быть в состоянии resumed (возобновленном) или running (выполнения). И в то время как она находится в этом состоянии, Activity видима (на экране) и пользователь может взаимодействовать с ней.

Activity может также быть paused (приостановлена). Например, когда новая Activity начинает раскрываться перед ней. В этой ситуации Activity может все еще быть частично видима, но пользователь не может взаимодействовать с ней, потому что он будет взаимодействовать с новой Activity, которая только что запущена (до версии 3.0 Android мог завершить Activity, как только они вошли в приостановленное состояние).

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

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

Чтобы поддерживать сценарии как этот, Android сообщает об изменениях жизненного цикла в Activity, вызывая предопределенные методы (call back) жизненного цикла. И вот некоторые из этих методов:

• onCreate, вызывается перед тем как Activity будет создано;

• onStart, вызывается перед тем как Activity станет видимым;

• onDestroy, вызывается перед тем как Activity будет уничтожена.

И, если вы хотите выполнить некоторые действия, когда ваша Activity изменяет состояние, то вы должны переопределить (override) эти методы в вашей Activity.

Давайте рассмотрим как эти различные методы взаимосвязаны друг с другом. Эта диаграмма изображает последовательность, в которой могут быть вызваны методы жизненного цикла Activity. И важно помнить, что приложения Android не работают полностью сами по себе. Вместо этого есть четко определенное направление взаимодействия между вашим приложением и Android. И вы должны понять правила этого взаимодействия, если хотите, чтобы ваши приложения функционировали должным образом.

Давайте представим простое приложение с одной Activity. Оно запускается, ожидает мгновение, и затем закрывается. В этом простом случае как только приложение будет запущено, Android вызовет (call back) метод onCreate.

Затем Android вызовет свой метод onStart, и затем onResume, после которого пользовательский интерфейс Activity появится на экране устройства, и пользователь сможет взаимодействовать с ним.

Приблизительно после одной минуты наша Activity начнет закрываться. И в этот момент Android вызовет метод onPause. Затем onStop. И, наконец, onDestroy. Теперь Activity абсолютно уничтожена.

Итак, как видите, все время жизни Activity заключено между onCreate при запуске и onDestroy в конце.

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

Когда Activity становятся видимыми, Android иногда вызывает метод onStart, а иногда – onRestart. Перед тем, как Activity станут невидимыми, Android вызывает метод onStop. Таким образом, время жизни Activity в видимом состоянии длится между запуском вызовов onStart и onStop. И, наконец, в то время как Activity видима на экране, есть отрезки времени, когда пользователь может взаимодействовать с ней, и есть моменты когда не может. Например, это может произойти, когда устройство «засыпает». В этом случае пользователь не может взаимодействовать с Activity даже при том, что эта Activity все еще запущена.

Когда Activity оказывается готова к взаимодействию с пользователем, Android вызывает метод onResume. Когда Activity собирается прекратить взаимодействие с пользователем, Android вызывает метод onPause.

Таким образом время жизни Activity, когда она видима и способна взаимодействовать с пользователем, длится между запуском вызовов onResume и onPause.

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

• вызов super.onCreate, который сделает часть собственной инициализации Android;

• установка content view Activity, которая сообщит Android, каким должен быть пользовательский интерфейс Activity;

• получение и сохранение всех необходимых ссылок и соответствий между различными элементами (view) лейаута пользовательского интерфейса и кодом Activity;

• конфигурирование элементов пользовательского интерфейса и view.

Давайте рассмотрим метод onCreate приложения «MapLocation». @Override – переопределяет activity.onCreate. В методе onCreate вы видите четыре функции, о которых мы говорили.

Во-первых, есть вызов super.onCreate. Затем есть вызов setContentView с ID файла лейаута R.layout.main в качестве параметра. После этого Activity сохраняет ссылки на view редактирования текста и на кнопку, которые появляются в пользовательском интерфейсе. И, наконец, onCreate присоединяет «слушателя» кнопки button.setOnClickListener. Android вызывает этот код «слушателя» каждый раз, когда пользователь нажимает на кнопку.

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

onStart вызывается перед тем, как Activity станет видимой. Некоторые типичные применения для этого метода – это запрос обновлений датчика положения или загрузка или сброс персистентного состояния приложения.

onResume вызывается перед тем, как Activity начнёт взаимодействовать с пользователем, и уже видима. Действия, которые вы совершаете в этом методе, должны быть запущены на переднем плане приложения. Например, стартовые анимации или воспроизведение фоновой звуковой дорожки.

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

onStop вызывается, когда Activity больше не видима пользователю. В этой точке предполагается, что Activity может быть опять запущена позже. Так, некоторые типичные действия, которые надо сделать здесь – это кэширование состояния Activity, которое вы захотите восстановить, когда Activity позже перезапустится по вызову onStart. И помните: onStop не всегда вызывается, когда Activity завершается. Например, его нельзя вызвать, если Android уничтожает процесс приложения из-за нехватки памяти. Поэтому вместо сохранения персистентных данных в этом методе, лучше сделайте это в onPause.

onDestroy вызывается перед тем, как Activity будет уничтожена. Некоторые типичные действия, которые надо сделать в этом методе – высвободить ресурсы, занимаемых этой Activity. Например, закрыть частные потоки, которые были запущены этой Activity. И снова помните, что onDestroy не будет вызван, например, если Android уничтожит приложение из-за нехватки памяти на устройстве.

Теперь, когда мы увидели жизненный цикл Activity в действии, давайте рассмотрим как одна Activity может программно запускать другую Activity. Чтобы запустить Activity программно, вы сначала создаете объект Intent (намерение), который определяет Activity, которую вы хотите запустить. И затем вы передаете этот созданный Intent тем методам, которые запускают Activity – startActivity или startActivityForResult. startActivity запустит желаемую Activity, скрывая текущую Activity с переднего плана. startActivityForResult, тоже запустит желаемую Activity, но сделает это с ожиданием того, что запущенная Activity вернет результат для вызывающей Activity.

Давайте рассмотрим как приложение «Map Location» запускает Activity «Google Maps». Каждый раз, когда пользователь кликает кнопкой, вызывается метод onClick. В строковую переменную address помещается географический адрес, считанный из текстового поля addrText. Далее создается Intent geoIntent, содержащий в себе заданный географический адрес, который затем и передается методу startActivity для запуска приложения «Карты» с географической картой, центрированной на указанном адресе.

Но вместо того, чтобы запросить у пользователя ввод адреса через клавиатуру, мы можем позволить ему выбрать контакт из приложения «Контакты» и использовать адресные данные этого контакта как географический адрес, который открыть на карте. Для этого рассмотрим приложение «Map location from contacts».

Отличие от «Map Location» находится в коде OnClickListener, в частности, этот код создает несколько иной Intent, а затем передает его в качестве параметра методу StartActivityForResult. Вторым параметром является requestCode (код запроса), который пригодится позже, когда результат вернется обратно в запускающую Activity.

Как только новая Activity запущена, она ответственна за результат, который должен быть возвращен назад вызывающей Activity. Это делается вызовом Activity.SetResult, передвая в нем код результата (resultCode). Эти коды результата включают некоторые встроенные коды, такие как Result_Canceled (отмененный результат), который указывает, что пользователь принял решение не завершать действие, а отменил его, например, нажав кнопку «Назад», и Result_OK, указывающий, что Activity фактически завершена штатно. Разработчики могут также добавить пользовательские коды результата после встроенного кода результата (Result_First_User).

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

Как вы видите, его параметры включают начальный код запроса (requestCode), который был передан в StartActivityForResult, код результата (resultCode), используемый запущенной Activity, когда она вызвала SetResult, и Intent, если он был передан в SetResult. onActivityResult обычно начинается с проверки кода результата и кода запроса, чтобы определить, что сделать с полученным результатом.

Следующим шагом необходимо получить данные контакта и проанализировать их, чтобы извлечь почтовый адрес контакта. Как только почтовый адрес был извлечен, «Map location from contacts» обрабатывает данные так, чтобы они были в формате, который ожидают карты Google (строковая переменная formattedAddress), помещает эти данные в Intent и затем вызывает startActivity, передавая ей этот Intent.

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

Предположим, например, что изменяется ориентация устройства. Если вы поворачиваете устройство из портретного режима в альбомный и назад в портретный, это заставит систему уничтожить текущую Activity и перезапустить ее дважды. Чтобы оптимизировать скорость изменения конфигурации, Android позволяет вам сделать две вещи. Первое, когда происходит изменение конфигурации, вы можете создать и сохранить произвольный объект Java, тем самым сохранив в кэше важную информацию о состоянии. И второе, вы можете вручную обработать изменение конфигурации, избежав завершения и перезапуска Activity в целом.

Итак, чтобы ускорить реконфигурирование, вы можете сохранить данные в объекте Java. И один способ сделать это – переопределить метод onRetainNonConfigurationInstance и вызвать его между onStop и onDestroy. Объект, который вы создаете и возвращаете в onRetainNonConfigurationInstance, может быть получен путём вызова экземпляра getLastNonConfigurationInstance, когда Activity воссоздана. Это обычно делается во время вызова onCreate, когда вы воссоздаете Activity.