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

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

• В этом туториале вы узнаете:
• Что такое Android Services и как их объявить в файле Manifest.
• Как использовать foreground сервис для отображении уведомления пользователю.
• Что такое фоновая обработка сложных процессов, не связанных с пользовательским интерфейсом.
• Как использовать bound service.

Давайте начнем

Загрузите начальный проект.

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

В игре четыре уровня сложности: Beginner (Начальный), Intermediate (Средний), Advanced (Продвинутый ) и Expert (Эксперт). Чем выше уровень сложности, тем больше карт нужно сопоставить. После того, как пользователь выполняет задание на уровень эксперт, он проходит игру. Не хотите попробовать? :]

В настоящее время приложение позволяет пользователю только запускать игру и управлять саундтреками. Запустив игру, вы сможете выйти из нее, просмотреть игровые карточки и засечь время, прошедшее с момента запуска игры.

Откройте проект в Android Studio и ознакомьтесь с файлами. Когда вы закончите, запустите проект на устройстве / эмуляторе, чтобы посмотреть, как он выглядит.

Вы можете поиграть в игру, нажав на кнопку PLAY BEGINNER LEVEL. Сейчас вы уже можете сопоставлять карточки, однако отсутствует таймер, отображающий количество времени, затраченное на решение задачи. Это первое, что мы реализуем в этом туториале.

Однако сначала давайте более подробно рассмотрим, что такое Android Services и как их использовать.

Представляем Android Services

Android Services - это компонент, который помогает выполнять длительные процессы, такие как обновление базы данных или сервера, запуск обратного отсчета или воспроизведение звука. По умолчанию Android Services запускаются в том же потоке, что и основные процессы приложения. Такой вид службы также называют local service.

Ресурсоемкие задачи данный сервис будет выполнять в фоновом режиме. Это позволит пользователю взаимодействовать с приложением. Например, если пользователь захочет позвонить или просмотреть уведомления при обновлении сервера, он сможет сделать это, не прерывая и не отменяя обновления.

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

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

Кроме того, другие компоненты приложения могут взаимодействовать с сервисами или даже осуществлять межпроцессное взаимодействие (InterProcess Communication (IPC)). Если вы будете дальше следовать этому туториалу, то узнаете больше о IPC.

В следующих разделах этого туториала мы применим каждый из перечисленных ниже типов Android Services и добавим в наше приложение Memo много новых функций:

• Foreground service: Добавим сервис TimerService, который содержит логику для отслеживания времени.
• Bound service: Используем MusicService, который позволит нам воспроизводить, ставить на паузу и перемешивать саундтреки.

Давайте начнем!

Объявление сервиса в Manifest

Перед использованием сервиса его необходимо объявить в AndroidManifest.xml. Сервис - это компонент Android, точно так же, как и Activity. Для удобства наш проект уже содержит классы сервисов, но вам все еще необходимо правильно их конфигурировать.

Перейдите к AndroidManifest.xml и добавьте этот код внутрь application:

В этом кода вы можете увидеть следующее:

• Android:name: Имя класса сервиса.
• Android:enabled: Если установлено значение true, система может создавать экземпляры сервисов.
• Android:exported: Если установлено значение False, то системе сообщается, что ни одно другое приложение не может запускать и использовать эти сервисы.

Значение android:name выделиться красным цветом, но пока просто не обращайте на это внимание. Мы починим это чуть позже.

А пока начнем работу по реализации нового функционала.

Реализация интерфейса сервиса

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

Вот наиболее важные из них:

