Разработка приложений под мобильную платформу Android

РАЗРАБОТКА  
ПРИЛОЖЕНИЙ 
ПОД  МОБИЛЬНУЮ  
ПЛАТФОРМУ ANDROID: 

Лабораторный 
практикум  

Москва 
Издательство «ФЛИНТА» 
2018 

УДК 004.41
ББК 32.972

Р17 

Р17 
Разработка приложений под мобильную платформу Android

[Электронный ресурс]: лабораторный практикум / Д.В. Кравцов, 
М.А. Лосева, Е.А. Леонов, А.А. Кузьменко, М.В. Терехов, 
А.В. Аверченков. — М. : ФЛИНТА, 2018. — 72 с.

ISBN 978-5-9765-4014-9

Лабораторный практикум содержит шесть лабораторных работ 

по дисциплине «Разработка приложений под мобильные платформы» и предназначен для студентов очной формы обучения по специальности 10.05.04 – «Информационно-аналитические системы 
безопасности».

УДК 004.41
ББК 32.972

ISBN 978-5-9765-4014-9
© Коллектив авторов, 2018
© Издательство «ФЛИНТА», 2018

Предисловие

В последние годы наблюдается бум развития мобильных 

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

Кроме того, для многих информационно-аналитических систем 

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

На сегодняшний день неоспоримым лидером по распространенно
сти, разнообразию и доступности по цене устройств является мобильная ОС Android, развиваемая совместными усилиями более 80 компаний, входящих в Open Handset Alliance, и Google. Важным преимуществом этой мобильной ОС является то, что она является свободной и 
открытой, т. е. доступны ее исходные коды. Также бесплатно доступны удобные инструментальные средства разработки и качественная 
документация. Поэтому в качестве программной платформы для обучения студентов разработке мобильных приложений был выбран 
Android.

Лабораторный практикум состоит из шести работ по дисциплине 

«Разработка приложений под мобильные платформы» и предназначен 
для студентов очной формы обучения по специальности 10.05.04 –
«Информационно-аналитические системы безопасности». В каждой 
лабораторной работе содержатся теоретические сведения, необходимые для выполнения работы, индивидуальные задания и контрольные 
вопросы. Также приведен перечень литературы, необходимый для 
успешного освоения дисциплины.

ЛАБОРАТОРНАЯ РАБОТА №1

РАЗРАБОТКА ПОЛЬЗОВАТЕЛЬСКИХ ИНТЕРФЕЙСОВ В 

ANDROID

ЦЕЛЬ РАБОТЫ

Целью лабораторной работы является ознакомление и приобрете
ние практических навыков разработки пользовательских интерфейсов.

Продолжительность лабораторной работы – 3 ч.

ОБЩИЕ СВЕДЕНИЯ

Все элементы интерфейса пользователя в приложении Android со
здаются с помощью объектов View и ViewGroup. Объект View формирует на экране элемент, с которым пользователь может взаимодействовать. Объект ViewGroup содержит другие объекты View (и 
ViewGroup) для определения макета интерфейса.

ACTIVITY, LAYOUT

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

Activity — это компонент приложения, который выдает экран, и с 

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

Содержимое Activity формируется из различных компонентов, 

называемых View. Самые распространенные — это кнопка, поле ввода, чек бокс и т.д. Пример приложения изображен на рис.1.

Необходимо 
заметить, 
что 
View 
обычно 
размещаются 
в 

ViewGroup. Самый распространенный пример ViewGroup – это 
Layout. Layout бывает различных типов и отвечает за то, как будут 
расположены его дочерние View на экране: 

LinearLayout – отображает View-элементы в виде одной строки 

(если он Horizontal) или одного столбца (если он Vertical).

TableLayout – отображает элементы в виде таблицы, по строкам и 

столбцам.

RelativeLayout – для каждого элемента настраивается его положе
ние относительно других элементов.

AbsoluteLayout – для каждого элемента указывается явная позиция 

на экране в системе координат (x, y).

Рис. 1. Пример построения приложения

Набор и расположение View компонентов, которые необходимы на 

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

Рис. 2. Пример открытого layout-файла

Design и Text. Design — это графическое представление экрана 

(рис. 2), а Text — это текстовое представление. Text выглядит следующим образом:

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout 
xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context="example.myapplication.MainActivity">

<TextView

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

</android.support.constraint.ConstraintLayout>
Режимы отображения экрана. На скриншоте (рис.2) в области 3 

видно два экрана. Обычный белый и рядом с ним синий. Это один и 
тот же экран, но он отображен в двух разных режимах: Design и 
Blueprint.

Design - в нем отображены View компоненты так, как они обычно 

выглядят на экране. Blueprint - отображаются только контуры View 
компонентов.

Кнопки в области 2 позволяют переключать следующие режимы: 

