Xiaomi Service Framework — что это за приложение и как его отключить

Фото: pixabay.com

Ваш новенький Xiaomi быстро разряжается без видимых причин? Всё потому, что некоторые приложения могут работать в фоновом режиме, потребляя не только энергию, но и трафик. Одна из таких программ — Xiaomi Service Framework. Возможно, вы видели это приложение на своем телефоне, но точно никогда сами не скачивали его. Для чего оно вообще нужно и можно ли его удалить без последствий для смартфона, Xiaomi держит почти что в тайне от пользователей. Но мы сейчас разберемся.

Почему Xiaomi Service Framework «жрет» трафик и батарею вашего смартфона

Приложение Xiaomi Service Framework создано для синхронизации и доставки оповещений от гаджетов, «привязанных» к телефону, например от смарт-часов. Это системное приложение, и оно постоянно поддерживает связь с облаком Mi Cloud, в результате чего даже в фоновом режиме потребляет интернет-трафик и расходует заряд аккумулятора.

Узнать, сколько реально трафика тратит программа, очень просто:

1. Перейдите в «Настройки» смартфона в раздел «Все приложения».

2. Найдите в списке Xiaomi Service Framework и нажмите на него.

3. Посмотрите в открывшейся информации о приложении, сколько трафика было потрачено.

Чтобы понять, насколько существенно Xiaomi Service Framework разряжает батарею, нужно снова открыть настройки:

1. В «Настройках» зайдите в категорию «Безопасность».

2. Отыщите вкладку «Потребление трафика».

3. Откройте «Системные приложения» и найдите в списке Service Framework.

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

Disable smart card-only authentication

If you manually manage the profiles that are installed on the computer, you can remove the smart card-only profile in two ways. You can use the Profiles pane of System Preferences, or you can use the /usr/bin/profiles command-line tool. For more information, open Terminal and enter man profiles .

If your client computers are enrolled in Mobile Device Management (MDM), you can restore password-based authentication. To do this, remove the smart card configuration profile that enables the smart card-only restriction from the client computers.

To prevent users from being locked out of their account, remove the enforceSmartCard profile before you unpair a smart card or disable attribute matching. If a user is locked out of their account, remove the configuration profile to fix the issue.

If you apply the smart card-only policy before you enable smart card-only authentication, a user can get locked out of their computer. To fix this issue, remove the smart card-only policy:

1. Turn on your Mac, then immediately press and hold Command-R to start up from macOS Recovery. Release the keys when you see the Apple logo, a spinning globe, or a prompt for a firmware password.
2. Select Disk Utility from the Utilities window, then click Continue.
3. From the Disk Utility sidebar, select the volume that you’re using, then choose File > Mount from the menu bar. (If the volume is already mounted, this option is dimmed.) Then enter your administrator password when prompted.
4. Quit Disk Utility.
5. Choose Terminal from the Utilities menu in the menu bar.
6. Delete the Configuration Profile Repository. To do this, open Terminal and enter the following commands. In these commands, replace with the name of the macOS volume where the profile settings were installed. rm /Volumes/ /var/db/ConfigurationProfiles/MDM_ComputerPrefs.plist rm /Volumes/ /var/db/ConfigurationProfiles/.profilesAreInstalled rm /Volumes/ /var/db/ConfigurationProfiles/Settings/.profilesAreInstalled rm /Volumes/ /var/db/ConfigurationProfiles/Store/ConfigProfiles.binary rm /Volumes/ /var/db/ConfigurationProfiles/Setup/.profileSetupDone
7. When done, choose Apple () menu > Restart.
8. Reinstall all the configuration profiles that existed before you enabled smart card-only authentication.

Как отключить Service Framework в смартфоне Xiaomi

Удалять приложение не рекомендуется, так как оно системное, однако можно просто его отключить. Смело делайте это, если не пользуетесь функциями Mi Cloud. Есть два способа отключить Service Framework: без использования root-прав или при их наличии.

Отключаем Service Framework без root-прав

1. В «Настройках» вам нужен раздел «Батарея и производительность».

2. Найдите пункт «Питание» или «Расход заряда батареи» (зависит от версии ПО).

3. Пять раз нажмите на пункт «Включить».

4. Появится режим «Максимальный», его нужно активировать.

5. Выбираем приложение Xiaomi Service Framework и активируем опцию «Ограничение фоновой активности».