• onStartCommand(): вызывается системой, когда другой компонент хочет запустить сервис, использую startService(). Как только система вызывает onStartCommand(), сервис может работать в фоновом режиме столько времени, сколько потребуется для завершения процесса. Вам нужно не забыть остановить службу вручную, когда работа будет завершена, вызвав stopSelf() или topService(). Эта не нужно, если вы хотите просто выполнить привязку к сервису, не запуская его.
• onBind(): Вам всегда нужно применять этот метод колбэка. Система использует этот колбэк при вызове bindService(). Используйте его для привязки другого компонента к сервису. Он открывает возможность коммуникации, таким образом вы предоставляете интерфейс для взаимодействия клиентов возвращая IBinder. Если вы не хотите использовать привязку, просто верните null.
• onCreate(): Используйте этот метод для настройки сервиса перед его запуском. Система вызывает его, только если сервис еще не запущен.
• onDestroy(): Система вызывает его, чтобы уничтожить сервис, когда он больше не нужен. Это последний вызов, который получает сервис. После этого сервис перестает использовать какие-либо ресурсы.

Создание сервиса Foreground

Сервис Foreground выполняет задачи, которые необходимо видеть пользователю. Он выводит уведомления в строку состояния, чтобы сообщить пользователю о том, что приложение выполняет операцию и потребляет ресурсы. Уведомление должно иметь приоритет PRIORITY_LOW или выше и быть видимым, даже если пользователь не взаимодействует с приложением.

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

Чтобы увидеть работу данного сервиса в действии давайте реализуем TimerService. Откройте TimerService.kt и добавьте следующее, чтобы сделать его подклассом Service:

class TimerService : Service(), CoroutineScope {

В этой строчке мы применяем интерфейс Service и CoroutineScope.

Применение методов сервиса.

Присмотритесь и обратите внимание, что Android Studio выдает ошибку из-за того, что не может найти onBind().

Чтобы исправить это добавьте следующее в TimerService:

 // 1
 override fun onBind(intent: Intent): IBinder? = null

 override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
   super.onStartCommand(intent, flags, startId)
   // 2
   intent?.extras?.run {
     when (getSerializable(SERVICE_COMMAND) as TimerState) {
       TimerState.START -> startTimer()
       TimerState.PAUSE -> pauseTimerService()
       TimerState.STOP -> endTimerService()
       else -> return START_NOT_STICKY
     }
   }
   // 3
   return START_NOT_STICKY
 }

 override fun onDestroy() {
   super.onDestroy()
   // 4
   handler.removeCallbacks(runnable)
   job.cancel()
 }

Давайте разберем этот код немного подробнее:

1. Так как мы используем сервис переднего плана, нам не нужно выполнять привязку и мы возвращаем null вместо IBinder. Также заметьте, что мы не используем onCreate(), так как нам не нужна никакая специфическая конфигурация для этого сервиса.
2. Здесь мы просматриваем дополнительные возможности Intent, чтобы получить значение, которое содержит ключ SERVICE_COMMAND. Это значение указывает на то, какое действие должен выполнить сервис.
3. Если система завершает работу сервиса из-за нехватки памяти, START_NOT_STICKY говорит системе о том, что не стоит создавать службу с неопределенным Intent. Альтернативные константы: START_STICKY и START_REDELIVER_INTENT. Если вас интересует функционал этих констант, ознакомьтесь с официальной документацией по константам сервисов.
4. Временно удалите все колбэки Handler, чтобы не засорять память. Кроме того, стоит очистить ресурсы, отменив все Job таймера, поскольку на следующем шаге сервис будет уже уничтожен.

Добавление разрешений

Все приложения, созданные для Android 9 (уровень API 28) или выше, должны запрашивать разрешение на использование службы переднего плана. Система автоматически разрешит доступ к сервису. В противном случае приложение генерирует исключение SecurityException.

В Project view перейдите к app ▸ manifest ▸ AndroidManifest.xml и добавьте следующий код над тегом application :

Это позволит нашему приложению Memo использовать сервис переднего плана.

Далее давайте создадим уведомление, которое будет говорить о работе этого сервиса.

Создание канала уведомлений

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

Откройте NotificationHelper.kt и добавьте этот код в начало класса:

private val notificationManager by lazy {
  context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
}

Здесь вам не нужно инициализировать notificationManager, получив системную службу NOTIFICATION_SERVICE и преобразовав ее в NotificationManager.

В Android 8 и более поздних версиях уведомление должно быть частью канала уведомлений. Чтобы создать его, добавьте этот код в NotificationHelper.kt:

