Книга посвящена практическому применению Jetpack Compose — современного декларативного фреймворка для создания пользовательских интерфейсов в Android-приложениях. Показаны основы языка Kotlin, от базовых конструкций до сопрограмм и объектно-ориентированного программирования. Рассматриваются ключевые концепции Compose 1.6, включая построение пользовательских интерфейсов с помощью Composable-функций, управление состоянием, навигация, анимационные эффекты, и архитектура приложений. Отдельное внимание уделено работе с базами данных SQLite и библиотекой Room, биометрической аутентификации, встроенным покупкам, использованию карт Google Maps и публикации приложений в Google Play.
В книге представлены практические примеры и подробные пошаговые инструкции по работе в Android Studio Iguana и использованию возможностей Material Design 3.
Для начинающих и практикующих Android-разработчиков
Практическое руководство по созданию Android-приложений с использованием Jetpack Compose 1.6, Android Studio Iguana и Material Design 3.
Jetpack Compose — это современный декларативный фреймворк для разработки пользовательских интерфейсов в Android-приложениях, полностью основанный на языке Kotlin. С его помощью вы сможете создавать гибкие, масштабируемые и визуально привлекательные приложения с минимальными усилиями.
Эта книга — практическое руководство по созданию Android-приложений с использованием Jetpack Compose 1.6, Android Studio Iguana и Material Design 3. Подробно рассматриваются ключевые концепции фреймворка, включая компоненты интерфейса, управление состоянием, модификаторы, навигация и анимационные эффекты.
Особое внимание уделено архитектуре проектов и современным подходам к построению пользовательского интерфейса на основе Composable-функций.
Для кого эта книга?
- Начинающие Android-разработчики
- Программисты, переходящие на Jetpack Compose
- Те, кто хочет освоить современные подходы в создании мобильных приложений
Формат обучения:
- Теория + практика
- Пошаговые задания с готовым кодом
- Реальные примеры и лучшие практики
Что внутри книги?
Ключевые темы:
- Компоненты интерфейса
- Управление состоянием
- Модификаторы
- Навигация
- Анимации
- Архитектура приложений и работа с Composable-функциями
Дополнительные технологии:
- Kotlin (от основ до корутин и ООП)
- Работа с данными: SQLite, Room
- Биометрическая аутентификация
- Интеграция Google Maps
- Публикация в Google Play
Книгу “Основы JetPack Compose: Разработка приложений для Android с помощью Jetpack Compose, Android Studio и Kotlin” можно купить в нашем интенет-магазине.
Глава 1. Начало……………………………………………………………………………………… 22
1.1. Для Kotlin-программистов………………………………………………………………………………………………….. 23
1.2. Для новых Kotlin-программистов………………………………………………………………………………………. 23
1.3. Загрузка примеров кода……………………………………………………………………………………………………… 23
Глава 2. Настройка среды разработки Android Studio…………………………….. 24
2.1. Системные требования……………………………………………………………………………………………………….. 24
2.2. Загрузка пакета Android Studio………………………………………………………………………………………….. 24
2.3. Установка Android Studio…………………………………………………………………………………………………… 25
2.3.1. Установка в Windows……………………………………………………………………………………………….. 25
2.3.2. Установка в macOS………………………………………………………………………………………………….. 25
2.3.3. Установка в Linux…………………………………………………………………………………………………….. 26
2.4. Мастер установки Android Studio……………………………………………………………………………………… 26
2.5. Установка дополнительных пакетов Android SDK………………………………………………………….. 29
2.6. Установка инструментов командной строки Android SDK……………………………………………… 32
2.6.1. Windows 8.1……………………………………………………………………………………………………………….. 33
2.6.2. Windows 10………………………………………………………………………………………………………………… 34
2.6.3. Windows 11………………………………………………………………………………………………………………… 34
2.6.4. Linux………………………………………………………………………………………………………………………….. 34
2.6.5. macOS………………………………………………………………………………………………………………………… 34
2.7. Управлению памятью Android Studio………………………………………………………………………………… 35
2.8. Обновление Android Studio и SDK……………………………………………………………………………………… 36
2.9. Заключение………………………………………………………………………………………………………………………….. 36
Глава 3. Обзор Compose-проекта……………………………………………………………. 37
3.1. О проекте……………………………………………………………………………………………………………………………… 37
3.2. Создание проекта……………………………………………………………………………………………………………….. 37
3.3. Создание активити……………………………………………………………………………………………………………… 39
3.4. Определение параметров проекта и настроек для SDK………………………………………………….. 39
3.5. Включение нового UI-интерфейса в проект Android Studio…………………………………………….. 41
3.6. Предварительный просмотр тестового проекта………………………………………………………………. 42
3.7. Обзор главной активити……………………………………………………………………………………………………… 46
3.8. Предварительный просмотр обновлений…………………………………………………………………………. 50
3.9. Список материалов и версия Compose……………………………………………………………………………… 51
3.10. Заключение……………………………………………………………………………………………………………………….. 52
Глава 4. Пример Compose-проекта…………………………………………………………. 53
4.1. Начало работы……………………………………………………………………………………………………………………. 53
4.2. Удаление кода шаблона…………………………………………………………………………………………………….. 53
4.3. Иерархия компонуемых функций………………………………………………………………………………………. 54
4.4. Добавление компонуемой функции DemoText…………………………………………………………………. 54
4.5. Предварительный просмотр компонуемой функции DemoText……………………………………… 56
4.6. Добавление компонуемой функции DemoSlider……………………………………………………………….. 57
4.7. Добавление компонуемой функции DemoScreen……………………………………………………………… 58
4.8. Предварительный просмотр компонуемой функции DemoScreen………………………………….. 60
4.9. Настройка параметров предварительного просмотра……………………………………………………. 61
4.10. Тестирование в интерактивном режиме………………………………………………………………………….. 62
4.11. Завершение проекта…………………………………………………………………………………………………………. 62
4.12. Заключение……………………………………………………………………………………………………………………….. 63
Глава 5. Создание виртуального Android-устройства в Android Studio……. 64
5.1. О виртуальных устройствах Android………………………………………………………………………………… 64
5.2. Запуск эмулятора……………………………………………………………………………………………………………….. 66
5.3. Запуск приложения в AVD…………………………………………………………………………………………………. 68
5.4. Обновления в реальном времени с помощью Live Edit……………………………………………………. 69
5.5. Запуск на нескольких устройствах…………………………………………………………………………………… 71
5.6. Остановка работающего приложения………………………………………………………………………………. 72
5.7. Поддержка темной темы…………………………………………………………………………………………………….. 73
5.8. Запуск эмулятора в отдельном окне…………………………………………………………………………………. 74
5.9. Отключение рамки устройства………………………………………………………………………………………….. 76
5.10. Заключение……………………………………………………………………………………………………………………….. 78
Глава 6. Использование и настройка эмулятора для AVD в Android Studio 79
6.1. Среда эмулятора…………………………………………………………………………………………………………………. 79
6.2. Панель инструментов эмулятора………………………………………………………………………………………. 80
6.3. Работа в режиме масштабирования………………………………………………………………………………….. 81
6.4. Изменение размера окна эмулятора………………………………………………………………………………….. 82
6.5. Расширенные возможности управления…………………………………………………………………………… 82
6.5.1. Location (местоположение)……………………………………………………………………………………… 83
6.5.2. Displays (дисплеи)…………………………………………………………………………………………………….. 83
6.5.3. Cellular (сотовая связь)……………………………………………………………………………………………… 83
6.5.4. Battery (аккумулятор)………………………………………………………………………………………………. 83
6.5.5. Camera (камера)……………………………………………………………………………………………………….. 83
6.5.6. Phone (телефон)………………………………………………………………………………………………………… 83
6.5.7. Directional Pad (навигационная панель)…………………………………………………………………. 84
6.5.8. Microphone (микрофон)……………………………………………………………………………………………. 84
6.5.9. Fingerprint (отпечаток пальца)…………………………………………………………………………………. 84
6.5.10. Virtual Sensors (виртуальные датчики)…………………………………………………………………. 84
6.5.11. Snapshots (снимки)………………………………………………………………………………………………….. 84
6.5.12. Record and Playback (запись и воспроизведение)………………………………………………… 84
6.5.13. Google Play………………………………………………………………………………………………………………. 84
6.5.14. Settings (настройки)………………………………………………………………………………………………… 85
6.5.15. Help (помощь)…………………………………………………………………………………………………………. 85
6.6. Работа со снимками……………………………………………………………………………………………………………. 85
6.7. Настройка эмуляции отпечатков пальцев………………………………………………………………………… 85
6.8. Эмулятор в режиме окна инструментов……………………………………………………………………………. 88
6.9. Создание эмулятора с изменяемым размером………………………………………………………………….. 88
6.10. Заключение……………………………………………………………………………………………………………………….. 89
Глава 7. Обзор пользовательского интерфейса Android Studio……………….. 90
7.1. Экран приветствия………………………………………………………………………………………………………………. 90
7.2. Строка меню………………………………………………………………………………………………………………………… 91
7.3. Главное окно……………………………………………………………………………………………………………………….. 92
7.4. Окна инструментов……………………………………………………………………………………………………………… 94
7.5. Меню окон инструментов…………………………………………………………………………………………………… 97
7.6. Сочетания клавиш………………………………………………………………………………………………………………. 98
7.7. Навигация по Switcher и Recent Files…………………………………………………………………………………. 98
7.8. Изменение темы Android Studio……………………………………………………………………………………….. 100
7.9. Заключение……………………………………………………………………………………………………………………….. 101
Глава 8. Тестирование приложений на физическом Android-устройстве. 102
8.1. Обзор Android Debug Bridge (ADB)………………………………………………………………………………….. 102
8.2. Включение отладки ADB по USB на устройствах Android…………………………………………… 102
8.2.1. Конфигурация ADB на macOS………………………………………………………………………………. 104
8.2.2. Конфигурация ADB на Windows…………………………………………………………………………… 104
8.2.3. Конфигурация ADB на Linux………………………………………………………………………………… 105
8.3. Устранение проблем с USB-подключением……………………………………………………………………. 106
8.4. Включение беспроводной отладки на устройствах Android………………………………………… 106
8.5. Тестирование соединения adb…………………………………………………………………………………………. 109
8.6. Зеркалирование устройств………………………………………………………………………………………………. 110
8.7. Заключение……………………………………………………………………………………………………………………….. 110
Глава 9. Основы редактора кода Android Studio…………………………………… 111
9.1. Редактор кода Android Studio…………………………………………………………………………………………… 111
9.2. Разделение окна редактора……………………………………………………………………………………………… 114
9.3. Автозавершение кода……………………………………………………………………………………………………….. 115
9.4. Автозавершение операторов……………………………………………………………………………………………. 117
9.5. Информация о параметрах………………………………………………………………………………………………. 117
9.6. Подсказки имен параметров…………………………………………………………………………………………….. 118
9.7. Генерация кода…………………………………………………………………………………………………………………. 118
9.8. Сокрытие кода…………………………………………………………………………………………………………………… 119
9.9. Быстрый поиск документации…………………………………………………………………………………………. 121
9.10. Переформатирование кода…………………………………………………………………………………………….. 121
9.11. Поиск примера кода……………………………………………………………………………………………………….. 123
9.12. Живые шаблоны……………………………………………………………………………………………………………… 123
9.13. Заключение……………………………………………………………………………………………………………………… 124
Глава 10. Обзор архитектуры Android………………………………………………….. 125
10.1. Программный стек Android…………………………………………………………………………………………….. 125
10.2. Ядро Linux……………………………………………………………………………………………………………………….. 126
10.3. Слой аппаратной абстракции……………………………………………………………………………………….. 126
10.4. Android Runtime — ART…………………………………………………………………………………………………. 126
10.5. Библиотеки Android………………………………………………………………………………………………………… 127
10.5.1. Библиотеки C/C++………………………………………………………………………………………………. 128
10.6. Фреймворк приложений…………………………………………………………………………………………………. 128
10.7. Приложения…………………………………………………………………………………………………………………….. 129
10.8. Заключение……………………………………………………………………………………………………………………… 129
Глава 11. Введение в Kotlin………………………………………………………………….. 130
11.1. Что такое Kotlin?……………………………………………………………………………………………………………… 130
11.2. Kotlin и Java…………………………………………………………………………………………………………………….. 130
11.3. Преобразование из Java в Kotlin……………………………………………………………………………………. 131
11.4. Kotlin и Android Studio…………………………………………………………………………………………………….. 131
11.5. Эксперименты с Kotlin……………………………………………………………………………………………………. 131
11.6. Точки с запятой в Kotlin………………………………………………………………………………………………….. 132
11.7. Заключение……………………………………………………………………………………………………………………… 133
Глава 12. Типы данных и переменные в Kotlin…………………………………….. 134
12.1. Типы данных Kotlin………………………………………………………………………………………………………… 134
12.1.1. Целочисленные типы данных……………………………………………………………………………. 135
12.1.2. Типы данных с плавающей точкой…………………………………………………………………… 135
12.1.3. Тип данных Boolean…………………………………………………………………………………………… 135
12.1.4. Символьный тип данных……………………………………………………………………………………. 136
12.1.5. Тип данных String……………………………………………………………………………………………….. 136
12.1.6. Экранированные последовательности…………………………………………………………….. 137
12.2. Изменяемые переменные………………………………………………………………………………………………… 137
12.3. Неизменяемые переменные……………………………………………………………………………………………. 138
12.4. Объявление изменяемых и неизменяемых переменных……………………………………………….. 138
12.5. Типы данных являются объектами……………………………………………………………………………….. 139
12.6. Аннотации типов и вывод типов……………………………………………………………………………………. 139
12.7. Nullable-типы…………………………………………………………………………………………………………………… 140
12.8. Оператор безопасного вызова……………………………………………………………………………………….. 141
12.9. Ненулевые утверждения………………………………………………………………………………………………… 142
12.10. Nullable-типы и функция let………………………………………………………………………………………….. 142
12.11. Поздняя инициализация (lateinit)…………………………………………………………………………………. 144
12.12. Оператор Элвиса………………………………………………………………………………………………………….. 144
12.13. Приведение типов и проверка типов…………………………………………………………………………… 145
12.14. Заключение……………………………………………………………………………………………………………………. 145
Глава 13. Операторы и выражения в Kotlin………………………………………….. 146
13.1. Синтаксис выражений в Kotlin………………………………………………………………………………………. 146
13.2. Базовый оператор присваивания………………………………………………………………………………….. 146
13.3. Арифметические операторы в Kotlin…………………………………………………………………………….. 147
13.4. Расширенные операторы присваивания………………………………………………………………………. 147
13.5. Операторы инкремента и декремента…………………………………………………………………………… 148
13.6. Операторы равенства…………………………………………………………………………………………………….. 148
13.7. Булевы логические операторы………………………………………………………………………………………. 149
13.8. Оператор диапазона………………………………………………………………………………………………………. 150
13.9. Поразрядные операторы………………………………………………………………………………………………… 150
13.9.1. Поразрядная инверсия……………………………………………………………………………………….. 151
13.9.2. Поразрядное «И»………………………………………………………………………………………………… 151
13.9.3. Поразрядное «ИЛИ»…………………………………………………………………………………………… 151
13.9.4. Побитовое исключающее «ИЛИ»……………………………………………………………………… 152
13.9.5. Поразрядный сдвиг влево………………………………………………………………………………….. 152
13.9.6. Поразрядный сдвиг вправо………………………………………………………………………………… 153
13.10. Заключение……………………………………………………………………………………………………………………. 153
Глава 14. Управление потоком в Kotlin………………………………………………… 154
14.1. Циклический поток управления…………………………………………………………………………………….. 154
14.1.1. Оператор for-in в Kotlin………………………………………………………………………………………. 154
14.1.2. Цикл while……………………………………………………………………………………………………………. 156
14.1.3. Цикл do… while…………………………………………………………………………………………………….. 156
14.1.4. Выход из циклов…………………………………………………………………………………………………. 157
14.1.5. Оператор continue………………………………………………………………………………………………. 157
14.1.6. Метки break и continue……………………………………………………………………………………….. 158
14.2. Условный поток управления………………………………………………………………………………………….. 159
14.2.1. Выражения if………………………………………………………………………………………………………. 159
14.2.2. Выражения if… else……………………………………………………………………………………………… 160
14.2.3. Выражения if… else if………………………………………………………………………………………….. 160
14.2.4. Оператор when……………………………………………………………………………………………………. 161
14.3. Заключение……………………………………………………………………………………………………………………… 161
Глава 15. Обзор функций и лямбда-выражений в Kotlin………………………. 162
15.1. Что такое функция?…………………………………………………………………………………………………………. 162
15.2. Как объявить функцию Kotlin………………………………………………………………………………………… 162
15.3. Вызов функции Kotlin……………………………………………………………………………………………………… 163
15.4. Функции с одним выражением………………………………………………………………………………………. 163
15.5. Локальные функции………………………………………………………………………………………………………… 164
15.6. Обработка возвращаемых значений…………………………………………………………………………….. 164
15.7. Объявление параметров функции по умолчанию………………………………………………………… 164
15.8. Переменное число параметров функции………………………………………………………………………. 165
15.9. Лямбда-выражения…………………………………………………………………………………………………………. 166
15.10. Функции высшего порядка…………………………………………………………………………………………… 167
15.11. Заключение……………………………………………………………………………………………………………………. 168
Глава 16. Основы объектно-ориентированного программирования
в Kotlin…………………………………………………………………………………………………. 169
16.1. Что такое объект?……………………………………………………………………………………………………………. 169
16.2. Что такое класс?……………………………………………………………………………………………………………… 169
16.3. Объявление класса в Kotlin…………………………………………………………………………………………….. 169
16.4. Добавление свойств в класс…………………………………………………………………………………………… 170
16.5. Определение методов……………………………………………………………………………………………………… 170
16.6. Объявление и инициализация экземпляра класса……………………………………………………….. 171
16.7. Главные и вторичные конструкторы…………………………………………………………………………….. 171
16.8. Блоки инициализаторов…………………………………………………………………………………………………. 173
16.9. Вызов методов и доступ к свойствам……………………………………………………………………………. 174
16.10. Пользовательские аксессоры………………………………………………………………………………………. 174
16.11. Вложенные и внутренние классы………………………………………………………………………………… 175
16.12. Объекты-компаньоны…………………………………………………………………………………………………… 176
16.13. Заключение……………………………………………………………………………………………………………………. 178
Глава 17. Введение в наследование и подклассы в Kotlin…………………….. 179
17.1. Наследование, классы и подклассы……………………………………………………………………………… 179
17.2. Синтаксис подклассов……………………………………………………………………………………………………. 179
17.3. Пример наследования в Kotlin……………………………………………………………………………………….. 181
17.4. Расширение функционала подкласса…………………………………………………………………………… 182
17.5. Переопределение унаследованных методов………………………………………………………………… 182
17.6. Добавление пользовательского вторичного конструктора………………………………………… 184
17.7. Использование класса SavingsAccount…………………………………………………………………………. 184
17.8. Заключение……………………………………………………………………………………………………………………… 185
Глава 18. Обзор Compose……………………………………………………………………… 186
18.1. Разработка до Compose…………………………………………………………………………………………………. 186
18.2. Декларативный синтаксис Compose…………………………………………………………………………….. 187
18.3. Compose, управляемый данными………………………………………………………………………………….. 187
18.4. Заключение……………………………………………………………………………………………………………………… 188
Глава 19. Руководство по каталогам версий Gradle……………………………… 189
19.1. Зависимости библиотек и плагинов………………………………………………………………………………. 189
19.2. Файл сборки пакета в Gradle………………………………………………………………………………………….. 189
19.3. Файлы сборки модуля в Gradle………………………………………………………………………………………. 190
19.4. Файл version catalog………………………………………………………………………………………………………… 190
19.5. Добавление зависимостей……………………………………………………………………………………………… 192
19.6. Обновления библиотек…………………………………………………………………………………………………… 193
19.7. Заключение……………………………………………………………………………………………………………………… 193
Глава 20. Обзор компонуемых функций………………………………………………. 194
20.1. Что такое компонуемая функция?…………………………………………………………………………………. 194
20.2. Компонуемые функции с сохранением и без сохранения состояния…………………………. 194
20.3. Синтаксис компонуемой функции…………………………………………………………………………………. 195
20.4. Компонуемые функции Foundation и Material……………………………………………………………… 197
20.5. Заключение……………………………………………………………………………………………………………………… 199
Глава 21. Обзор состояния и рекомпозиции в Compose………………………… 200
21.1. Основы состояния…………………………………………………………………………………………………………… 200
21.2. Знакомство с рекомпозицией…………………………………………………………………………………………. 200
21.3. Создание проекта StateExample……………………………………………………………………………………. 201
21.4. Объявление состояния в компонуемой функции………………………………………………………….. 201
21.5. Однонаправленный поток данных………………………………………………………………………………… 205
21.6. Подъем состояния…………………………………………………………………………………………………………… 207
21.7. Сохранение состояния через изменения конфигурации……………………………………………… 210
21.8. Заключение……………………………………………………………………………………………………………………… 211
Глава 22. Введение в Composition Local………………………………………………… 213
22.1. Понимание CompositionLocal………………………………………………………………………………………… 213
22.2. Использование CompositionLocal………………………………………………………………………………….. 215
22.3. Создание проекта CompLocalDemo……………………………………………………………………………… 215
22.4. Разработка макета………………………………………………………………………………………………………….. 216
22.5. Добавление состояния CompositionLocal…………………………………………………………………….. 217
22.6. Доступ к состоянию CompositionLocal…………………………………………………………………………. 218
22.7. Тестирование дизайна……………………………………………………………………………………………………. 218
22.8. Заключение……………………………………………………………………………………………………………………… 220
Глава 23. Обзор API-слотов в Compose…………………………………………………. 221
23.1. Понимание API-слотов…………………………………………………………………………………………………… 221
23.2. Объявление API-слота……………………………………………………………………………………………………. 222
23.3. Вызов компонуемых API-слотов……………………………………………………………………………………. 223
23.4. Заключение……………………………………………………………………………………………………………………… 224
Глава 24. Пособие по API-слотам в Compose………………………………………… 225
24.1. О проекте…………………………………………………………………………………………………………………………. 225
24.2. Создание проекта SlotApiDemo…………………………………………………………………………………….. 225
24.3. Подготовка файла для класса MainActivity…………………………………………………………………. 225
24.4. Создание компонуемой функции MainScreen………………………………………………………………. 226
24.5. Добавление компонуемой функции ScreenContent………………………………………………………. 227
24.6. Создание компонуемой функции Checkbox…………………………………………………………………. 228
24.7. Реализация API-слотов в ScreenContent……………………………………………………………………….. 229
24.8. Добавление ресурса рисования изображения……………………………………………………………… 231
24.9. Кодирование компонуемой функции TitleImage………………………………………………………….. 233
24.10. Заполнение компонуемой функции MainScreen…………………………………………………………. 233
24.11. Предварительный просмотр проекта………………………………………………………………………….. 235
24.12. Заключение……………………………………………………………………………………………………………………. 237
Глава 25. Использование модификаторов в Compose……………………………. 238
25.1. Обзор модификаторов…………………………………………………………………………………………………….. 238
25.2. Создание проекта ModifierDemo…………………………………………………………………………………… 239
25.3. Создание модификатора………………………………………………………………………………………………… 240
25.4. Порядок модификаторов………………………………………………………………………………………………… 241
25.5. Добавление поддержки модификаторов в компонуемую функцию…………………………… 242
25.6. Общие встроенные модификаторы……………………………………………………………………………….. 246
25.7. Объединение модификаторов………………………………………………………………………………………… 246
25.8. Заключение……………………………………………………………………………………………………………………… 247
Глава 26. Аннотированные строки и стили инструмента Brush……………. 248
26.1. Что такое аннотированные строки?……………………………………………………………………………… 248
26.2. Использование аннотированных строк………………………………………………………………………… 248
26.3. Стилизация текста с помощью инструмента Brush……………………………………………………… 249
26.4. Создание проекта для демонстрации……………………………………………………………………………. 250
26.5. Пример аннотированной строки SpanStyle………………………………………………………………….. 250
26.6. Пример аннотированной строки ParagraphStyle………………………………………………………….. 252
26.7. Пример стиля Brush………………………………………………………………………………………………………… 254
26.8. Заключение……………………………………………………………………………………………………………………… 256
Глава 27. Создание макетов с помощью компонуемых функций Row и Column 257
27.1. Создание проекта RowColDemo……………………………………………………………………………………. 257
27.2. Компонуемая функция Row……………………………………………………………………………………………. 258
27.3. Компонуемая функция Column……………………………………………………………………………………… 259
27.4. Объединение компонуемых функций Row и Column…………………………………………………… 259
27.5. Выравнивание макета…………………………………………………………………………………………………….. 260
27.6. Позиционирование макета…………………………………………………………………………………………….. 263
27.7. Интервал между расположениями макета……………………………………………………………………. 265
27.8. Модификаторы области действия для компонентов Row и Column………………………….. 266
27.9. Веса модификаторов области действия……………………………………………………………………….. 270
27.10. Заключение……………………………………………………………………………………………………………………. 271
Глава 28. Макеты компонента Box в Compose……………………………………… 272
28.1. Введение в компонуемую функцию Box……………………………………………………………………….. 272
28.2. Создание проекта BoxLayout………………………………………………………………………………………… 272
28.3. Добавление компонуемой функции TextCell………………………………………………………………… 273
28.4. Добавление макета Box…………………………………………………………………………………………………. 273
28.5. Выравнивание в Box………………………………………………………………………………………………………. 274
28.6. Модификаторы области действия BoxScope……………………………………………………………….. 276
28.7. Использование модификатора clip………………………………………………………………………………… 277
28.8. Заключение……………………………………………………………………………………………………………………… 278
Глава 29. Введение в FlowRow и FlowColumn……………………………………….. 279
29.1. Компонуемые функции FlowColumn и FlowRow………………………………………………………….. 279
29.2. Максимальное количество элементов………………………………………………………………………….. 280
29.3. Работа с расположением главной оси………………………………………………………………………….. 281
29.4. Понимание поперечного расположения по осям…………………………………………………………. 282
29.5. Выравнивание элементов………………………………………………………………………………………………. 282
29.6. Управление размером элемента……………………………………………………………………………………. 283
29.7. Заключение……………………………………………………………………………………………………………………… 284
Глава 30. Руководство по FlowRow и FlowColumn………………………………… 285
30.1. Создание проекта FlowLayoutDemo……………………………………………………………………………… 285
30.2. Генерация случайных значений для высоты и цвета………………………………………………….. 286
30.3. Добавление компонуемой функции Box……………………………………………………………………….. 287
30.4. Изменение расположения макета Flow…………………………………………………………………………. 288
30.5. Изменение выравнивания элементов…………………………………………………………………………….. 289
30.6. Переключение на FlowColumn………………………………………………………………………………………. 290
30.7. Использование перекрестного расположения……………………………………………………………… 291
30.8. Добавление весов для элементов…………………………………………………………………………………… 292
30.9. Заключение……………………………………………………………………………………………………………………… 293
Глава 31. Пользовательские модификаторы макета…………………………….. 294
31.1. Основы компоновки макета в Compose………………………………………………………………………… 294
31.2. Пользовательские макеты………………………………………………………………………………………………. 295
31.3. Создание проекта LayoutModifier…………………………………………………………………………………. 295
31.4. Добавление компонуемой функции ColorBox………………………………………………………………. 295
31.5. Создание пользовательского модификатора макета…………………………………………………… 296
31.6. Понимание позиции по умолчанию………………………………………………………………………………. 297
31.7. Завершение модификатора макета……………………………………………………………………………….. 297
31.8. Использование пользовательского модификатора……………………………………………………… 299
31.9. Работа с линиями выравнивания…………………………………………………………………………………… 299
31.10. Работа с базовыми линиями………………………………………………………………………………………… 302
31.11. Заключение……………………………………………………………………………………………………………………. 303
Глава 32. Создание пользовательских макетов…………………………………….. 304
32.1. Обзор пользовательских макетов………………………………………………………………………………….. 304
32.2. Синтаксис пользовательского макета…………………………………………………………………………… 304
32.3. Использование пользовательского макета…………………………………………………………………… 306
32.4. Создание проекта CustomLayout………………………………………………………………………………….. 306
32.5. Создание компонуемой функции CascadeLayout………………………………………………………… 307
32.6. Использование компонуемой функции CascadeLayout………………………………………………. 309
32.7. Заключение……………………………………………………………………………………………………………………… 310
Глава 33. Руководство по ConstraintLayout в Compose…………………………. 311
33.1. Введение в ConstraintLayout………………………………………………………………………………………….. 311
33.2. Как работает ConstraintLayout……………………………………………………………………………………… 311
33.2.1. Ограничения……………………………………………………………………………………………………….. 312
33.2.2. Поля……………………………………………………………………………………………………………………… 312
33.2.3. Противоположные ограничения……………………………………………………………………….. 313
33.2.4. Смещение ограничений……………………………………………………………………………………… 313
33.2.5. Цепочки……………………………………………………………………………………………………………….. 314
33.2.6. Стили цепочки…………………………………………………………………………………………………….. 315
33.3. Настройка размеров……………………………………………………………………………………………………….. 316
33.4. Направляющие линии…………………………………………………………………………………………………….. 317
33.5. Барьеры……………………………………………………………………………………………………………………………. 317
33.6. Заключение……………………………………………………………………………………………………………………… 319
Глава 34. Работа с ConstraintLayout в Compose…………………………………….. 320
34.1. Вызов ConstraintLayout………………………………………………………………………………………………….. 320
34.2. Генерация ссылок…………………………………………………………………………………………………………… 320
34.3. Назначение ссылки на компонуемую функцию…………………………………………………………… 321
34.4. Добавление ограничений……………………………………………………………………………………………….. 321
34.5. Создание проекта ConstraintLayout……………………………………………………………………………… 322
34.6. Добавление библиотеки ConstraintLayout……………………………………………………………………. 322
34.7. Добавление пользовательской компонуемой функции button……………………………………. 323
34.8. Базовые ограничения……………………………………………………………………………………………………… 324
34.9. Противоположные ограничения……………………………………………………………………………………. 325
34.10. Смещение ограничений………………………………………………………………………………………………… 327
34.11. Ограничения полями…………………………………………………………………………………………………….. 327
34.12. Важность противоположных ограничений и смещений…………………………………………… 329
34.13. Создание цепочек…………………………………………………………………………………………………………. 332
34.14. Работа с направляющими линиями…………………………………………………………………………….. 333
34.15. Работа с барьерами………………………………………………………………………………………………………. 334
34.16. Наборы ограничений……………………………………………………………………………………………………. 338
34.17. Заключение……………………………………………………………………………………………………………………. 340
Глава 35. Работа с IntrinsicSize в Compose…………………………………………….. 341
35.1. Внутренние измерения……………………………………………………………………………………………………. 341
35.2. Измерение максимального и минимального внутреннего размера……………………………. 342
35.3. О проекте…………………………………………………………………………………………………………………………. 343
35.4. Создание проекта IntrinsicSizeDemo……………………………………………………………………………… 343
35.5. Создание пользовательского текстового поля…………………………………………………………….. 344
35.6. Добавление компонентов Text и Box……………………………………………………………………………. 344
35.7. Добавление столбца верхнего уровня………………………………………………………………………….. 345
35.8. Тестирование проекта……………………………………………………………………………………………………. 346
35.9. Применение измерений IntrinsicSize.Max……………………………………………………………………… 346
35.10. Применение измерений IntrinsicSize.Min…………………………………………………………………….. 347
35.11. Заключение……………………………………………………………………………………………………………………. 347
Глава 36. Корутины и LaunchedEffects в Jetpack Compose…………………….. 348
36.1. Что такое корутины?………………………………………………………………………………………………………. 348
36.2. Потоки против корутинов………………………………………………………………………………………………. 349
36.3. Область действия корутинов…………………………………………………………………………………………. 349
36.4. Функции приостановки…………………………………………………………………………………………………… 350
36.5. Диспетчеры корутинов…………………………………………………………………………………………………… 350
36.6. Конструкторы корутинов………………………………………………………………………………………………. 351
36.7. Job…………………………………………………………………………………………………………………………………….. 352
36.8. Приостановка и возобновление корутинов………………………………………………………………….. 352
36.9. Канал связи для корутинов……………………………………………………………………………………………. 354
36.10. Понимание побочных эффектов………………………………………………………………………………….. 354
36.11. Заключение……………………………………………………………………………………………………………………. 356
Глава 37. Обзор компонуемых функций List и Grid в Compose…………….. 357
37.1. Стандартные и ленивые списки…………………………………………………………………………………….. 357
37.2. Работа со списками Column и Row……………………………………………………………………………….. 358
37.3. Создание ленивых списков…………………………………………………………………………………………….. 358
37.4. Включение прокрутки с помощью ScrollState………………………………………………………………. 359
37.5. Программная прокрутка………………………………………………………………………………………………… 360
37.6. Липкие заголовки……………………………………………………………………………………………………………. 362
37.7. Создание ленивой сетки…………………………………………………………………………………………………. 364
37.8. Заключение……………………………………………………………………………………………………………………… 366
Глава 38. Руководство по спискам на основе Row и Column………………… 367
38.1. Создание проекта ListDemo…………………………………………………………………………………………… 367
38.2. Создание списка на основе Column………………………………………………………………………………. 367
38.3. Включение прокрутки списка………………………………………………………………………………………… 369
38.4. Ручная прокрутка……………………………………………………………………………………………………………. 370
38.5. Пример списка на основе Row……………………………………………………………………………………….. 372
38.6. Заключение……………………………………………………………………………………………………………………… 373
Глава 39. Руководство по ленивым спискам в Compose……………………….. 374
39.1. Создание проекта LazyListDemo…………………………………………………………………………………… 374
39.2. Добавление данных списка в проект…………………………………………………………………………….. 374
39.3. Чтение данных XML……………………………………………………………………………………………………….. 376
39.4. Обработка загрузки изображений…………………………………………………………………………………. 377
39.5. Проектирование компонуемой функции для элементов списка…………………………………. 380
39.6. Создание ленивого списка……………………………………………………………………………………………… 381
39.7. Тестирование проекта……………………………………………………………………………………………………. 382
39.8. Делаем элементы списка интерактивными…………………………………………………………………… 383
39.9. Заключение……………………………………………………………………………………………………………………… 385
Глава 40. Липкие заголовки и обнаружение прокрутки в ленивых списках 386
40.1. Группировка данных в элементах списка……………………………………………………………………. 386
40.2. Отображение заголовков и элементов………………………………………………………………………….. 386
40.3. Добавление липких заголовков……………………………………………………………………………………… 387
40.4. Реакция на изменение позиции прокрутки……………………………………………………………………. 389
40.5. Добавление кнопки прокрутки………………………………………………………………………………………. 390
40.6. Тестирование готового приложения……………………………………………………………………………… 392
40.7. Заключение……………………………………………………………………………………………………………………… 392
Глава 41. Руководство по ленивой неравномерной сетке в Compose…….. 393
41.1. Ленивые неравномерные сетки……………………………………………………………………………………… 393
41.2. Создание проекта StaggeredGridDemo………………………………………………………………………….. 395
41.3. Добавление компонуемой функции Box……………………………………………………………………….. 395
41.4. Генерация случайных значений высоты и цвета…………………………………………………………. 396
41.5. Создание неравномерного списка…………………………………………………………………………………. 397
41.6. Тестирование проекта……………………………………………………………………………………………………. 398
41.7. Переключение на горизонтальную неравномерную сетку…………………………………………. 398
41.8. Заключение……………………………………………………………………………………………………………………… 400
Глава 42. VerticalPager и HorizontalPager в Compose……………………………. 401
42.1. Компонуемая функция Pager………………………………………………………………………………………….. 401
42.2. Работа с состоянием пейджера……………………………………………………………………………………… 403
42.3. О проекте PagerDemo……………………………………………………………………………………………………… 404
42.4. Создание проекта PagerDemo………………………………………………………………………………………… 404
42.5. Добавление изображений с обложками книг……………………………………………………………….. 404
42.6. Добавление HorizontalPager…………………………………………………………………………………………… 405
42.7. Создание содержимого страницы…………………………………………………………………………………. 406
42.8. Тестирование пейджера…………………………………………………………………………………………………. 407
42.9. Добавление кнопок со стрелками………………………………………………………………………………….. 408
42.10. Заключение……………………………………………………………………………………………………………………. 411
Глава 43. Анимация в Compose…………………………………………………………….. 412
43.1. Создание проекта AnimateVisibility………………………………………………………………………………. 412
43.2. Анимация видимости………………………………………………………………………………………………………. 413
43.3. Определение анимаций входа и выхода………………………………………………………………………. 416
43.4. Спецификации и плавность анимации………………………………………………………………………….. 417
43.5. Повтор анимации……………………………………………………………………………………………………………. 419
43.6. Разные анимации для разных дочерних элементов…………………………………………………….. 419
43.7. Автозапуск анимации…………………………………………………………………………………………………….. 421
43.8. Реализация кроссфейдинга…………………………………………………………………………………………….. 422
43.9. Заключение……………………………………………………………………………………………………………………… 423
Глава 44. Анимация, основанная на состоянии……………………………………. 424
44.1. Понимание анимации, управляемой состоянием…………………………………………………………. 424
44.2. Знакомство с функциями «анимация как состояние»…………………………………………………… 424
44.3. Создание проекта AnimateState…………………………………………………………………………………….. 425
44.4. Анимация вращения с помощью animateFloatAsState…………………………………………………. 426
44.5. Анимация изменения цвета с помощью animateColorAsState…………………………………….. 429
44.6. Анимация движения с помощью animateDpAsState…………………………………………………….. 432
44.7. Добавление эффектов пружины…………………………………………………………………………………….. 435
44.8. Работа с ключевыми кадрами……………………………………………………………………………………….. 436
44.9. Объединение нескольких анимаций……………………………………………………………………………… 437
44.10. Использование инспектора анимации………………………………………………………………………… 440
44.11. Заключение……………………………………………………………………………………………………………………. 441
Глава 45. Рисование графики с помощью Canvas в Compose……………….. 442
45.1. Знакомство с компонентом Canvas……………………………………………………………………………….. 442
45.2. Создание проекта CanvasDemo…………………………………………………………………………………….. 442
45.3. Рисование линии и получение размера холста……………………………………………………………. 443
45.4. Рисование пунктирных линий……………………………………………………………………………………….. 444
45.5. Рисование прямоугольника……………………………………………………………………………………………. 445
45.6. Применение вращения……………………………………………………………………………………………………. 449
45.7. Рисование кругов и овалов…………………………………………………………………………………………….. 449
45.8. Рисование градиентов…………………………………………………………………………………………………….. 451
45.9. Рисование дуг………………………………………………………………………………………………………………….. 454
45.10. Рисование путей……………………………………………………………………………………………………………. 455
45.11. Рисование точек……………………………………………………………………………………………………………. 456
45.12. Рисование изображения……………………………………………………………………………………………….. 457
45.13. Рисование текста…………………………………………………………………………………………………………… 460
45.14. Заключение……………………………………………………………………………………………………………………. 462
Глава 46. Работа с ViewModels в Compose…………………………………………….. 463
46.1. Что такое Android Jetpack?…………………………………………………………………………………………….. 463
46.2. «Старая» архитектура……………………………………………………………………………………………………. 463
46.3. Современная архитектура Android……………………………………………………………………………….. 464
46.4. Компонент ViewModel……………………………………………………………………………………………………. 464
46.5. Реализация ViewModel с помощью состояния……………………………………………………………… 465
46.6. Подключение состояния ViewModel к активити…………………………………………………………… 466
46.7. Реализация ViewModel с использованием LiveData…………………………………………………….. 468
46.8. Наблюдение за LiveData для ViewModel внутри активити…………………………………………. 468
46.9. Заключение……………………………………………………………………………………………………………………… 469
Глава 47. Руководство по ViewModel в Compose…………………………………… 470
47.1. О проекте…………………………………………………………………………………………………………………………. 470
47.2. Создание проекта ViewModelDemo………………………………………………………………………………. 471
47.3. Добавление ViewModel…………………………………………………………………………………………………… 472
47.4. Доступ к DemoViewModel из MainActivity……………………………………………………………………. 473
47.5. Проектирование компонуемой функции для ввода температуры………………………………. 474
47.6. Проектирование компонуемой функции для ввода температуры………………………………. 476
47.7. Завершение дизайна пользовательского интерфейса…………………………………………………. 479
47.8. Тестирование приложения…………………………………………………………………………………………….. 480
47.9. Заключение……………………………………………………………………………………………………………………… 480
Глава 48. Обзор базы данных SQLite……………………………………………………. 481
48.1. Понимание таблиц базы данных…………………………………………………………………………………… 481
48.2. Знакомство со схемой базы данных……………………………………………………………………………… 481
48.3. Столбцы и типы данных………………………………………………………………………………………………… 482
48.4. Строки базы данных………………………………………………………………………………………………………. 482
48.5. Введение в первичные ключи………………………………………………………………………………………… 482
48.6. Что такое SQLite?……………………………………………………………………………………………………………. 483
48.7. Язык структурированных запросов………………………………………………………………………………. 483
48.8. Тестирование SQLite на виртуальном устройстве Android…………………………………………. 484
48.9. Android-библиотека Room для хранения данных на устройстве………………………………. 486
48.10. Заключение……………………………………………………………………………………………………………………. 486
Глава 49. Базы данных Room в Compose………………………………………………. 487
49.1. Пересмотр современной архитектуры приложений……………………………………………………. 487
49.2. Ключевые элементы базы данных Room……………………………………………………………………… 488
49.2.1. Репозиторий………………………………………………………………………………………………………… 488
49.2.2. База данных Room…………………………………………………………………………………………….. 488
49.2.3. Объект доступа к данным (DAO)………………………………………………………………………. 488
49.2.4. Сущности…………………………………………………………………………………………………………….. 488
49.2.5. База данных SQLite……………………………………………………………………………………………. 489
49.3. Понимание сущностей……………………………………………………………………………………………………. 490
49.4. Объекты доступа к данным……………………………………………………………………………………………. 492
49.5. База данных Room…………………………………………………………………………………………………………. 494
49.6. Репозиторий…………………………………………………………………………………………………………………….. 495
49.7. Базы данных, хранящиеся в памяти……………………………………………………………………………… 496
49.8. Инспектор баз данных……………………………………………………………………………………………………. 496
49.9. Заключение……………………………………………………………………………………………………………………… 497
Глава 50. Руководство по базам данных Room и Репозиторию в Compose 498
50.1. О проекте RoomDemo…………………………………………………………………………………………………….. 498
50.2. Создание проекта RoomDemo………………………………………………………………………………………. 498
50.3. Модификация конфигурации сборки…………………………………………………………………………….. 499
50.4. Создание сущности………………………………………………………………………………………………………… 501
50.5. Создание DAO…………………………………………………………………………………………………………………. 502
50.6. Добавление базы данных Room……………………………………………………………………………………. 503
50.7. Добавление репозитория……………………………………………………………………………………………….. 504
50.8. Добавление ViewModel…………………………………………………………………………………………………… 506
50.9. Проектирование пользовательского интерфейса………………………………………………………… 508
50.10. Написание класса ViewModelProviderFactory……………………………………………………………. 510
50.11. Завершение функции MainScreen………………………………………………………………………………… 512
50.12. Тестирование приложения RoomDemo………………………………………………………………………. 515
50.13. Использование Database Inspector………………………………………………………………………………. 515
50.14. Заключение……………………………………………………………………………………………………………………. 516
Глава 51. Обзор навигации в Compose…………………………………………………. 517
51.1. Понимание навигации…………………………………………………………………………………………………….. 517
51.2. Объявление контроллера навигации…………………………………………………………………………….. 519
51.3. Объявление хоста навигации…………………………………………………………………………………………. 519
51.4. Добавление пунктов назначения в навигационный граф……………………………………………. 520
51.5. Навигация к пунктам назначения………………………………………………………………………………….. 522
51.6. Передача аргументов в пункт назначения……………………………………………………………………. 523
51.7. Работа с нижними навигационными панелями……………………………………………………………. 525
51.8. Заключение……………………………………………………………………………………………………………………… 526
Глава 52. Руководство по навигации в Compose…………………………………… 527
52.1. Создание проекта NavigationDemo……………………………………………………………………………….. 527
52.2. О проекте NavigationDemo…………………………………………………………………………………………….. 528
52.3. Объявление маршрутов навигации……………………………………………………………………………….. 528
52.4. Добавление домашнего экрана……………………………………………………………………………………… 528
52.5. Добавление экрана приветствия……………………………………………………………………………………. 530
52.6. Добавление экрана профиля………………………………………………………………………………………….. 531
52.7. Создание контроллера навигации и хоста…………………………………………………………………… 531
52.8. Реализация навигации по экрану………………………………………………………………………………….. 532
52.9. Передача аргумента имени пользователя……………………………………………………………………. 533
52.10. Тестирование проекта………………………………………………………………………………………………….. 534
52.11. Заключение……………………………………………………………………………………………………………………. 535
Глава 53. Руководство по навигационной панели в Compose……………….. 536
53.1. Создание проекта BottomBarDemo………………………………………………………………………………. 536
53.2. Объявление маршрутов навигации……………………………………………………………………………….. 537
53.3. Проектирование элементов панели………………………………………………………………………………. 537
53.4. Создание списка элементов панели………………………………………………………………………………. 538
53.5. Добавление экранов назначения…………………………………………………………………………………… 539
53.6. Создание контроллера и хоста навигации…………………………………………………………………… 541
53.7. Проектирование панели навигации………………………………………………………………………………. 541
53.8. Работа с компонентом Scaffold……………………………………………………………………………………… 543
53.9. Тестирование проекта……………………………………………………………………………………………………. 544
53.10. Заключение……………………………………………………………………………………………………………………. 545
Глава 54. Распознавание жестов в Compose………………………………………….. 546
54.1. Распознавание жестов в Compose…………………………………………………………………………………. 546
54.2. Создание проекта GestureDemo…………………………………………………………………………………….. 546
54.3. Обнаружение жестов нажатия………………………………………………………………………………………. 547
54.4. Обнаружение нажатий с помощью PointerInputScope………………………………………………… 548
54.5. Обнаружение жестов перетаскивания………………………………………………………………………….. 550
54.6. Обнаружение жестов перетаскивания с помощью PointerInputScope……………………….. 552
54.7. Прокрутка с помощью модификатора scrollable………………………………………………………….. 553
54.8. Модификаторы прокрутки…………………………………………………………………………………………….. 554
54.9. Обнаружение жестов сжатия…………………………………………………………………………………………. 556
54.10. Определение жестов вращения……………………………………………………………………………………. 558
54.11. Обнаружение жестов сдвига………………………………………………………………………………………… 559
54.12. Заключение……………………………………………………………………………………………………………………. 560
Глава 55. Работа с закрепленными перетаскиваемыми компонентами… 561
55.1. Перетаскивание и якоря…………………………………………………………………………………………………. 561
55.2. Обнаружение жестов перетаскивания………………………………………………………………………….. 561
55.3. Объявление точек привязки……………………………………………………………………………………………. 562
55.4. Объявление порогов……………………………………………………………………………………………………….. 562
55.5. Объявление перетаскиваемого состояния…………………………………………………………………….. 562
55.6. Перемещение компонента в ответ на жест перетаскивания……………………………………….. 563
55.7. О проекте DraggableDemo………………………………………………………………………………………………. 564
55.8. Создание проекта DraggableDemo………………………………………………………………………………… 564
55.9. Добавление библиотеки Foundation……………………………………………………………………………… 565
55.10. Добавление перечислений якорей………………………………………………………………………………. 565
55.11. Настройка перетаскиваемого состояния и якорей…………………………………………………….. 566
55.12. Проектирование родительского элемента Box………………………………………………………….. 567
55.13. Добавление перетаскиваемого элемента Box……………………………………………………………. 569
55.14. Тестирование проекта………………………………………………………………………………………………….. 572
55.15. Заключение……………………………………………………………………………………………………………………. 572
Глава 56. Введение в потоки Kotlin………………………………………………………. 573
56.1. Понимание потоков………………………………………………………………………………………………………… 573
56.2. Создание примера проекта……………………………………………………………………………………………. 574
56.3. Добавление модели представления в проект……………………………………………………………….. 575
56.4. Объявление потока…………………………………………………………………………………………………………. 575
56.5. Передача потоковых данных………………………………………………………………………………………… 576
56.6. Сбор потоковых данных в виде состояния…………………………………………………………………… 577
56.7. Преобразование данных с помощью посредников……………………………………………………… 578
56.8. Сбор потоковых данных………………………………………………………………………………………………… 580
56.9. Добавление буфера потока……………………………………………………………………………………………. 582
56.10. Другие терминальные операторы потока………………………………………………………………….. 583
56.11. Выравнивание потока………………………………………………………………………………………………….. 584
56.12. Объединение нескольких потоков……………………………………………………………………………….. 586
56.13. Горячие и холодные потоки………………………………………………………………………………………… 587
56.14. StateFlow………………………………………………………………………………………………………………………… 587
56.15. SharedFlow……………………………………………………………………………………………………………………… 589
56.16. Преобразование холодного потока в горячий…………………………………………………………… 591
56.17. Заключение……………………………………………………………………………………………………………………. 591
Глава 57. Руководство по SharedFlow в Compose………………………………….. 592
57.1. О проекте…………………………………………………………………………………………………………………………. 592
57.2. Создание проекта SharedFlowDemo……………………………………………………………………………… 592
57.3. Добавление модели представления в проект……………………………………………………………….. 593
57.4. Объявление SharedFlow………………………………………………………………………………………………….. 594
57.5. Сбор значений из потока……………………………………………………………………………………………….. 595
57.6. Тестирование приложения SharedFlowDemo……………………………………………………………….. 596
57.7. Обработка потоков в фоновом режиме…………………………………………………………………………. 597
57.8. Заключение……………………………………………………………………………………………………………………… 599
Глава 58. Руководство по биометрической аутентификации в Android… 600
58.1. Обзор биометрической аутентификации………………………………………………………………………. 600
58.2. Создание проекта биометрической аутентификации………………………………………………….. 600
58.3. Добавление биометрической зависимости…………………………………………………………………… 601
58.4. Настройка аутентификации по отпечаткам пальцев………………………………………………….. 601
58.5. Добавление биометрических разрешений в файл манифеста…………………………………….. 602
58.6. Проверка настроек безопасности………………………………………………………………………………….. 603
58.7. Проектирование пользовательского интерфейса………………………………………………………… 604
58.8. Настройка колбэков аутентификации………………………………………………………………………….. 605
58.9. Запуск биометрического запроса………………………………………………………………………………….. 606
58.10. Тестирование проекта………………………………………………………………………………………………….. 607
58.11. Заключение……………………………………………………………………………………………………………………. 607
Глава 59. Работа с Google Maps API в Android Studio……………………………. 608
59.1. Элементы Google Maps…………………………………………………………………………………………………… 608
59.2. Создание проекта Google Maps……………………………………………………………………………………… 609
59.3. Создание учетной записи Google Cloud………………………………………………………………………… 609
59.4. Создание нового проекта Google Cloud………………………………………………………………………… 610
59.5. Включение Google Maps SDK………………………………………………………………………………………… 611
59.6. Генерация ключа Google Maps………………………………………………………………………………………. 612
59.7. Добавление ключа API в проект……………………………………………………………………………………. 612
59.8. Добавление зависимости Compose Map………………………………………………………………………. 614
59.9. Создание карты………………………………………………………………………………………………………………. 614
59.10. Тестирование приложения…………………………………………………………………………………………… 614
59.11. Понимание геокодирования и обратного геокодирования……………………………………….. 615
59.12. Указание местоположения на карте……………………………………………………………………………. 617
59.13. Изменение типа карты………………………………………………………………………………………………….. 618
59.14. Отображение элементов управления картой для пользователя………………………………. 620
59.15. Обработка взаимодействия жестов с картой……………………………………………………………… 621
59.15.1. Жесты масштабирования………………………………………………………………………………. 621
59.15.2. Жесты прокрутки/сдвига карты……………………………………………………………………. 622
59.15.3. Жесты наклона карты……………………………………………………………………………………. 622
59.15.4. Жесты поворота карты………………………………………………………………………………….. 622
59.16. Создание маркеров карты……………………………………………………………………………………………. 622
59.17. Управление камерой карты…………………………………………………………………………………………. 624
59.18. Заключение……………………………………………………………………………………………………………………. 625
Глава 60. Создание, тестирование и загрузка пакета Android-приложений 626
60.1. Процесс подготовки к релизу…………………………………………………………………………………………. 626
60.2. Пакеты Android-приложений…………………………………………………………………………………………. 626
60.3. Регистрация аккаунта в консоли разработчика Google Play………………………………………. 627
60.4. Настройка приложения в консоли………………………………………………………………………………… 628
60.5. Включение подписи приложений в Google Play…………………………………………………………… 628
60.6. Создание файла для хранения ключей…………………………………………………………………………. 631
60.7. Создание пакета Android-приложений…………………………………………………………………………. 632
60.8. Создание тестовых APK-файлов……………………………………………………………………………………. 634
60.9. Загрузка пакета приложения в Консоль разработчика Google Play………………………….. 635
60.10. Обзор пакета приложений……………………………………………………………………………………………. 636
60.11. Управление тестерами…………………………………………………………………………………………………. 638
60.12. Развертывание приложения для тестирования………………………………………………………….. 639
60.13. Загрузка новых версий пакета приложений………………………………………………………………. 639
60.14. Анализ файла пакета приложения………………………………………………………………………………. 640
60.15. Заключение……………………………………………………………………………………………………………………. 641
Глава 61. Обзор биллинга в Android-приложениях……………………………….. 642
61.1. Подготовка проекта для покупок внутри приложения………………………………………………… 642
61.2. Создание продуктов и подписок внутри приложения…………………………………………………. 643
61.3. Инициализация BillingClient…………………………………………………………………………………………… 644
61.4. Подключение к библиотеке Google Play Billing…………………………………………………………….. 645
61.5. Запрос доступных продуктов………………………………………………………………………………………… 645
61.6. Запуск процесса покупки……………………………………………………………………………………………….. 646
61.7. Завершение покупки……………………………………………………………………………………………………….. 647
61.8. Запрос предыдущих покупок………………………………………………………………………………………… 648
61.9. Заключение……………………………………………………………………………………………………………………… 649
Глава 62. Руководство по покупкам в приложении Android…………………. 650
62.1. О проекте тестовых покупок в приложении…………………………………………………………………. 650
62.2. Создание проекта InAppPurchase………………………………………………………………………………….. 650
62.3. Добавление библиотек в проект……………………………………………………………………………………. 651
62.4. Добавление приложения в Google Play Store………………………………………………………………… 652
62.5. Создание продукта внутри приложения………………………………………………………………………. 652
62.6. Включение тестировщиков лицензий……………………………………………………………………………. 653
62.7. Создание вспомогательного класса для покупок………………………………………………………… 654
62.8. Добавление потоков StateFlow………………………………………………………………………………………. 655
62.9. Инициализация BillingClient…………………………………………………………………………………………… 655
62.10. Запрос продукта…………………………………………………………………………………………………………… 656
62.11. Обработка обновлений покупок………………………………………………………………………………….. 657
62.12. Запуск процесса покупки…………………………………………………………………………………………….. 658
62.13. Использование продукта……………………………………………………………………………………………… 659
62.14. Восстановление предыдущей покупки……………………………………………………………………….. 659
62.15. Завершение MainActivity……………………………………………………………………………………………… 660
62.16. Тестирование приложения…………………………………………………………………………………………… 662
62.17. Устранение неполадок…………………………………………………………………………………………………. 665
62.18. Заключение……………………………………………………………………………………………………………………. 665
Глава 63. Работа с темами в Compose…………………………………………………… 666
63.1. Material Design 2 и Material Design 3………………………………………………………………………………. 666
63.2. Тематизация Material Design 3……………………………………………………………………………………….. 666
63.3. Заключение……………………………………………………………………………………………………………………… 671
Глава 64. Руководство по тематическому оформлению Material Design 3 672
64.1. Создание проекта ThemeDemo……………………………………………………………………………………… 672
64.2. Проектирование пользовательского интерфейса………………………………………………………… 672
64.3. Создание новой темы……………………………………………………………………………………………………… 675
64.4. Добавление темы в проект……………………………………………………………………………………………… 676
64.5. Включение динамических цветов………………………………………………………………………………….. 676
64.6. Заключение……………………………………………………………………………………………………………………… 678
Глава 65. Обзор на Gradle в Android Studio…………………………………………… 679
65.1. Обзор Gradle…………………………………………………………………………………………………………………….. 679
65.2. Gradle и Android Studio……………………………………………………………………………………………………. 679
65.2.1. Разумные значения по умолчанию…………………………………………………………………… 680
65.2.2. Зависимости………………………………………………………………………………………………………… 680
65.2.3. Варианты сборки……………………………………………………………………………………………….. 680
65.2.4. Записи манифеста………………………………………………………………………………………………. 680
65.2.5. Подписание APK…………………………………………………………………………………………………. 681
65.2.6. Поддержка ProGuard………………………………………………………………………………………….. 681
65.3. Файл сборки Gradle со свойствами и настройками……………………………………………………… 681
65.4. Файл сборки Gradle верхнего уровня……………………………………………………………………………. 682
65.5. Файлы сборки Gradle на уровне модуля……………………………………………………………………….. 683
65.6. Настройка параметров подписи в файле сборки…………………………………………………………. 686
65.7. Запуск задач Gradle из командной строки……………………………………………………………………. 687
65.8. Заключение……………………………………………………………………………………………………………………… 687