Важная деталь: этот способ сработает, если смартфон Xiaomi не обновлен до версии MIUI 10. В ином случае отключить Xiaomi Service Framework можно только с root-правами.

Отключаем Service Framework без root-прав (посмотрите, сколько неприлично много энергии иногда потребляет это системное приложение!)

Отключаем с root-правами

1. В «Настройках» смартфона найдите раздел «О телефоне».

2. Отрывисто нажимайте на строку с версией системы MIUI, пока не появится уведомление о получении root-прав.

3. Теперь найдите в этом же разделе пункт «Для разработчиков».

4. Включите функцию «Отладка по USB».

Отключаем Service Framework c root-правами с помощью приложений TWRP и Root Uninstaller

Для дальнейших действий нужны два приложения: TWRP (Team Win Recovery Project) и Root Uninstaller:

1. Устанавливаем Team Win Recovery Project.

2. Возвращаемся в настройках в раздел «О телефоне».

3. Находим «Обновление прошивки» и нажимаем на «…».

4. Перезагружаемся в Recovery.

5. Устанавливаем приложение Root Uninstaller.

6. Запускаем его, разрешаем доступ к root-правам.

Далее остается найти Xiaomi Service Framework в списке приложений и «заморозить» ненавистную утилиту.

Enable smart card-only login

Make sure that you carefully follow these steps to ensure that users will be able to log in to the computer.

1. Pair a smart card to an admin user account or configure Attribute Matching.
2. If you’ve enabled strict certificate checks, install any root certificates or intermediates that are required.
3. Confirm that you can log in to an administrator account using a smart card.
4. Install a smart-card configuration profile that includes » enforceSmartCard

For more information about smart card payload settings, see the Apple Configuration Profile Reference.

For more information about using smart card services, see the macOS Deployment Guide or open Terminal and enter man SmartCardServices .

Как еще уменьшить расход трафика приложением Service Framework

Если не хотите отключать приложение, можете просто задать для него лимит по трафику:

1. Найдите в «Настройках» раздел «Передача данных». В некоторых версиях ПО он называется «Интернет».

2. Откройте «Контроль трафика».

3. Нажмите на «Тарифный план» и далее перейдите к пункту «Лимит трафика».

4. Определите предельный объем трафика для приложения.

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

Configure Secure Shell Daemon (SSHD) to support smart card-only authentication

Users can use their smart card to authenticate over SSH to the local computer or to remote computers that are correctly configured. Follow these steps to configure SSHD on a computer so that it supports smart card authentication.

Update the /etc/ssh/sshd_config file:

1. Use the following command to back up the sshd_config file: sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config_backup_`date «+%Y-%m-%d_%H:%M»`
2. In the sshd_config file, change «#ChallengeResponseAuthentication yes» to «ChallengeResponseAuthentication no» and change «#PasswordAuthentication yes» to «#PasswordAuthentication no.»

Then, use the following commands to restart SSHD:

sudo launchctl stop com.openssh.sshd

sudo launchctl start com.openssh.sshd

If a user wants to authenticate SSH sessions using a smart card, have them follow these steps:

1. Use the following command to export the public key from their smart card: ssh-keygen -D /usr/lib/ssh-keychain.dylib
2. Add the public key from the previous step to the

/.ssh/authorized_keys file on the target computer.

• Use the following command to back up the ssh_config file: sudo cp /etc/ssh/ssh_config /etc/ssh/ssh_config_backup_`date «+%Y-%m-%d_%H:%M»`
• In the/etc/ssh/ssh_config file, add the line «PKCS11Provider=/usr/lib/ssh-keychain.dylib.»

If the user wants to, they can also use the following command to add the private key to their ssh-agent:

ssh-add -s /usr/lib/ssh-keychain.dylib

Оптимизация работы Xiaomi Service Framework

Если вам важна синхронизация, то можете просто ограничить «поле деятельности» Xiaomi Service Framework, чтобы приложение работало, но не потребляло много интернет-трафика и заряда аккумулятора. Сделать это легко:

1. В «Настройках» откройте пункт «Дополнительно или «Расширенные» (в разных версиях ПО названия отличаются).

2. Выберите «Конфиденциальность».

3. Перейдите во вкладку «Доступ к уведомлениям».