@RequiresApi(Build.VERSION_CODES.O)
private fun createChannel() =
    // 1
    NotificationChannel(
      CHANNEL_ID,
      CHANNEL_NAME,
      NotificationManager.IMPORTANCE_DEFAULT
    ).apply {

      // 2
      description = CHANNEL_DESCRIPTION
      setSound(null, null)
    }

В этом кусочке кода мы:

1. Создаем канал уведомлений с CHANNEL_ID в качестве идентификатора, CHANNEL_NAME в качестве имени и дефолтным приоритетом по умолчанию.
2. Устанавливаем значение CHANNEL_DESCRIPTION для описания канала уведомлений, а для звука - значение null, что означает, что при срабатывании уведомления в канале звук не будет воспроизводиться.

Следующим шагом будет работа с отображением уведомлений.

Создание конструктора уведомлений

Чтобы пользователь знал о запущенном сервисе, создайте уведомление, которое пользователь сможет увидеть в строке состояния. Вверху NotificationHelper.kt добавьте:

  // 1
  private val notificationBuilder: NotificationCompat.Builder by lazy {
    NotificationCompat.Builder(context, CHANNEL_ID)
       // 2
      .setContentTitle(context.getString(R.string.app_name))
      .setSound(null)
      .setContentIntent(contentIntent)
      .setSmallIcon(R.drawable.ic_launcher_foreground)
      .setPriority(NotificationCompat.PRIORITY_HIGH)
      // 3
      .setAutoCancel(true)
  }

Если вы получаете ошибку, сообщающую, contentIntent не определено, не волнуйтесь. Мы позаботимся об этом на следующих шагах.

В этом коде мы реализовали следующее:

1. Мы использовали NotificationCompat.Builder для того, чтобы создать конструктор уведомлений, отображаемых в строке состояния.
2. Конструктор должен содержать информацию о некоторых параметрах уведомления. Однако вам не нужно определять эти параметры при объявлении конструктора. Если не будет хватать какой-либо информации, мы всегда сможем указать эту информацию в самом уведомлении.
3. Этот тип уведомления должен быть настроен как автоматически отменяемый. Это означает, что когда пользователь нажмет на уведомление, оно автоматически закроется.

Заметка

Многие разработчики допускают очень глупую ошибку. Они забывают присвоить уведомлению небольшой значок (иконку). Это приводит к тому, что уведомление получается невидимым.

Создание самого уведомления

Пришло время создать само уведомление. Добавьте в NotificationHelper.kt следующее:

 fun getNotification(): Notification {
    // 1
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
      notificationManager.createNotificationChannel(createChannel())
    }

    // 2
    return notificationBuilder.build()
  }

Вот что происходит в этом куске кода:

1. Если версия Android равна 8 или выше, система создает канал уведомления и возвращает Notification. К сожалению, библиотека поддержки для версий до Android 8 не предоставляет API каналов уведомлений. Подробнее об этой проблеме читайте в официальной документации на тему каналов уведомлений.
2. Возвращается Notification после вызова build() в конструкторе.

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

Ниже getNotification() добавьте следующее:

fun updateNotification(notificationText: String? = null) {
    // 1
    notificationText?.let { notificationBuilder.setContentText(it) }
    // 2
    notificationManager.notify(NOTIFICATION_ID, notificationBuilder.build())
}

Вот, что здесь происходит:

1. Мы обновляем текст в уведомлении, отображаемом в строке состояния, через notificationBuilder.
2. Затем говорим диспетчер уведомлений какое уведомление нужно обновить. Для этого мы используем уникальный NOTIFICATION_ID.

Наконец, давайте определим, что происходит, когда пользователь нажимает на уведомление. Добавьте это в начало NotificationHelper.kt:

 private val contentIntent by lazy {
    PendingIntent.getActivity(
      context,
      0,
      Intent(context, MainActivity::class.java),
      PendingIntent.FLAG_UPDATE_CURRENT
    )
  }

Здесь вы выполняете ленивую инициализацию PendingIntent, которая запускает MainActivity, когда пользователь нажимает на уведомление.