Design, Blueprint, Design + Blueprint.

Экран. Здесь отображается как выглядит экран приложения. Сюда 

можно добавлять различные компоненты из области 4.

Палитра. Это список всех View компонентов, которые можно до
бавлять на экран: кнопки, поля ввода, checkbox, progressbar и прочее.

Дерево компонентов. Здесь представлена иерархия View компо
нентов экрана. На рис. 2, например, корневой элемент — это 
ConstraintLayout. А в него вложен TextView.

Свойства. При работе с каким-либо View компонентом отобража
ются его свойства. С помощью свойств можно настраивать внешний 
вид, расположение и содержимое View компонента.

При разработке, каждому Activity сопоставляется одноименный 

java-класс (наследник класса android.app.Activity). При запуске приложения, когда система должна показать Activity и в дальнейшем работать с ним, она будет вызывать методы этого класса. И от кода в 
этих методах зависит поведение Activity.

Метод onCreate – вызывается, когда приложение создает и отобра
жает Activity.

Метод setContentView(int) – устанавливает содержимое Activity из 

layout-файла. Но в качестве аргумента указывается не путь к layoutфайлу (res/layout/activity_main.xml), а константа, которая является ID 
файла. Эта константа генерируется автоматически в файле R.java. В 
этом классе хранятся сгенерированные ID для всех ресурсов проекта 
(из папки res/*), чтобы можно было к ним обращаться. Имена этих IDконстант совпадают с именами файлов ресурсов (без расширений). 

LAYOUT-ФАЙЛ ПРИ СМЕНЕ ОРИЕНТАЦИИ ЭКРАНА

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

Создание такого файла почти не отличается от создания обычного 

layout-файла. В папке res/layout создается новый Layout resource file, 
название которого будет одноименно с activity. Для того, чтобы приложение могло понять, что данный layout необходимо использовать в 
горизонтальном положении, необходимо добавить спецификатор 
Orientation. В случае необходимости горизонтальной ориентации, с 
параметром Landscape. При стандартной настройке спецификатора 
новый layout-файл будет создан в папке res/layout-land, а не res/layout, 
как обычно. Т.е. спецификатор –land указывает на то, что layoutфайлы из этой папки будут использованы в горизонтальной ориентации устройства.

Activity 
читает 
layout-файл, 
который 
указан 
в 
методе 

setContentView, например, myscreen.xml и отображает его содержимое. При этом учитывается ориентация устройства, и в случае горизонтальной ориентации используется myscreen из папки res/layout-land 
(если он существует).

Стоит учесть, что при повороте экрана активность создаётся зано
во и различного рода компоненты сбрасываются в начальное значение. Для сохранения данных у активности существует специальный 
метод onSaveInstanceState(), который вызывается системой перед методами onPause(), onStop() и onDestroy(). Метод позволяет сохранить 
значения простых типов в объекте Bundle. Класс Bundle — это простой способ хранения данных ключ/значение.

ОБРАБОТЧИКИ СОБЫТИЙ НА ПРИМЕРЕ BUTTON

Кнопка - один из самых распространенных элементов управления 

в программировании. Наследуется от TextView и является базовым 
классом для класса СompoundButton. От класса CompoundButton в 
свою 
очередь 
наследуются 
такие 
элементы 
как 
CheckBox, 

ToggleButton и RadioButton. В Android для кнопки используется класс 
android.widget.Button. На кнопке располагается текст и на кнопку 
нужно нажать, чтобы получить результат. Альтернативой ей может 
служить компонент ImageButton (android.widget.ImageButton), у которого вместо текста используется изображение.

В студии кнопка представлена компонентом Button в разделе 

Widgets. Управлять размером шрифта, цветом текста и другими свойствами можно через атрибут textAppearance, который задействует системные стили. Выпадающий список данного свойства содержит 
огромный перечень вариантов. Также можно вручную задать конкретные индивидуальные настройки через отдельные свойства.

Если 
растягивать 
кнопку 
по 
всей 
ширине 
экрана 

(android:layout_width="match_parent"), то дополнительно рекомендуется использовать атрибут android:layout_margin (или родственные 
ему layout_marginRight и layout_marginLeft) для создания отступов от 
краев экрана.

Один из способов обработки события при нажатии на кнопку явля
ется использование атрибута onClick:

android:onClick="onMyButtonClick
Имя для события можно выбрать произвольное. Далее следует 

прописать в классе активности имя метода, который будет обрабатывать нажатие. Метод должен быть открытым (public) и с одним параметром, использующим объект View. Метод необходимо поместить в 
класс:

public void onMyButtonClick(Viewview) {  

// выводим сообщение

Toast.makeText(this, "Вы нажали на кнопку", 
Toast.LENGTH_SHORT).show();  
}  
Когда пользователь нажимает на кнопку, то вызывается метод 

onMyButtonClick(), который в свою очередь генерирует всплывающее 
сообщение.

Данный способ применим не только к кнопке, но и к другим эле
ментам и позволяет сократить количество строк кода, за счет того, что 
Android сам определит кнопку, без ее объявления через конструкцию 
(Button) findViewById (R.id.button1). Но стоит заметить, что данный 
способ не будет работать в фрагментах. Кнопка должна быть частью 
активности, а не фрагмента.

Более 
традиционный 
способ 
Java 
через 
метод 

setOnClickListener(). Предположим, на экране уже есть кнопка button. 
В коде она объявляется обычным способом:

Button button = (Button) findViewById(R.id.button);
Следующий шаг - написание метода для нажатия. В результате 

должна получиться заготовка для обработки нажатия кнопки такого 
вида:

button.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View v) {   
}
});
Как вариант, можно вынести код для OnClickListener в отдельное 

место, это удобно, когда кнопок на экране несколько и такой подход 
позволит упорядочить код. Принцип такой же, немного меняется порядок. В предыдущем примере сразу был прописан в методе 
setOnClickListener слушатель new OnClickListener... с методом 
onClick(). Можно сначала отдельно объявить отдельную переменную 
myButtonClickListener:

OnClickListenermyButtonClickListener = newOnClickListener() {

@Override
public void onClick(View v) {
}

};
В конечном счете должна получиться готовая переменная, и те
перь, при наборе кода button.setOnClickListener, вместо new 
OnClickListener есть возможность вписать готовую переменную.

ПРИЛОЖЕНИЕ С НЕСКОЛЬКИМИ ЭКРАНАМИ (ACTIVITY)

Приложение не всегда состоит из одного экрана, оно может иметь 

несколько activity с набором различного функционала.

Для создания дополнительной activity необходимо создать новый 

XML-файл разметки activity _about.xml в папке res/layout. Далее необходимо создать класс для окна AboutActivity.java. Класс должен 
наследоваться от абстрактного класса Activity или его родственников 
типа FragmentActivity, AppCompatActivity и т.д. У класса активности 
должен быть метод onCreate(). 

В созданном методе нужно вызвать метод setContentView(), кото
рый подгрузит на экран подготовленную разметку.

Далее, для того, чтобы перейти на новый экран при нажатии кноп
ки на первом экране, необходимо написать обработчик нажатия в 
классе MainActivity:

public void onClick(View view) {

Intent intent = new Intent(MainActivity.this, AboutActiv
ity.class);

startActivity(intent);

}
Для запуска нового экрана необходимо создать экземпляр класса 

Intent и указать в первом параметре текущий класс, а во втором - класс 
для перехода. После этого вызывается метод startActivity(), который и 
запускает новый экран.

Необходимо зарегистрировать новый Activity в манифесте 

AndroidManifest.xml. В окне редактирования файла нужно добавить 

новый тег <activity> после закрывающего тега </activity> для первой 
активности:

<activity android:name=".AboutActivity"></activity>
Стоит обратить внимание, что второй создаваемый класс активно
сти должен наследоваться от класса Activity или ему похожих 
(ListActivity и др.), иметь XML-файл разметки и быть прописан в манифесте.

После вызова метода startActivity() запустится новая активность, 

которая станет видимой и переместится на вершину стека, содержащего работающие компоненты. При вызове метода finish() из новой 
активности (или при нажатии аппаратной клавиши возврата) она будет закрыта и удалена из стека. Разработчик также может перемещаться к предыдущей (или к любой другой) активности, используя 
всё тот же метод startActivity().

ДИАЛОГОВЫЕ ОКНА

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

Диалоговые окна в Android представляют собой полупрозрачные 

«плавающие» активности, частично перекрывающие родительский 
экран, из которого их вызвали. Как правило, они затеняют родительскую активность позади себя с помощью фильтров размывания или 
затемнения. Можно установить заголовок с помощью метода setTitle() 
и содержимое с помощью метода setContentView().

Dialog — это класс, принадлежащий Android SDK и помогающий 

работать с диалоговыми окнами в Android. Класс Dialog имеет 4 подкласса:
•
AlertDialog: это диалоговое окно для различных сообщений приложения, например, «Вы хотите купить мое приложение?» или 
что-то в этом роде. AlertDialog поддерживает три кнопки — утвердительную (OK), отрицательную (Cancel) и нейтральную (Later).

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

•
DatePickerDialog: диалоговое окно предлагает пользователю выбрать дату.

•
TimePickerDialog: диалоговое окно предлагает пользователю выбрать время.
Эти классы определяют стиль и структуру диалогового окна, одна
ко следует использовать DialogFragment в качестве контейнера диалогового окна. Класс DialogFragment предоставляет все функции, необ