4. Найдите в списке Xiaomi Service Framework и отключите его.

5. Вернитесь в настройки конфиденциальности и выберите пункт «Приложения с доступом к данным».

6. Также отыщите Service Framework и ограничьте его активность.

Теперь Xiaomi Service Framework не будет «читать» все сообщения, служебные уведомления и ваши личные данные.

Сделав несколько тапов по экрану, вы сильно ограничите работу Xiaomi Service Framework, при этом оставив его включенным

Условия и реализация атаки

Для отправки вредоносных OMA CP сообщений атакующему достаточно иметь GSM-модем и находиться в пределах досягаемости жертвы/жертв. При этом возможны как таргетированные атаки, так и широковещательная рассылка запросов на изменение настроек.

NETWPIN-аутентификация

За редким исключением (рассмотрено ниже про Samsung) сообщения от оператора аутентифицируются, предоставив девайсу его же IMSI (Mobile Subscriber Identity, уникальный 64-битный идентификатор устройства, аналогичный IP-адресу в «этих ваших интернетах»).

Насколько сложно «достать» IMSI — вопрос отдельный, но есть как минимум следующие способы:

• вредоносное приложение на устройстве (при этом достаточно разрешения в манифесте permission.READ_PHONE_STATE);
• посмотреть SIM-карту жертвы;
• использование ISMI-catcher, имитирующих мобильные вышки, что потребует определенных вложений, но вполне возможно.

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

USERPIN-аутентификация

Даже если у злоумышленника отсутствует ISMI, то можно осуществить следующий вектор атаки:

• отправка сообщения от имени оператора с запросом о применении настроек;
• автоматический запрос у пользователя PIN-кода системой;
• отправка CP-сообщения с настройками, защищенного PIN-кодом, указанным пользователем.

Погружение в службы Android

Перевод статьи «Deep Dive into Android Services» от Nazmul Idris. Я оставил оригинальное название автора, хотя это скорее не «погружение», а «знакомство». Думаю, текст будет полезен начинающим разработчикам. Статья отлично дополняет офф. документацию по службам на Android. В статье разбираются особенности взаимодействия с запущенными и привязанными службами. Плюс статьи в том, что учитываются изменения в работе со службами в Android O. В переводе есть незначительные, по сравнению с оригиналом, изменения, добавленные для пущей ясности.

Введение

Большинство современных android-приложений выполняют часть задач в фоне. Это означает, что задачи выполняются в фоновом потоке, а не в потоке пользовательского интерфейса (UI-поток).

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

Чтобы справиться с этим вы могли бы использовать AsyncTask. Но что, если вашему приложению необходимо запустить этот фоновый поток не только из Activity, но и из нотификации (notification) или из другого компонента?

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

Служба — это компонент android-приложения без видимого интерфейса, который запускается в основном потоке приложения. Служба должна быть объявлена в манифесте. Если вам необходимо чтобы служба работала в фоновом потоке, вы должны самостоятельно реализовать это.

Термины фон и передний план перегружены, и могут применяться к:

1. жизненному циклу компонентов Android
2. потокам

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

Существует подкласс android-служб, называемый IntentService, который запускает задачи в фоновом потоке «из коробки». Но мы не будем говорить о таких службах в этой статье.

Потоки, службы и жизненный цикл компонентов Android

Давайте сделаем шаг назад и посмотрим на более общую картину того, что должны делать службы. Ваш код, который работает в фоновом потоке, например Thread или Executor, на самом деле не связан с жизненным циклом какого-либо компонента Android. Если мы говорим об Activity, то она имеет конкретную точку запуска и остановки работы, основываясь на взаимодействии с пользователем. Однако эти точки начала и конца работы Activity не обязательно связаны с жизненным циклом Thread или Executor.

Ниже приведены пояснения к основным временным моментам этой диаграммы Гантта. Детали этих моментов (и пояснения к ним) приведены в остальной части статьи.

Метод службы onCreate() вызывается в момент ее создания (путем запуска или привязки к ней).

Затем, через некоторое время, служба запускает Thread или Executor. Когда Thread завершает работу, он дает об этом знать службе, чтобы та могла вызвать метод stopSelf(). Это довольно распространенный шаблон реализации службы.

Код, который вы пишите в ваших Thread или Executor, должен сообщить службе о запуске или остановке фонового потока.

