Android studio super что это
Полный список
— Activity LifeCycle – поведение Activity при создании, вызове, закрытии
Теория
При работе приложения, мы создаем новые Activity и закрываем старые, сворачиваем приложение, снова открываем и т.д. Activity умеет обрабатывать все эти движения. Это необходимо, например, для освобождения ресурсов или сохранения данных. В хелпе достаточно подробно это описано.
Созданное при работе приложения Activity может быть в одном из трех состояний:
Когда Activity переходит из одного состояния в другое, система вызывает различные его методы, которые мы можем заполнять своим кодом. Схематично это можно изобразить так:
Для упрощения понимания я дал краткое описание состояний в скобках под названиями. А крестом обозначил отсутствие Activity.
Итак, мы имеем следующие методы Activity, которые вызывает система:
onCreate() – вызывается при первом создании Activity
onStart() – вызывается перед тем, как Activity будет видно пользователю
onResume() – вызывается перед тем как будет доступно для активности пользователя (взаимодействие)
onPause() – вызывается перед тем, как будет показано другое Activity
onStop() – вызывается когда Activity становится не видно пользователю
onDestroy() – вызывается перед тем, как Activity будет уничтожено
Т.е. эти методы НЕ вызывают смену состояния. Наоборот, смена состояния Activity является триггером, который вызывает эти методы. Тем самым нас уведомляют о смене, и мы можем реагировать соответственно. Посмотрим на практике, когда и в каком порядке вызываются эти методы.
Практика
В этом уроке нам надо будет эмулировать событие смены ориентации экрана. Но эмулятор с Android 2.3 делает это криво, поэтому в проекте будем использовать версию 2.2. Для этого надо создать новое AVD по версии 2.2
Создадим проект (обратите внимание, используем Android 2.2.):
Project name: P0231_OneActivityState
Build Target: Android 2.2
Application name: OneActivityState
Package name: ru.startandroid.develop.p0231oneactivitystate
Create Activity: MainActivity
Layout не меняем, нам он сейчас не важен. Открываем MainActivity.java, там как обычно код по умолчанию:
Мы видим, что реализован уже знакомый нам по схеме метод onCreate. Повторюсь, важно понимать, что этот метод НЕ создает Activity. Создание – это дело системы. Т.е. система сама создает Activity, а нам дает возможность немного поучаствовать и выполнить свой код в методе onCreate(). Мы этой возможностью пользуемся и говорим системе, что Activity должна отобразить экран из R.layout.main.
Добавим все остальные методы из схемы, и в каждый добавим запись в лог.
В каментах подсказали важное замечание! При реализации этих методов обязательно вызывайте соответствующие методы супер-класса и обязательно перед вашим кодом. См. код выше. Каждый метод содержит вызов метода супер-класса и свой код расположен после этих вызовов.
Теперь, когда методы будут вызываться, мы будем видеть это в логах. Настроим фильтр на тег «States», чтобы не искать свои сообщения в общей куче логов. Как это делается мы проходили в уроке 12
Все сохраним и запустим приложение. После того, как запустилось, смотрим лог:
MainActivity: onCreate()
MainActivity: onStart()
MainActivity: onResume()
Теперь нажмем кнопку Back на эмуляторе. Activity закрылось. Смотрим лог:
MainActivity: onPause()
MainActivity: onStop()
MainActivity: onDestroy()
Activity проделывает путь, обратный созданию. Сначала теряет фокус (onPause), затем исчезает с экрана (onStop), затем полностью уничтожается (onDestroy).
Смена ориентации экрана
Посмотрим, как ведет себя Activity, когда происходит смена ориентации экрана. Запустите снова приложение (либо найдите его в списке приложений в системе на эмуляторе, либо снова нажмите CTRL+F11 в Eclipse ). В логах снова отобразились три метода, вызванные при создании. Теперь в эмуляторе нажмите CTRL+F12, ориентация сменилась. Кажется, что ничего особенного не произошло, но смотрим логи и видим:
MainActivity: onPause()
MainActivity: onStop()
MainActivity: onDestroy()
MainActivity: onCreate()
MainActivity: onStart()
MainActivity: onResume()
Activity полностью уничтожается и снова создается. При этом обычно выполняются процедуры сохранения и восстановления данных, чтобы не потерялись данные, и приложение сохранило свой вид. Про то, как это делается, мы будем говорить в последующих уроках.
Также есть еще метод onRestart. Он вызывается перед методом onStart, если Activity не создается с нуля, а восстанавливается из состояния Stoped. Его мы рассмотрим в следующем уроке.
Обычно в учебниках эта тема дается по-другому. Но мне это шаблонное объяснение кажется недостаточно понятным, поэтому я написал свое. Как всегда, надеюсь, что у меня получилось раскрыть тему )
Советую вам после этого урока прочитать хелп, ссылку на который я дал в самом начале урока. Там все очень хорошо написано. И знания лучше усвоятся. Пока что, главное – это понять в какой момент, какой метод вызывается. А уже дальше мы будем разбираться, как это можно использовать и что там кодить.
На следующем уроке:
— изучаем смену состояния на примере двух Activity
Присоединяйтесь к нам в Telegram:
— в канале StartAndroid публикуются ссылки на новые статьи с сайта startandroid.ru и интересные материалы с хабра, medium.com и т.п.
— в чатах решаем возникающие вопросы и проблемы по различным темам: Android, Kotlin, RxJava, Dagger, Тестирование
— ну и если просто хочется поговорить с коллегами по разработке, то есть чат Флудильня
— новый чат Performance для обсуждения проблем производительности и для ваших пожеланий по содержанию курса по этой теме
Список за пять минут
Очень часто экран приложения состоит из обычного прокручиваемого списка. Например, это может быть список контактов, дни месяца, ассортимент товара, технические характеристики модели и так далее. Android позволяет создать такой список за пару минут.
В предыдущих примерах мы встречали в коде строчку public class HelloWorld extends Activity, что означало наследование от специального класса Activity или производных классов, например, AppCompatActivity. Существует ещё один специальный класс ListActivity, специально разработанный для списков.
Сейчас данный тип активности устарел, так как не слишком удобен для планшетов. Теперь предпочтительнее использовать ListFragment. Но в основе всё равно лежит компонент ListView и базовые приёмы работы не изменились. Изучив данный пример, вы без труда разберётесь и с другими формами отображения списков.
Шаг первый
Создадим новый стандартный проект. Мы знаем, что в проекте есть файл activity_main.xml, отвечающий за разметку элементов на экране. Класс ListActivity разработан таким образом, что на экране есть только прокручиваемый список и ему не нужна дополнительная разметка. Поэтому набираемся смелости, выбираем в папке res/layout файл activity_main.xml и удаляем его.
Шаг второй
Всё пропало! Теперь ничего не запустится! Don’t panic! Открываем java-файл и видим, что студия ругается на строчку setContentView(R.layout.activity_main);, что вполне объяснимо. Мы ведь только что сами удалили файл разметки. Ещё раз набираемся смелости и удаляем эту строчку, она там тоже больше не нужна.
Шаг третий
Теперь нужно поставить Android в известность, что мы собираемся использовать экран со списком, поэтому меняем в строчке public class ВашеНазваниеActivity extends AppCompatActivity слово AppCompatActivity (или Activity) на ListActivity. Если набирать вручную, то студия автоматически импортирует нужный класс.
В результате в секции import нашего файла появится новая строка. Там же мы увидим строку, которую можно безболезненно удалить:
Шаг четвёртый
Подготовительные работы закончены. Теперь пришло время подготовить данные для списка, чтобы отобразить их на экране. Создадим массив строк:
К слову сказать, вы можете создать массив строк в ресурсах, в этом случае вам будет проще редактировать список, не затрагивая код программы. Когда наберётесь опыта, то сами решите, какой вариант лучше.
Шаг пятый
А теперь начинается самое важное. У нас есть намерение создать экран со списком и сами слова для списка. Необходим некий посредник, который свяжет эти звенья в одно целое. Для подобных целей в Android существует понятие адаптера данных и его определение для работы с массивами строк выглядит так:
Мы можем ему предложить ListActivity в качестве текущего контекста (можно использовать ключевое слово this), готовый системный идентификатор ресурса и созданный массив строк. А выглядеть это будет так:
Обратите внимание на строчку android.R.layout.simple_list_item_1. В ней уже содержится необходимая разметка для отдельного элемента списка, которая состоит из одного компонента TextView. Если вас не устраивает системная разметка, то можете создать собственную разметку в xml-файле и подключить её. Об этом в следующий раз.
Шаг шестой
Запускаем проект и любуемся своим списком. Он прекрасно прокручивается и каждый пункт подсвечивается при нажатии.
Обработка нажатий
У метода четыре параметра. Самым интересным является третий параметр position, который указывает на номер выбранного пункта списка.
Отсчёт позиций идёт с нуля, поэтому я прибавляю единицу к номеру позиции, чтобы получить информацию в привычном виде.
Замурчательно. Но хочется узнать не номер выбранного пункта, а сам текст. У списка ListView есть специальный метод getItemAtPosition(position), возвращающий объект для заданной позиции. Перепишем код.
В данном случае мы используем первый параметр l, который отвечает за родительский компонент ListView. Возвращаемый объект нужно преобразовать в строку.
В тех методах, у которых нет в параметрах ссылки на ListView, мы можем получить доступ к списку через метод активности getListView().
Долгое нажатие и удаление элемента списка
Расширим возможности списка и научимся обрабатывать долгие нажатия, а также удалять некоторые элементы списка.
Для долгого нажатия существует интерфейс OnItemLongClickListener с методом onItemLongClick(), возвращающим значение. Так как мы собираемся обрабатывать долгие нажатия, то строчку return false; необходимо заменить на return true;.
Добавляем интерфейс в активность, вручную вводя текст implements OnItem, студия предложит подсказку и поможет создать нужный метод для данного интерфейса.
Подключаем к адаптеру.
Далее прописываем необходимый код для удаления выбранного пункта меню и запускаем программу. Прокручивая список, с удивлением замечаем, что среди кошачьих имён затесался какой-то сраный пёсик Бобик. Пробуем удалить его. Получилось! Теперь наш список выглядит правильно.
Метод remove() удаляет элемент из списочного массива, а метод notifyDataSetChanged() уведомляет список об изменении данных для обновления списка на экране.
На всякий случай ещё раз просмотрите список и если увидите чужеродное имя, то удалите его.
Заключение
Поначалу эта статья может показаться вам сложной. Не отчаивайтесь, возьмите её как шаблон и на первых порах просто копируйте куски кода. Позже с практикой вы лучше разберётесь в работе со списком.
В данном материале вы познакомились с простым и быстрым способом создания списка на основе системных настроек. Но, если вам нужны более навороченные списки, то изучите статью про элемент управления ListView, а также статью Списки со значками.
Исходный код
Своя разметка
Можно заново создать файл activity_main.xml, если вы его удалили, как вас просили, или файл с другим именем, например, activity_customlist.xml:
Я специально установил зелёный цвет для фона, чтобы вы поверили, что будет запускаться наш шаблон вместо системного, а TextView с системным идентификатором android:id/empty нужен для отображения текста, если список будет пустым. Осталось добавить строчку кода, который подключает шаблон:
Запустите проект и убедитесь, что загружается наш шаблон. Если вы зададите пустой массив, то вместо списка вы увидите TextView с текстом List is Empty.
Ещё раз напомню, что в стандартных списках отдельный его элемент представляет собой компонент TextView. Если вы хотите создать более сложную разметку с картинками, то вам надо изучить поближе ListView. Для этого на сайте есть отдельный раздел.
Переключаемся между двумя списками
Мы создали два адаптера через массивы строк. Сначала используем первый адаптер. При выборе элемента списка через метод onListItemClick() подключаем другой адаптер. Чтобы изменения отразились на экране, необходимо вызвать метод notifyDataSetChanged().
Автоматизация Android. Супер простое руководство по созданию первого Espresso-теста
Здравствуйте, друзья. В преддверии старта курса «Mobile QA Engineer», хотим поделиться с вами переводом интересного материала.
Что такое Espresso?
Нет, это не напиток, который вы пьете каждый день, чтобы взбодриться. Espresso — это тестовый фреймворк с открытым исходным кодом, разработанный Google. Он позволяет выполнять сложные тесты пользовательского интерфейса на реальном устройстве или эмуляторе. Потребуется ли время, чтобы начать писать сложные тесты для Android?
Возможно. Но ничего не мешает вам сделать первый шаг и научиться писать простые тест-кейсы для Android с помощью фреймворка Espresso прямо сейчас.
Расскажите поподробнее об автоматизации?
Конечно. Автоматизация — это способ ускорить выполнение тестов, сделать их более эффективным и масштабируемым. Ручное тестирование очень важно, но наличие автоматических тестов — гораздо лучший вариант в перспективе.
Существует в основном два типа тестовых фреймворков:
Основные компоненты Espresso
Есть три типа методов, доступных в Espresso:
Создание простого приложения для автоматизации
Первое, что нам нужно сделать, — это создать приложение, которое мы будем автоматизировать. Давайте создадим проект в Android Studio. Для этого, конечно, необходимо, чтобы Android Studio был установлен у вас на компьютере.
1. Откройте Android Studio и создайте Bottom Navigation Activity.
Android Studio. Окно «Create New Project»
2. Назовите проект и выберите язык программирования.
Android Studio. Указание имени проекта
3. Перейдите в папку androidTest
Android Studio. Инструментальный тест.
Как вы можете видеть, там написан только один тест, и это не UI-тест, а JUnit-тест.
Сейчас нам нужно добавить простой тест пользовательского интерфейса. Для этого сначала создадим правило для открытия MainActivity.
Давайте добавим импорт аннотации JUnit Rule:
Следующее, что нужно сделать, — это добавить строку кода, указанную ниже, в дополнение к аннотации RunWith:
Теперь мы видим, что ActivityTestRule выделен красным. Это означает, что нам необходимо импортировать функцию ActivityTestRule. Но прежде нам нужно добавить библиотеку, способную сделать это. В двух словах, для этой задачи нам нужна помощь Gradle — системы автоматизации сборки, созданной специально для этой цели.
Давайте перейдем к файлу конфигурации Gradle и добавим эту библиотеку. Откройте файл с именем build.gradle (Module: app) и добавьте строку, указанную ниже:
Android Studio. Добавление зависимости.
После добавления, нужно нажать кнопку для синхронизации проекта и затем вернуться к файлу с реализацией теста.
Теперь, когда библиотека добавлена, следующим шагом будет ее импортирование в файле с инструментальным тестом:
Android Studio. Импорт ActivityTestRule.
Хорошо, теперь мы готовы добавить наш первый тест. Введите этот код в ExampleInstrumentedTest:
Android Studio. Добавление теста и импортирование дополнительных элементов
Для нашего теста требуется импортировать дополнительные элементы, прежде чем он начнет работать. Нажмите кнопку «ОК», и мы, собственно, готовы к запуску нашего теста!
Запуск Espresso-тестов
Щелкните правой кнопкой мыши на нашем тесте слева и выберите «Run ExampleInstrumentedTest».
Поскольку это UI-тест, а не модульный тест, дальше мы увидим окно с выбором устройства, на котором мы хотели бы запустить его. У меня уже есть «Nexus 5X» в качестве устройства, поэтому мне нужно просто выбрать его.
В вашем случае, если вы никогда не развертывали Android-проект, выберите ваше реальное Android-устройство или нажмите «Create New Virtual Device» и создайте новое эмулируемое устройство для запуска тестов. Это может быть любое устройство из списка, на котором бы вы хотели запустить тесты.
Нажмите «ОК» и приготовьтесь увидеть магию!
Android Studio. Результаты выполнения теста
Как вы можете видеть, у нас есть набор из двух пройденных тестов: модульного теста, который уже был там, после создания проекта, и нашего теста «clickHomeButton», который мы только что написали.
Android Studio. Выполненный тест.
Как видно из названия, мы нажали только одну кнопку в нижней панели навигации, которая называется «navigation_home» в иерархии MainActivity.
Давайте проанализируем что мы делали в этой цепочке методов:
Иерархия представлений в Android
Уважаемый читатель, я надеюсь, что смог объяснить вам, как писать базовые UI-тесты для Android с помощью Espresso.
Однако, вероятно, не так просто понять, что именно здесь произошло, если не знать, где все эти кнопки расположены и откуда они берутся. Для того, чтобы это узнать, нам нужно перейти в папку «res» с левой стороны, открыть папку «menu» и выбрать «bottom_nav_menu.xml».
Вот что мы увидим там:
Android Studio. Иерархия представления нижнего меню навигации.
Как видите, это строка, которая присваивает имя элементу меню:
Именно это мы используем в нашем коде для запуска тестов. Также есть кнопки меню “navigation_dashboard” и “navigation_notifications”, доступные внизу, так что давайте продолжим и используем их в наших тестах.
Еще больше Espresso-тестов
Нам нужно вернуться к файлу ExampleInstrumentedTest и добавить туда еще пару тестовых функций:
Единственное, что мы добавили, — это проверка еще нескольких элементов меню: “navigation_dashboard” и “navigation_notifications”.
Android Studio. Добавляем еще два теста.
Конечно, эти тесты можно было бы еще больше упростить, но для того, чтобы показать, как все это работает, допустим, что они прекрасно подходят для наших целей.
Давайте продолжим и запустим эти тесты еще раз. Нажмите кнопку «Run».
Android Studio. Результаты выполнения тестов.
Все 4 теста пройдены. Все представления были найдены, нажаты и подтверждены в иерархии представлений.
Заключение
Espresso — это мощное решение для запуска UI-тестов. Теперь, когда вы знаете, как они создаются, вы готовы писать намного более мощные и сложные тесты.
Сервисы Android: начало работы
Сервисы Android: начало работы
Многие приложения Android имеют функции, выполнение которых требует много времени, например загрузка какого-либо контента или обновление удаленной базы данных. Если разработчики не организуют работу подобных функций должным образом, они постепенно загромоздят основной поток, создав утечки памяти и неточности в работе. Это может сильно раздражать ваших пользователей.
Давайте начнем
В игре четыре уровня сложности: Beginner (Начальный), Intermediate (Средний), Advanced (Продвинутый ) и Expert (Эксперт). Чем выше уровень сложности, тем больше карт нужно сопоставить. После того, как пользователь выполняет задание на уровень эксперт, он проходит игру. Не хотите попробовать? :]
В настоящее время приложение позволяет пользователю только запускать игру и управлять саундтреками. Запустив игру, вы сможете выйти из нее, просмотреть игровые карточки и засечь время, прошедшее с момента запуска игры.
Откройте проект в Android Studio и ознакомьтесь с файлами. Когда вы закончите, запустите проект на устройстве / эмуляторе, чтобы посмотреть, как он выглядит.
Вы можете поиграть в игру, нажав на кнопку PLAY BEGINNER LEVEL. Сейчас вы уже можете сопоставлять карточки, однако отсутствует таймер, отображающий количество времени, затраченное на решение задачи. Это первое, что мы реализуем в этом туториале.
Однако сначала давайте более подробно рассмотрим, что такое Android Services и как их использовать.
Представляем Android Services
Ресурсоемкие задачи данный сервис будет выполнять в фоновом режиме. Это позволит пользователю взаимодействовать с приложением. Например, если пользователь захочет позвонить или просмотреть уведомления при обновлении сервера, он сможет сделать это, не прерывая и не отменяя обновления.
Для этого нужно создать фоновый поток и вручную указать, какие задачи должны выполняться именно в этом потоке, поскольку сервисы не поддерживают реализацию потока напрямую.
Поскольку Android Services не имеет пользовательского интерфейса, он никак не зависит от последовательности выполнения других процессов. Это означает, что вы можете запускать его, даже когда пользователь вообще никак не взаимодействует с приложением.
Кроме того, другие компоненты приложения могут взаимодействовать с сервисами или даже осуществлять межпроцессное взаимодействие (InterProcess Communication (IPC)). Если вы будете дальше следовать этому туториалу, то узнаете больше о IPC.
В следующих разделах этого туториала мы применим каждый из перечисленных ниже типов Android Services и добавим в наше приложение Memo много новых функций:
Объявление сервиса в Manifest
Перейдите к AndroidManifest.xml и добавьте этот код внутрь application :
В этом кода вы можете увидеть следующее:
Значение android:name выделиться красным цветом, но пока просто не обращайте на это внимание. Мы починим это чуть позже.
А пока начнем работу по реализации нового функционала.
Реализация интерфейса сервиса
Каждый кастомный класс сервиса должен быть подклассом Service и должен реализовывать и переопределять несколько базовых методов колбэка, связанных с жизненным циклом сервиса.
Вот наиболее важные из них:
Создание сервиса Foreground
Сервис Foreground выполняет задачи, которые необходимо видеть пользователю. Он выводит уведомления в строку состояния, чтобы сообщить пользователю о том, что приложение выполняет операцию и потребляет ресурсы. Уведомление должно иметь приоритет PRIORITY_LOW или выше и быть видимым, даже если пользователь не взаимодействует с приложением.
Пользователь не может закрыть уведомление. Оно исчезает, когда служба завершает свою работу или покидает передний план.
Применение методов сервиса.
Чтобы исправить это добавьте следующее в TimerService :
Давайте разберем этот код немного подробнее:
Добавление разрешений
Все приложения, созданные для Android 9 (уровень API 28) или выше, должны запрашивать разрешение на использование службы переднего плана. Система автоматически разрешит доступ к сервису. В противном случае приложение генерирует исключение SecurityException.
В Project view перейдите к app ▸ manifest ▸ AndroidManifest.xml и добавьте следующий код над тегом application :
Это позволит нашему приложению Memo использовать сервис переднего плана.
Далее давайте создадим уведомление, которое будет говорить о работе этого сервиса.
Создание канала уведомлений
Любой сервис переднего плана должен уведомлять пользователя о своем запуске. Вам также необходимо определить диспетчер уведомлений, который уведомляет пользователя о происходящих событиях и содержит информацию об одном или нескольких уведомлениях.
Откройте NotificationHelper.kt и добавьте этот код в начало класса:
В Android 8 и более поздних версиях уведомление должно быть частью канала уведомлений. Чтобы создать его, добавьте этот код в NotificationHelper.kt:
В этом кусочке кода мы:
Следующим шагом будет работа с отображением уведомлений.
Создание конструктора уведомлений
Чтобы пользователь знал о запущенном сервисе, создайте уведомление, которое пользователь сможет увидеть в строке состояния. Вверху NotificationHelper.kt добавьте:
Если вы получаете ошибку, сообщающую, contentIntent не определено, не волнуйтесь. Мы позаботимся об этом на следующих шагах.
В этом коде мы реализовали следующее:
Заметка
Многие разработчики допускают очень глупую ошибку. Они забывают присвоить уведомлению небольшой значок (иконку). Это приводит к тому, что уведомление получается невидимым.
Создание самого уведомления
Пришло время создать само уведомление. Добавьте в NotificationHelper.kt следующее:
Вот что происходит в этом куске кода:
Уведомление может обновляться динамически. В этом случае мы будем обновлять текст, если пользователь закроет приложение во время работы службы.
Ниже getNotification() добавьте следующее:
Вот, что здесь происходит:
Наконец, давайте определим, что происходит, когда пользователь нажимает на уведомление. Добавьте это в начало NotificationHelper.kt:
Прекрасная работа! Уже очень многое было реализовано. Теперь пора запустить Foreground Service.
Запуск и остановка службы
Откройте TimerService.kt и добавьте следующее в метод startTimer() :
Чтобы исправить это создайте экземпляр класса NotificationHelper в верхней части TimerService :
Чтобы попытаться запустить сервис из другого компонента, откройте MainActivity.kt, найдите sendCommandToForegroundService() и добавьте:
Здесь мы запускаем сервис из Activity. Вы передаете его Context и Intent для запуска сервиса.
Все, что начинается, должно заканчиваться, в том числе и сервисы. Откройте TimerService.kt и добавьте в stopService() следующее:
Обновление уведомления при изменении таймера
TimerService содержит сопрограмму, которая тикает каждую секунду во время выполнения уровня. Вы будете использовать значение таймера, чтобы обновить представление уведомлений.
Найдите BroadUpdate () внутри TimerService.kt и добавьте этот код в if :
Вот что делает этот блок кода:
На этом этапе мы уже сделали все, что видит пользователь во время игры. Но что произойдет, если пользователь закроет приложение во время работы таймера?
Чтобы это работало корректно, добавьте следующую строку в broadcastUpdate() в else if :
Эта строчка обновляет текст уведомления, зазывающего пользователя обратно в игру.
Отличная работа! Запустите проект, чтобы проверить таймер. Запустите игру на каком-нибудь уровне сложности и обратите внимание, как внизу меняется таймер. Потяните вниз строку состояния, чтобы увидеть, как таймер изменяется в уведомлении. Попробуйте выйти из приложения, чтобы проверить обновление текста сообщения в уведомлении.
Использование фоновой обработки для сложных задач
Иногда пользователю не нужно знать о том, что происходит какое-то действие, например, если вы сохраняете данные об активности пользователя на сервере в целях доработки своего приложения, вам не нужно, чтобы пользователь видел уведомление. Поместите такие непрерывные задачи в фоновую очередь.
Для этого вы можете использовать:
Объяснение ограничений для фонового выполнения
Android 8 и более новые версии имеют ограничения при использовании Android Services в фоновом потоке:
Дополнительные сведения см. В документации по ограничениям фонового выполнения.
Заметка
Из-за всех этих ограничений фоновые сервисы используются крайне редко. Как упоминалось выше, а также рекомендовано официальной документацией Android, лучшим решением для фоновой работы является использование Work Manager. Подробнее об этом читайте в разделе «Планирование задач с помощью Android WorkManager».
А теперь пора узнать о последнем виде сервисов.
Создание Bound Service
Жизненный цикл связанного сервиса зависит от другого компонента приложения. Когда компонент отключается, привязанный сервис уничтожает себя. Следовательно, он не может работать в фоновом режиме вечно.
Чтобы попробовать это, давайте добавим в Memo возможность воспроизводить звук.
Преобразование MusicService в реальный Service
Откройте MusicService.kt и расширьте его Service :
Как указано в его типе, другой компонент привяжется к этому сервису. Вы уже узнали об обязательном методе привязки к сервису, поэтому добавьте его в MusicService :
Разница между последним применением onBind() и этой строчкой, очевидно, заключается в возвращаемом значении. Поскольку здесь вы привязываетесь к сервису, вам необходимо указать значение IBinder.
Определение Binder
Теперь, чтобы определить интерфейс, добавьте эти строки внизу класса:
Определение методов сервисов для управления аудио
Этот сервис позволяет пользователю взаимодействовать со звуковыми иконками для воспроизведения, приостановки, остановки и перемешивания музыки. Для простоты, некоторые методы управления звуком уже определены. Однако сам музыкальный проигрыватель все еще не определен.
Чтобы создать музыкальный проигрыватель, добавьте этот код в initializeMediaPlayer() внутри MusicService.kt:
Еще одна интересная особенность такого сервиса заключается в том, что он может предоставить имя воспроизводимого трека. Внутри MusicService добавьте:
Все сделано! Теперь воспользуемся этими методами из другого компонента.
Создание колбэка для подключения к службе
Чтобы использовать MusicService внутри других классов, нам нужно создать его экземпляр. Откройте MainActivity.kt и добавьте в начало класса следующее:
Добавьте код под инициализацией musicService :
Этот блок кода не сложно понять:
Привязка к Сервису
Здесь вы проверяете, имеет ли сервис уже привязку. Если нет, вы вызываете метод привязки.
Метод привязки еще не существует, поэтому добавьте его код ниже onDestroy() :
В этом куске кода мы:
Чтобы избежать утечек памяти или ошибок, вам нужно добавить код для отмены привязки сервиса. Добавьте в unbindMusicService() следующее:
Использование методов сервисов
Как только сервис отключится, нам нужно остановить воспроизведение музыки. Добавьте следующий код над только что добавленной строкой unbindService() :
Осталось сделать еще кое- что! Как только саундтрек начнет воспроизводиться, сервис может предоставить информацию о названии песни. Перед тем, как это применить это в нашем приложении, нужно исправить момент с получением результата.
Запустите проект, затем нажмите значок «Play», чтобы запустить воспроизведение. Нажмите GET SONG NAME, чтобы увидеть название текущей песни во всплывающем сообщении. Наконец, вы можете наслаждаться музыкой во время игры!
Межпроцессные взаимодействия
Каждое приложение Android работает в собственном процессе с уникальным идентификатором процесса. Когда вы запускаете приложение, система Android генерирует процесс и выполняет основное действие в основном потоке. Плюс этого в том, что приложение живет в изолированной среде, и другие приложения не могут его прервать.
Исходя из этого, Android позволяет запускать компоненты в другом процессе, который не используется для запуска приложения. Для этого вам нужно использовать тег процесса внутри AndroidManifest.xml. У процесса может быть случайное имя, например myNewProcess.
Многопроцессорность повышает безопасность вашего приложения и улучшает управление памятью. Однако, если вы его используете, вам нужно найти способ взаимодействия между различными процессами.
Первый способ мы уже рассмотрели в этом туториале, но не стесняйтесь изучить и другие.
Что дальше?
Загрузите конечный проект, если что-то у вас не получилось.
Вы узнали много нового о сервисах Android и о том, как их по-разному использовать. Сервисы полезны для оптимизации приложений и улучшения взаимодействия с пользователем.
Android 12 внесет некоторые изменения в уведомления переднего плана. Ознакомиться с ними можно в официальной документации по Foreground Services.