Прекрасная работа! Уже очень многое было реализовано. Теперь пора запустить Foreground Service.

Запуск и остановка службы

Чтобы запустить Foreground Service, используйте startForeground(). Для этого метода требуются два параметра: уникальный положительный целочисленный идентификатор уведомления и Notificaton.

Откройте TimerService.kt и добавьте следующее в метод startTimer():

startForeground(NotificationHelper.NOTIFICATION_ID, helper.getNotification())

Этот метод заставляет службу работать на переднем плане и отправляет уведомление с идентификатором NOTIFICATION_ID в строку состояния. Вы заметите, что helper выделен красным, потому что вы еще не определили переменную helper.

Чтобы исправить это создайте экземпляр класса NotificationHelper в верхней части TimerService:

private val helper by lazy { NotificationHelper(this) }

Чтобы попытаться запустить сервис из другого компонента, откройте MainActivity.kt, найдите sendCommandToForegroundService() и добавьте:

ContextCompat.startForegroundService(this, getServiceIntent(timerState))

Здесь мы запускаем сервис из Activity. Вы передаете его Context и Intent для запуска сервиса.

Все, что начинается, должно заканчиваться, в том числе и сервисы. Откройте TimerService.kt и добавьте в stopService() следующее:

// 1
stopForeground(true)

// 2
stopSelf()

В этом блоке кода:

1. Этот вызов сообщает системе, что она должна убрать этот сервис из foreground. Переданный логический аргумент соответствует удалению уведомления, если для него установлено значение true.
2. Поскольку сервис может запускаться сам, он также должен и завершаться сам. stopSelf() позволяет это реализовать.

Обновление уведомления при изменении таймера

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

Найдите BroadUpdate () внутри TimerService.kt и добавьте этот код в if:

// 1
sendBroadcast(
  Intent(TIMER_ACTION)
    .putExtra(NOTIFICATION_TEXT, elapsedTime)
)

// 2
helper.updateNotification(
  getString(R.string.time_is_running, elapsedTime.secondsToTime())
)

Вот что делает этот блок кода:

1. Здесь вы отправляете трансляцию с истекшим временем в MainActivity. С его помощью MainActivity может обновлять время в TextView.
2. Этот вспомогательный метод обновляет уведомление в строке состояния, которое мы сделали ранее.

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

Чтобы это работало корректно, добавьте следующую строку в broadcastUpdate() в else if:

helper.updateNotification(getString(R.string.get_back))

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

Отличная работа! Запустите проект, чтобы проверить таймер. Запустите игру на каком-нибудь уровне сложности и обратите внимание, как внизу меняется таймер. Потяните вниз строку состояния, чтобы увидеть, как таймер изменяется в уведомлении. Попробуйте выйти из приложения, чтобы проверить обновление текста сообщения в уведомлении.

Использование фоновой обработки для сложных задач

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

Для этого вы можете использовать:

1. Пользовательский Background Service - по умолчанию сервис запускается в потоке пользовательского интерфейса. Чтобы избежать блокировки, создайте Сервис с обработкой процесса в фоновом потоке.
2. IntentService - подкласс сервиса, который последовательно выполняет запросы с помощью рабочего потока. Начиная с Android 8, использовать его не рекомендуется. Кроме того, IntentService устарел с Android 11.
3. JobIntentService - замена IntentService. Вместо сервиса он использует JobScheduler для выполнения заданий. В более ранних версиях, чем Android 8, он будет действовать так же, как IntentService. Для получения дополнительной информации прочтите официальную документацию JobIntentService.
4. Фоновая работа с WorkManager - это общая концепция фоновой работы в Android. Используйте его, когда вы захотите выполнять периодические процессы в будущем или когда у вас есть некоторые ограничения в работе приложения.

Объяснение ограничений для фонового выполнения

Android 8 и более новые версии имеют ограничения при использовании Android Services в фоновом потоке:

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

Дополнительные сведения см. В документации по ограничениям фонового выполнения.

Заметка