• Когда поток начинает работу, он должен установить начальное состояние сервиса путем вызова startService()
• Когда поток завершает работу, он должен вызвать stopSelf() у службы.

Метод службы onDestroy() вызывается системой только когда вы сообщили службе, что пришло время завершать работу. Служба не знает, что будет происходить в коде ваших Thread или Executor — это зона вашей ответственности. Таким образом, задача программиста сообщить службе о начале и о завершении работы.

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

1. Запущенная служба
2. Привязанная служба
3. Привязанная и запущенная служба одновременно

Изменения в Android O

В Android O (API 26) произошли существенные изменения в регулировании фоновых служб системой. Одно из главных изменений в том, что запущенная служба, которая не в белом списке (в белый список помещаются службы, работа которых видна пользователю; подробнее смотри в офф. документации) или которая явно не сообщает пользователю о своей работе, не будет запускаться в фоновом потоке после закрытия Activity. Другими словами, вы должны создать уведомление (notification), к которому вы прикрепляете запущенную службу. И вы должны запускать службу с помощью нового метода  startForegroundService() (а не с помощью startService()). И, после создания службы, у вас есть пять секунд чтобы вызвать метод startForeground() запущенной службы и показать видимое пользователю уведомление. Иначе система останавливает службу и показывает ANR («приложение не отвечает»). Ниже мы разъясняем эти положения с помощью примеров кода.

Запущенные службы

Запущенные службы начинают свою работу после вызова метода startService(Intent) в вашей Activity или службе. При этом Intent должен быть явным. Это означает, что вы должны явно указать в Intent имя класса запускаемой вами службы. Или, если вам важно допустить некоторую неопределенность в отношении того, какая служба запускается, вы можете предоставить фильтры намерений для ваших служб и исключить имя компонента из Intent, но затем вы должны установить пакет для намерения с помощью setPackage(), который обеспечивает достаточное устранение неоднозначности для целевой службы. Ниже мы приводим пример создания явного Intent:

public class MyIntentBuilder{ public static MyIntentBuilder getInstance(Context context) { return new MyIntentBuilder(context); } public MyIntentBuilder(Context context) { this.mContext = context; } public MyIntentBuilder setMessage(String message) { this.mMessage = message; return this; } public MyIntentBuilder setCommand(@Command int command) { this.mCommandId = command; return this; } public Intent build() { Assert.assertNotNULL(«Context can not be NULL!», mContext); Intent intent = new Intent(mContext, MyTileService.class); if (mCommandId != Command.INVALID) { intent.putExtra(KEY_COMMAND, mCommandId); } if (mMessage != NULL) { intent.putExtra(KEY_MESSAGE, mMessage); } return intent; } }

Чтобы служба стала запущенной, вы должны вызвать startService() с явным намерением. Если вы не сделаете этого, тогда служба не перейдет в запущенное состояние. И, таким образом, она не сможет перейти на передний план, и stopSelf() на самом деле ничего не выполнит.

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

Служба может быть запущена несколько раз. Каждый раз, когда она запускается, вызывается onStartCommand(). Этому методу передается несколько параметров наряду с явным Intent. Даже если вы запускаете службу несколько раз, она вызывает onCreate() только однажды (конечно, если до этого служба уже не была привязана). Чтобы завершить работу, служба должна вызвать stopSelf(). После того, как служба будет остановлена (когда вы остановите ее), и если с ней ничего больше не связано, вызывается onDestroy(). Помните об этом, когда выделяете ресурсы для вашей запущенной службы.

Intent

Для старта запущенной службы необходим Intent. Компонент Android, в котором стартует служба, на самом деле не хранит соединение с ней, и если ему необходимо что-то сообщить запущенной службе, он может запустить ее снова, используя другой Intent. Это главная разница между запущенной и привязанной службой. Привязанные службы со своей стороны реализуют шаблон клиент-сервер. Где клиент (компонент Android UI или другая служба) хранит соединение и может через него вызывать методы непосредственно у службы.

public class MyActivity extends Activity{ @TargetApi(Build.VERSION_CODES.O) private void moveToStartedState() { Intent intent = new MyIntentBuilder(this) .setCommand(Command.START).build(); if (isPreAndroidO()) { Log.d(TAG, «Running on Android N or lower»); startService(intent); } else { Log.d(TAG, «Running on Android O»); startForegroundService(intent); } } }

Помните, что в Android O многое изменилось в отношении запущенных служб. Они больше не могут работать достаточно долго в фоне без механизма постоянного уведомления. И метод старта запущенной службы в фоне в Android O — это startForegroundService(Intent).

Передний план и механизм постоянного уведомления

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

Примеры использования службами переднего плана:

1. Приложения, которые проигрывают медиа-файлы в фоне.
2. Приложения, которые обновляют данные о местоположении в фоне.

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

Ниже пример старта запущенной службы на переднем плане:

public class MyActivity extends Activity{ private void commandStart() { if (!mServiceIsStarted) { moveToStartedState(); return; } if (mExecutor == NULL) { // Start Executor task in Background Thread. } } }

Вот код создания постоянного уведомления в версиях
до Android O
@TargetApi(25) public static class PreO { public static void createNotification(Service context) { // Create Pending Intents. PendingIntent piLaunchMainActivity = getLaunchActivityPI(context); PendingIntent piStopService = getStopServicePI(context); // Action to stop the service. NotificationCompat.Action stopAction = new NotificationCompat.Action.Builder( STOP_ACTION_ICON, getNotificationStopActionText(context), piStopService) .build(); // Create a notification. Notification mNotification = new NotificationCompat.Builder(context) .setContentTitle(getNotificationTitle(context)) .setContentText(getNotificationContent(context)) .setSmallIcon(SMALL_ICON) .setContentIntent(piLaunchMainActivity) .addAction(stopAction) .setStyle(new NotificationCompat.BigTextStyle()) .build(); context.startForeground( ONGOING_NOTIFICATION_ID, mNotification); } }

в Android O, через NotificationChannel

@TargetApi(26) public static class O { public static final String CHANNEL_ID = String.valueOf(getRandomNumber()); public static void createNotification(Service context) { String channelId = createChannel(context); Notification notification = buildNotification(context, channelId); context.startForeground( ONGOING_NOTIFICATION_ID, notification); } private static Notification buildNotification( Service context, String channelId) { // Create Pending Intents. PendingIntent piLaunchMainActivity = getLaunchActivityPI(context); PendingIntent piStopService = getStopServicePI(context); // Action to stop the service. Notification.Action stopAction = new Notification.Action.Builder( STOP_ACTION_ICON, getNotificationStopActionText(context), piStopService) .build(); // Create a notification. return new Notification.Builder(context, channelId) .setContentTitle(getNotificationTitle(context)) .setContentText(getNotificationContent(context)) .setSmallIcon(SMALL_ICON) .setContentIntent(piLaunchMainActivity) .setActions(stopAction) .setStyle(new Notification.BigTextStyle()) .build(); } @NonNULL private static String createChannel(Service ctx) { // Create a channel. NotificationManager notificationManager = (NotificationManager) ctx.getSystemService(Context.NOTIFICATION_SERVICE); CharSequence channelName = «Playback channel»; int importance = NotificationManager.IMPORTANCE_DEFAULT; NotificationChannel notificationChannel = new NotificationChannel( CHANNEL_ID, channelName, importance); notificationManager.createNotificationChannel( notificationChannel); return CHANNEL_ID; } }

Кроме того, вот еще одна статья, в которой больше деталей о создании уведомлений в MediaStyle (поскольку для фонового проигрывания аудио-файлов нужны как уведомления, так и привязанные и запущенные службы)

Остановка запущенных служб

Обратите внимание, что параметр piStopService типа PendingIntent (который передается в конструктор уведомления) фактически передает Intent с константой Command.STOP типа Integer. Помните, что startService(Intent) может вызываться несколько раз? Это пример такого поведения. Чтобы остановить службу мы запускаем Intent через startService(Intent) и далее обрабатываем этот Intent в методе onStartCommand() запущенной службы.

public class HandleNotifications{ private static PendingIntent getStopServicePI(Service context) { PendingIntent piStopService; { Intent iStopService = new MyIntentBuilder(context) .setCommand(Command.STOP).build(); piStopService = PendingIntent.getService( context, getRandomNumber(), iStopService, 0); } return piStopService; } }

Это объясняет почему метод onStartCommand() должен уметь обрабатывать Intentы. Используя этот механизм мы можем «сказать» службе, чтобы она остановила работу. Ниже код, который иллюстрирует эти возможности:

public class MyService extends Service{ @Override public int onStartCommand(Intent intent, int flags, int startId) { boolean containsCommand = MyIntentBuilder .containsCommand(intent); d(TAG, String.format( «Service in [%s] state. cmdId: [%d]. startId: [%d]», mServiceIsStarted ? «STARTED» : «NOT STARTED», containsCommand ? MyIntentBuilder.getCommand(intent) : «N/A», startId)); mServiceIsStarted = true; routeIntentToCommand(intent); return START_NOT_STICKY; } private void routeIntentToCommand(Intent intent) { if (intent != NULL) { // process command if (containsCommand(intent)) { processCommand(MyIntentBuilder.getCommand(intent)); } // process message if (MyIntentBuilder.containsMessage(intent)) { processMessage(MyIntentBuilder.getMessage(intent)); } } } }

Если вы хотите завершить выполнение запущенной службы на переднем плане, вы должны вызвать stopForeground(true). Этот метод также завершит работу постоянного уведомления. Однако, саму службу это не остановит. Для этого следует вызвать stopSelf().

Чтобы остановить службу вы можете выполнить одно из следующих действий:

1. Как было показано выше, передайте Intent с дополнительным параметром в startService(), который затем будет обработан в onStartCommand() и фактически служба вызовет stopSelf(). И, если к службе не привязаны никакие другие компоненты, это вызовет onDestroy() и служба завершит свою работу.
2. Вы также можете создать явный Intent (указывая на класс службы) и передать его в метод stopService(), который вызовет stopSelf() и, затем, onDestroy() аналогично п.1.

Вот несколько примеров остановки службы из Activity:

public class MyActivity extends Activity{ void stopService1(){ stopService(new MyIntentBuilder(this).build()); } void stopService2(){ startService(new MyIntentBuilder(this) .setCommand(Command.STOP).build()); } }

И вот код в вашей службе, который будет обрабатывать эти запросы (при условии, что ваша запущенная служба находится на переднем плане):

public class MyService extends Service{ private void stopCommand(){ stopForeground(true); stopSelf(); } }

Привязанные службы

В отличие от запущенных служб, привязанные службы позволяют установить соединение между компонентом Android, привязанным к службе, и службой. Это соединение предоставляется реализацией интерфейса IBinder, который определяет методы для взаимодействия со службой. Простым примером этого может быть реализация привязанной службы в одном процессе с клиентом (т.е. в рамках вашего собственного приложения). В этом случае Java-объект, подкласс Binder, передается клиенту, который может использовать его для вызова методов службы.

В более сложных сценариях, когда необходимо, чтобы интерфейс службы был доступен для разных процессов, для предоставления клиенту интерфейса службы следует воспользоваться объектом Messenger (является ссылкой на объект Handler, который получает обратный вызов для каждого вызова от клиента), благодаря чему со службой можно взаимодействовать с помощью объектов Message. Объект Messenger фактически основан на AIDL (Android Interface Definition Language). Messenger создает очередь из всех запросов клиентов в рамках одного потока, поэтому служба одновременно получает только один запрос. Если необходимо, чтобы служба обрабатывала одновременно сразу несколько запросов, можно использовать AIDL напрямую.

Отличия между привязанной и запущенной службами:

1. У клиентского компонента нет соединения с запущенной службой. Он просто использует объекты Intent посредством startService() или stopService(), которые обрабатываются службой в методе onStartCommand().
2. Когда клиентский компонент (Activity, Fragment или другая служба) соединяются с привязанной службой, они получают реализацию IBinder, посредством которой они могут вызывать методы у привязанной службы.

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

bindService() и onCreate()

Для того, чтобы клиентский компонент стал привязанным к службе, необходимо вызвать bindService() с явным Intent, как и в случае с запущенной службой.

Пример:

public class MyActivity extends Activity{ void bind(){ bindService( new MyIntentBuilder(this).build(), mServiceConnection, BIND_AUTO_CREATE); } }

BIND_AUTO_CREATE это наиболее часто встречающийся флаг в случае вызова bindService(). Существуют и другие флаги (например, BIND_DEBUG_UNBIND или BIND_NOT_FOREGROUND). В случае BIND_AUTO_CREATE у привязанной службы вызывается onCreate(), если служба до этого еще не была создана. Фактически это означает, что служба создается в момент первой привязки к ней.

Как только вызывается bindService(), службе необходимо реагировать на запрос клиента и предоставить ему экземпляр IBinder, посредством которого клиент сможет вызывать методы привязанной службы. В примере выше, это реализуется с помощью ссылки mServiceConnection. Это обратный вызов (callback) ServiceConnection, который привязанная служба будет использовать для уведомления клиента о завершении привязки. Он также позволит клиенту узнать о разрыве соединения со службой.

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

Ниже приведен пример реализации ServiceConnection:

public class MyActivity extends Activity{ private ServiceConnection mServiceConnection = new ServiceConnection(){ public void onServiceConnected( ComponentName cName, IBinder service){ MyBinder binder = (MyService.MyBinder) service; mService = binder.getService(); // Get a reference to the Bound Service object. mServiceBound = true; } public void onServiceDisconnected(ComponentName cName){ mServiceBound= false; } }; }

Привязка службы

Давайте посмотрим, что происходит на стороне привязанной службы, когда клиент вызывает bindService(Intent).

В привязанной службе вы должны реализовать метод onBind(), для получения клиентом экземпляра IBinder. Метод ‘onBind()’ будет вызван только один раз, при первой привязке клиента. Для последующих клиентов, система выдаст такой же экземпляр IBinder:

public class MyService extends Service{ public IBinder onBind(Intent intent){ if (mBinder == NULL){ mBinder = new MyBinder(); } return mBinder; } }

Объект IBinder обеспечивает программный интерфейс, с помощью которого клиенты могут взаимодействовать со службой. Как говорилось выше, самый простой способ реализации IBinder — это расширение класса Binder, экземпляр которого возвращается из метода onBind():

public class MyService extends Service{ public class MyBinder extends android.os.Binder { MyService getService(){ // Simply return a reference to this instance //of the Service. return MyService.this; } } }

В примере выше, мы просто используем метод getService(), который просто возвращает Java-объект привязанной службы клиентскому компоненту. Ссылаясь на этот экземпляр IBinder, клиент может вызывать публичные методы у привязанной службы напрямую. Обратите внимание, что эти методы выполняются в клиентском потоке. И в случае Activity или Fragment эти методы будут выполняться в главном потоке. Поэтому стоит быть осторожным с методами в привязанной службе, которые могут блокировать поток или могут стать причиной ANR.

Отвязка от службы и вызов onDestroy()

Чтобы отвязаться от привязанной службы, клиент просто вызывает unbindService(mServiceConnection). Затем система вызовет onUnbind() в самой службе. И, если у привязанной службы больше нет клиентов, и также, если, служба не является запущенной службой, то система вызывает onDestroy.

Вот как выглядит вызов unbindService() в клиентском компоненте:

public class MyActivity extends Activity{ protected void onStop(){ if (mServiceBound){ unbindService(mServiceConnection); mServiceBound = false; } } }

В коде выше, метод onStop() в Activity переопределен для вызова unbindService(). В зависимости от требований UX к приложению ваш клиентский компонент может привязываться к службе и отвязываться от нее в методах onStart() и onStop() соответственно, или в любых других методах жизненного цикла клиентских компонентов на ваше усмотрение.

Вот пример как может выглядеть onUnbind() в коде привязанной службы:

public class MyService extends Service{ public boolean onUnbind(Intent i){ return false; } }

Обычно вы вернете false. Но, если вернуть true, то при привязке следующего клиента к службе вместо onBind() будет вызван метод onRebind().

Привязанные и запущенные службы одновременно

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

Если служба не запущена, то клиент, который хочет привязаться к ней, вызовет onCreate() у службы. Если служба уже запущена, этот метод не вызывается. С другой стороны, если клиент отвязывается от службы и при этом служба не запущенная, то вызывается onDestroy() и служба уничтожается.

Вы можете запустить службу путем вызова метода startService(), вывести ее на передний план и показывать постоянное уведомление. Таким образом, вы реализуете все, что мы говорили о создании запущенных служб. Но кроме того, вы можете реализовать методы, которые позволят клиентам привязываться к службе, с помощью вызова метода bindService(). Особенность такой »двойной» службы в том, что даже при отвязке всех клиентов, служба продолжает свою работу и выполняется до тех пор, пока сама не остановит себя с помощью метода stopSelf(), или до тех пор, пока другой компонент не вызовет метод stopService().

Переход в запущенное состояние

Поскольку клиент, привязываясь к службе, не переведет ее в запущенное состояние, то для привязанных и запущенных служб одновременно, требуется чтобы служба переходила в запущенное состояние самостоятельно. Вот, как можно это сделать с учетом Android O:

много кода

public class MyService extends Service{ private void commandStart() { if (!mServiceIsStarted) { moveToStartedState(); return; } if (mExecutor == NULL) { mTimeRunning_sec = 0; if (isPreAndroidO()) { HandleNotifications.PreO.createNotification(this); } else { HandleNotifications.O.createNotification(this); } mExecutor = Executors .newSingleThreadScheduledExecutor(); Runnable runnable = new Runnable() { @Override public void run() { recurringTask(); } }; mExecutor.scheduleWithFixedDelay( runnable, DELAY_INITIAL, DELAY_RECURRING, DELAY_UNIT); d(TAG, «commandStart: starting executor»); } else { d(TAG, «commandStart: do nothing»); } } @TargetApi(Build.VERSION_CODES.O) private void moveToStartedState() { Intent intent = new MyIntentBuilder(this) .setCommand(Command.START).build(); if (isPreAndroidO()) { Log.d(TAG, «moveToStartedState: on N/lower»); startService(intent); } else { Log.d(TAG, «moveToStartedState: on O»); startForegroundService(intent); } } @Override public int onStartCommand( Intent intent, int flags, int startId) { boolean containsCommand = MyIntentBuilder .containsCommand(intent); d(TAG, String.format( «Service in [%s] state. id: [%d]. startId: [%d]», mServiceIsStarted ? «STARTED» : «NOT STARTED», containsCommand ? MyIntentBuilder.getCommand(intent) : «N/A», startId)); mServiceIsStarted = true; routeIntentToCommand(intent); return START_NOT_STICKY; } private void routeIntentToCommand(Intent intent) { if (intent != NULL) { // process command if (containsCommand(intent)) { processCommand(MyIntentBuilder.getCommand(intent)); } // process message if (MyIntentBuilder.containsMessage(intent)) { processMessage(MyIntentBuilder.getMessage(intent)); } } } private void processMessage(String message) { try { d(TAG, String.format(«doMessage: message from client: ‘%s'», message)); } catch (Exception e) { e(TAG, «processMessage: exception», e); } } private void processCommand(int command) { try { switch (command) { case Command.START: commandStart(); break; case Command.STOP: commandStop(); break; } } catch (Exception e) { e(TAG, «processCommand: exception», e); } } /*…*/ }

В коде под спойлером:

1. Метод commandStart() может быть вызван клиентом, который привязывается к службе.
2. Или commandStart() вызывается через методы startService() или startForegroundService() (для Android O).

Но, перед фактическим исполнением работы, служба сначала переводит себя в запущенное состояние.

Итак, когда клиент привязывается к службе, вызывается commandStart(). Служба еще не запущена. Давайте посмотрим на код, и увидим, что случится:

1. Если служба привязывается к клиенту, то она не запущена (и вmServiceStarted содержится false)
2. В этом случае вызывается moveToStarted() и там создается явный Intent с Extras Command.START, и далее вызывается startService() или startForegroundService().
3. Это приводит к вызову onStartCommand(), который опять вызывает commandStart().
4. Но теперь в commandStart() значение переменной mServiceIsStarted равняется true, и поэтому метод commandStart() выполняет свое прямое предназначение, т.е. запускает полезную работу службы.

Завершение работы службы и отвязывание

Если служба не в запущенном состоянии и клиентский компонент отвязывается от службы, то служба уничтожается и вызывается onDestroy()

Но если она в запущенном состоянии она не уничтожается. И она будет «убита», только если запущенное состояние будет остановлено (через вызов stopService(Intent) или вызов startService(Intent) c Extras в Intent, которые говорят о намерении остановить службу, например Command.STOP).

Вот диаграмма, в которой суммируются состояния службы и переходы между ними для запущенной и привязанной службы одновременно:

Примеры

Реализацию большинства из того, о чем говорилось в статье, можно глянуть на GitHub.

Это небольшая утилита для Android O и N, которая держит телефон в активном состоянии, если он на зарядке.