Из-за всех этих ограничений фоновые сервисы используются крайне редко. Как упоминалось выше, а также рекомендовано официальной документацией Android, лучшим решением для фоновой работы является использование Work Manager. Подробнее об этом читайте в разделе «Планирование задач с помощью Android WorkManager».

А теперь пора узнать о последнем виде сервисов.

Создание Bound Service

Bound Service - это все еще применение Service. Это компонент, с которым связываются другие компоненты, взаимодействуют с ним и осуществляют межпроцессное взаимодействие (IPC). Связанный компонент может быть Activity, другим сервисом, приемником трансляции или поставщиком контента.

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

Однако ему не обязательно нужен связанный компонент - он также может запускаться и останавливаться. В этом случае есть возможность работать бесконечно.

Чтобы попробовать это, давайте добавим в Memo возможность воспроизводить звук.

Преобразование MusicService в реальный Service

Для реализации функции воспроизведения звука, давайте воспользуемся MusicService. Во-первых, измените его, чтобы получить доступ к основным методам сервиса.

Откройте MusicService.kt и расширьте его Service:

class MusicService : Service() {

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

override fun onBind(intent: Intent?): IBinder = binder

Разница между последним применением onBind() и этой строчкой, очевидно, заключается в возвращаемом значении. Поскольку здесь вы привязываетесь к сервису, вам необходимо указать значение IBinder.

IBinder - это программный интерфейс Binder, который клиент использует для взаимодействия с сервисом. Его методы позволяют отправлять вызов объекту IBinder и получать вызов, поступающий в объект Binder. Чтобы узнать больше, ознакомьтесь с документацией IBinder.

Сейчас Android Studio выдает ошибку, потому что мы не определили переменную binder. Чтобы исправить это, добавьте в начало класса следующее:

private val binder by lazy { MusicBinder() }

Здесь мы выполняем отложенную инициализацию binder, который является разновидностью MusicBinder. Внедрение MusicBinder - ваш следующий шаг.

Определение Binder

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

Теперь, чтобы определить интерфейс, добавьте эти строки внизу класса:

inner class MusicBinder : Binder() {

  fun getService(): MusicService = this@MusicService
}

MusicBinder вложен в другой класс и может получить доступ ко всем его методам. Он также может использовать все методы Binder. Внутри него вы создаете метод для получения контекста сервиса.

Определение методов сервисов для управления аудио

Этот сервис позволяет пользователю взаимодействовать со звуковыми иконками для воспроизведения, приостановки, остановки и перемешивания музыки. Для простоты, некоторые методы управления звуком уже определены. Однако сам музыкальный проигрыватель все еще не определен.

Чтобы создать музыкальный проигрыватель, добавьте этот код в initializeMediaPlayer() внутри MusicService.kt:

 musicMediaPlayer = MediaPlayer.create(this, randomSongs.first()).apply {
    isLooping = true
  }

Здесь вы используете MediaPlayer для запуска непрерывно повторяющегося звука первой песни в randomSongs.

Еще одна интересная особенность такого сервиса заключается в том, что он может предоставить имя воспроизводимого трека. Внутри MusicService добавьте:

fun getNameOfSong(): String =
    resources.getResourceEntryName(randomSongs.first())
        .replaceFirstChar { 
             if (it.isLowerCase()) it.titlecase(Locale.ENGLISH) 
             else it.toString() 
        }.replace("_", " ")

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

Все сделано! Теперь воспользуемся этими методами из другого компонента.

Создание колбэка для подключения к службе

Чтобы использовать MusicService внутри других классов, нам нужно создать его экземпляр. Откройте MainActivity.kt и добавьте в начало класса следующее:

private var musicService: MusicService? = null

Здесь мы объявляем переменную, которая содержит экземпляр сервиса. В данный момент сервис является null. Мы назначим новое значение, когда активити подключится к службе с помощью интерфейса Binder. Чтобы уловить изменения состояния соединения, создайте колбэк соединения.

Добавьте код под инициализацией musicService:

// 1
private val boundServiceConnection = object : ServiceConnection {

  // 2
  override fun onServiceConnected(className: ComponentName, service: IBinder) {
    val binder: MusicService.MusicBinder = service as MusicService.MusicBinder
    musicService = binder.getService()
    mainViewModel.isMusicServiceBound = true
  }

  // 3
  override fun onServiceDisconnected(arg0: ComponentName) {
    musicService?.runAction(MusicState.STOP)
    musicService = null
    mainViewModel.isMusicServiceBound = false
  }
}

Этот блок кода не сложно понять:

1. Это колбэк для состояния подключения сервиса.
2. Когда активити подключается к сервису, система использует экземпляр MusicBinder и getService() чтобы передать ссылку в musicService.
3. Когда сервис отключается, воспроизведение звука прекратится, если ссылка на сервис еще не приняла значение null, при этом ссылка на сервис будет удалена.

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

Привязка к Сервису

Следующим шагом мы создадим привязку сервиса при запуске MainActivity. Найдите onStart() и добавьте:

if (!mainViewModel.isMusicServiceBound) bindToMusicService()

Здесь вы проверяете, имеет ли сервис уже привязку. Если нет, вы вызываете метод привязки.

Метод привязки еще не существует, поэтому добавьте его код ниже onDestroy():

private fun bindToMusicService() {
  // 1
  Intent(this, MusicService::class.java).also {
    // 2
    bindService(it, boundServiceConnection, Context.BIND_AUTO_CREATE)
  }
}

В этом куске кода мы:

1. Заявляем о намерении запустить MusicService
2. Предоставляем сервису информацию о нашем Intent вместе с колбэком соединения и флагом, который автоматически создает сервис, если привязка существует.

Чтобы избежать утечек памяти или ошибок, вам нужно добавить код для отмены привязки сервиса. Добавьте в unbindMusicService() следующее:

unbindService(boundServiceConnection)

Таким образом, вы говорите сервису выполнить onServiceDisconnected() в колбеке boundServiceConnection.

Использование методов сервисов

Как только сервис отключится, нам нужно остановить воспроизведение музыки. Добавьте следующий код над только что добавленной строкой unbindService():

musicService?.runAction(MusicState.STOP)

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

Чтобы запустить звук, используем sendCommandToBoundService(). Теперь создадим общий вызов к изменению действия, чтобы уменьшить количество строк кода. Добавьте эту строку в sendCommandToBoundService():

musicService?.runAction(state)

Таким образом, вы задаете сервису действие, которое он выполняет в соответствии с параметром sendCommandToBoundService().

Осталось сделать еще кое- что! Как только саундтрек начнет воспроизводиться, сервис может предоставить информацию о названии песни. Перед тем, как это применить это в нашем приложении, нужно исправить момент с получением результата.

Внутри getNameOfSong(), замените строку, возвращающую текст «Unknown», на:

musicService?.getNameOfSong() ?: getString(R.string.unknown)

Здесь мы вызываем метод сервиса, который проверяет, какая звуковая дорожка в настоящее время воспроизводится, и возвращает необязательный результат String. Если результат равен null, вместо информации, полученной от сервиса, мы используем текст, взятый из ресурсов.

Запустите проект, затем нажмите значок «Play», чтобы запустить воспроизведение. Нажмите GET SONG NAME, чтобы увидеть название текущей песни во всплывающем сообщении. Наконец, вы можете наслаждаться музыкой во время игры!

Межпроцессные взаимодействия

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

Исходя из этого, Android позволяет запускать компоненты в другом процессе, который не используется для запуска приложения. Для этого вам нужно использовать тег процесса внутри AndroidManifest.xml. У процесса может быть случайное имя, например myNewProcess.

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

Вам нужно включить только один программный интерфейс - IBinder, но Android предоставляет три способа его определения:

• Расширение подшивки
• Использование мессенджера
• Использование AIDL 

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

Что дальше?

Загрузите конечный проект, если что-то у вас не получилось.

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

Android 12 внесет некоторые изменения в уведомления переднего плана. Ознакомиться с ними можно в официальной документации по Foreground Services.

Оригинал статьи