Ваш BLE-скан на Android тихо умирает через 5 минут. И вы об этом не знаете

в 12:28, , рубрики: android, background, beacon, bluetooth, indoor-навигация, позиционирование, сканирование

«Самого главного глазами не увидишь» Антуан де Сент-Экзюпери, «Маленький принц»

Всем привет! Меня зовут Денис Хамидуллин, я Android-разработчик.

Я работаю в команде, и мы занимаемся системами позиционирования людей, транспорта и оборудования внутри помещений и на ограниченных территориях — в промышленности, логистике и ритейле.

Вкратце о том, как это работает:

Позиционирование осуществляется на базе технологии Bluetooth Low Energy (BLE). Устройство сканирует BLE-маяки (в простонароде биконы) — небольшие автономные устройства, которые непрерывно транслируют короткие пакеты: идентификатор (в iBeacon это UUID + major + minor) и калиброванную мощность сигнала на расстоянии 1 м. Эти измерения от нескольких маяков — входные данные для алгоритмов, которые оценивают положение устройства.

Нередко бывают случаи, когда отслеживаемым устройством является обычный Android-смартфон в кармане сотрудника. А значит, устройство должно функционировать не только в разблокированном виде, но и в фоне с выключенным экраном. Здесь начинается самое странное: на одном телефоне всё стабильно, на другом через полчаса маячки «пропадают», на третьем приложение тихо «умирает» ночью.

Большая часть статей на эту тему написана во времена Android 7–9 и с тех пор сильно устарела. В этой статье я разберу, как устроено BLE-сканирование и почему в фоне оно деградирует на современных версиях Android: какие ограничения заложены в сам Bluetooth-стек (со ссылками на исходники AOSP) и что добавляют производители. А затем расскажу, как мы решали эту проблему, на какие подводные камни наткнулись по пути и что из этого подтверждается замерами на реальном устройстве.

Ваш BLE-скан на Android тихо умирает через 5 минут. И вы об этом не знаете - 1

Android и «закручивание гаек»

Платформа андроид не первый год занимается оптимизацией энергопотребления. Всё началось еще с Android 6, с введением Doze mode и App Standby. На это есть две причины: экономия расхода батареи и соблюдение приватности пользователя. Теперь же, с каждой версией ОС, выполнять задачи в фоне становится всё труднее, и каждому приложению нужно бороться за свое место «под солнцем»

Версия Android

Что поменялось

6 (2015)

Doze и App Standby; для BLE-скана нужно runtime-разрешение на геолокацию

7

Doze «на ходу» (light doze); недокументированные лимиты BLE: не больше 5 стартов скана за 30 с и таймаут длительного скана

8 / 8.1

фоновые сервисы останавливаются через несколько минут после ухода приложения в фон — долгая работа только через Foreground Service; появился PendingIntent-скан; в 8.1 скан без фильтра приостанавливается при выключенном экране

9

App Standby Buckets — частота фоновых задач зависит от того, как часто пользователь открывает приложение

10

отдельное разрешение ACCESS_BACKGROUND_LOCATION; foregroundServiceType="location«

11

«Разрешить всегда» для геолокации — только через настройки

12

запрет запуска Foreground Service из фона (с исключениями); новое разрешение BLUETOOTH_SCAN

13

Bluetooth вынесен в отдельный системный модуль (Mainline); в QPR1 таймаут 30 мин распространён и на сканы с фильтром

14

тип Foreground Service обязателен, плюс отдельное разрешение на каждый тип

15

force stop отменяет все PendingIntent приложения — включая PendingIntent-скан

16

квоты JobScheduler действуют даже при запущенном Foreground Service; Bluetooth-модуль обновляется независимо от прошивки

17

лимиты памяти на приложение в зависимости от объёма RAM

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

Замеры в статье сделаны на устройстве Samsung (Android 14, One UI 6.1); данные по другим производителям взяты из публичных источников.

1. Базовый скан: как это работает

Начнём с манифеста, так как именно в нём объявляются все разрешения. С каждой версией этих разрешений нужно всё больше. Для сканирования маячков набор зависит от версии Android:

Android

Что нужно для скана маяков

6–9 (API 23–28)

BLUETOOTH, BLUETOOTH_ADMIN + runtime ACCESS_COARSE_LOCATION или ACCESS_FINE_LOCATION; служба геолокации включена

10–11 (API 29–30)

ACCESS_FINE_LOCATION (coarse уже не хватает); для фона — ACCESS_BACKGROUND_LOCATION (в 11 — только через настройки)

12+ (API 31+)

runtime BLUETOOTH_SCAN (группа «Устройства поблизости»); для маячков по-прежнему нужны ACCESS_FINE_LOCATION и для фона ACCESS_BACKGROUND_LOCATION - см. ниже про neverForLocation

14+ (API 34+)

для фонового сервиса: FOREGROUND_SERVICE + FOREGROUND_SERVICE_LOCATION и foregroundServiceType="location"; запустить такой сервис из фона можно только с ACCESS_BACKGROUND_LOCATION

На этом этапе уже можно встретить пару подводных камней:

1) Флаг neverForLocation.

Документация Android 12 предлагает флаг neverForLocation — флаг того, что мы не определяем местоположение при сканировании. Соблазнительно, но с этим флагом система молча вырезает из результатов пакеты iBeacon и Eddystone: в AOSP для этого есть denylist по сигнатурам 0×004C 0×02 (iBeacon) и 0xFEAA (Eddystone) (AOSP). В нашем случае, это означает пустой экран без единой ошибки.

2) Проверка старых разрешений.

Если BLUETOOTH/BLUETOOTH_ADMIN объявлены с maxSdkVersion="30« (как рекомендует Google), то на Android 12+ checkSelfPermission для них вернёт DENIED. Код, который проверяет их на всех версиях, никогда не запустит скан.

1.1 Как запустить сканирование

val scanner = bluetoothManager.adapter.bluetoothLeScanner

val filters = listOf(
ScanFilter.Builder()
// iBeacon: manufacturer Apple (0×004C), первые два байта данных = 0×02 0×15
.setManufacturerData(0×004C, byteArrayOf(0×02, 0×15), byteArrayOf(-1, −1))
.build()
)
val settings = ScanSettings.Builder()
.setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
.build()

scanner.startScan(filters, settings, object : ScanCallback() {
override fun onScanResult(callbackType: Int, result: ScanResult) { /* RSSI, scanRecord */ }
override fun onScanFailed(errorCode: Int) { /* приходит не всегда */ }
})

— ScanFilter - что искать: MAC, имя, service UUID, service data, manufacturer data с маской. Фильтры по возможности выполняются прямо в Bluetooth-контроллере, и процессор не просыпается ради чужих устройств. И, как увидим в разделе 3, без фильтра скан в фоне просто не работает. — ScanSettings - как искать: режим (scanMode), тип коллбэка (каждый пакет / первое обнаружение / потеря), reportDelay (накапливать результаты в контроллере и отдавать пачкой).

1.2 Что ещё за режим скана?

Маяк шлёт один и тот же пакет по очереди на трёх рекламных каналах (37, 38, 39) раз в интервал (T_adv, обычно 100–1000 мс). Устройство также слушает эфир не постоянно, а окнами: в каждом интервале скана оно слушает один канал в течение окна, а остальное время спит. Константы SCAN_MODE_* - это просто имена для пар «окно / интервал».

Режим

Окно / интервал, мс

Сколько устройство слушает

LOW_POWER

140 / 1400

10% времени

BALANCED

183 / 730

~25%

LOW_LATENCY

100 / 100

~100%

SCREEN_OFF (internal)

512 / 10 240

5%

SCREEN_OFF_BALANCED (internal)

183 / 730

~25%

Последние два режима мы запросить не можем, они системные (AOSP). Об этом в разделе 3.

Сколько пакетов мы увидим?

Если окно длиннее T_adv, пакет почти наверняка попадёт в каждое окно. Если короче — вероятность поймать пакет за одно окно примерно равна окно / T_adv:

обнаружения в минуту ≈ (60 000 / интервал) × min(1, окно / T_adv) × (1 − потери в эфире)

Наш тестовый маяк шлёт пакеты раз в ~500 мс. В LOW_LATENCY с включённым экраном смартфон видел 94 пакета в минуту из ~120 возможных: около 22% теряется даже в идеальных условиях. По формуле для LOW_POWER получается ~9—12 в минуту, для BALANCED ~23—30.

Вывод: помимо частоты важно учитывать максимальную паузу между обнаружениями. При интервале скана 10 с (SCREEN_OFF) человек успевает пройти 10–15 метров между двумя измерениями.

1.3 Где на самом деле выполняется скан?

Путь вызова: приложение → BluetoothLeScanner → binder → системный процесс Bluetooth (GattService → ScanManager) → нативный стек → HCI → Bluetooth-контроллер.

Ваш BLE-скан на Android тихо умирает через 5 минут. И вы об этом не знаете - 2

Из этого следует три важных вещи:

  1. Bluetooth-контроллер один на всё устройство.

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

За это отвечает SсanMAnager - компонент системного Bluetooth-сервиса. Он учитывает, включён ли экран, видно ли приложение пользователю и как долго уже идёт скан. В зависимости от этого он может понизить режим, который мы запросили. Подробно об этом — в следующем разделе. 3. Bluetooth — отдельный обновляемый модуль.

(Mainline, с Android 13; с Android 16 обновляется независимо от прошивки). Поэтому поведение сканирования зависит и от версии Android, и от версии этого модуля.

Следить за фоновым сканированием приходится самому. Для геолокации у Android есть готовые системные механизмы — Fused Location и геозоны: система сама собирает данные и будит приложение. Для долгого BLE-сканирования готового механизма увы нет. Приложению нужно самому держать скан живым: работать через Foreground Service, перезапускать скан, восстанавливаться после смерти процесса.

2. Что ломается в фоне и почему?

Проблемы с фоновым сканированием удобно разложить по трём слоям: Bluetooth-стек, жизненный цикл процесса и прошивка производителя. Каждый слой может остановить скан независимо от других.

Ваш BLE-скан на Android тихо умирает через 5 минут. И вы об этом не знаете - 3

Слой А — Bluetooth-стек AOSP (ScanManager)

Это то, что мы описывали выше: фильтры сканирования, окна и интервалы, таймауты и лимиты. Это, скажем так, первый уровень обороны. Обычно все проблемы, которые появляются во время реализации сканирования, находятся именно здесь. Но за деревьями есть ещё лес.

Слой B — жизненный цикл процесса

— Если вы хотите гарантированно (почти) иметь сканирование в фоне, то вам нужен Foreground Service. Казалось бы, всё просто: два класса кода, и всё работает. На деле ситуация комплекснее. В зависимости от версии ОС вам нужно соблюдать ряд правил: — Android 12 — Foreground Service нельзя запустить из фона, за редкими исключениями. Запускать сервис нужно, пока приложение на экране. — Android 14 — тип сервиса обязателен. Для нас это location и отдельное разрешение FOREGROUND_SERVICE_LOCATION; без доступа к геолокации такой сервис не запустится. — Android 15 — force stop отменяет все PendingIntent приложения, включая PendingIntent-скан. Из BOOT_COMPLETED запрещено запускать часть типов сервисов, location в этот список не входит (документация). — Android 16 — квоты JobScheduler действуют, даже когда запущен Foreground Service (документация). — Android 17 — лимиты памяти на приложение в зависимости от объёма RAM (behavior changes). При превышении процесс завершается: в ApplicationExitInfo причина REASON_OTHER, а в описании — MemoryLimiter:AnonSwap. Пока лимиты выставлены с запасом и рассчитаны на утечки памяти, но для сервиса, который живёт сутками, это актуально.

WorkManager или JobScheduler для этой задачи, увы, не подойдут: периодические задачи можно запускать не чаще, чем один раз в 15 минут. PS. Можно использовать как watchdog для перезапуска скана с PEndingIntent.

Ещё три вещи, которые стоит знать:

— Doze. Когда телефон лежит неподвижно с выключенным экраном и не заряжается, система откладывает сеть, будильники и фоновые задачи. Сам скан идёт в процессе Bluetooth, но всё, что вы делаете с результатами (отправка на сервер, таймеры), попадает под ограничения. У части производителей свой «глубокий» Doze жёстче — например, в HyperOS в логе встречается отказ запускать скан для несистемных приложений (Nordic DevZone). — Force stop. После «Остановить» в настройках система снимает всё: сервис, будильники, задачи, а с Android 15 и PendingIntent-скан. Приложение не запустится, пока пользователь сам его не откроет. Это осознанное действие пользователя, и обходить его не нужно. — Смерть процесса. При нехватке памяти система может убить и процесс с Foreground Service. С START_STICKY сервис перезапускается сам, но скан нужно запустить заново в onStartCommand (наш замер — в разделе 3.5).

Слой C — OEM

Как уже упоминалось выше, производители добавляют свои механизмы энергосбережения поверх Android, и они работают ниже уровня API. Уведомление сервиса висит, код написан по документации, а прошивка всё равно решает, что приложению работать не нужно. Основные ограничения популярных вендоров:

Производитель

Что мешает работе

Samsung (One UI)

списки «спящих» и «глубоко спящих» приложений: приложение, которое не открывали несколько дней, ограничивается автоматически. С One UI 6.0 Samsung заявляет, что Foreground Service приложений с target Android 14 работают как задумано

Xiaomi (MIUI, HyperOS)

автозапуск выключен по умолчанию, без него сервис не перезапускается; агрессивная чистка фона. На Xiaomi 12T при выключенном экране результаты скана приходят пачкой раз в 5 минут (Nordic DevZone)

Huawei, Honor (EMUI, HarmonyOS)

«Запуск приложений» в автоматическом режиме блокирует автозапуск и фоновую активность

OPPO, Vivo, OnePlus

периодическая чистка фоновых процессов, в том числе с Foreground Service

Для отслеживания всех этих ограничений есть замечательный сайт, если вы Android-разработчик, то вы наверняка о нём вкурсе — dontkillmyapp.com.

3. Что мы тестили?

Мы прогоняли сырой сканер на тестовом устройстве Samsung (Android 14) в разных условиях: экран включён и выключен, приложение открыто и свёрнуто, процесс убит, приложение смахнуто из «Недавних». Сканер работал внутри Foreground Service с типом location, приложение было исключено из оптимизации батареи.

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

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

3.1 Таймаут длительного скана: 5 минут

Запускаем LOW_LATENCY с фильтром iBeacon и оставляем телефон лежать с включённым экраном. Первые пять минут всё отлично — 75–100 обнаружений в минуту. На шестой минуте поток падает до 5–14 в минуту и больше не восстанавливается. Открытое на экране приложение ничего не меняет: падение такое же, как в фоне.

Причина видна прямо в logcat:

23:56:14.796 старт скана (scannerId 7, LOW_LATENCY)
00:01:14.826 W BtGatt.ScanManager: Moving filtered scan client to downgraded scan (scannerId 7)

Ровно 300 секунд. Это механизм AOSP: если скан идёт дольше scan_timeout_millis, ScanManager переводит его в LOW_POWER, а скан без фильтра — в оппортунистический режим. Для сканов с фильтром понижение появилось в Android 13 QPR1 (AOSP). Приложению об этом ничего не сообщается: колбэки продолжают приходить, просто реже. В dumpsys bluetooth_manager у скана появляется пометка Forced, а в настройках по-прежнему стоит LOW_LATENCY.

В AOSP значение по умолчанию — 30 минут (AOSP), однако на деле значение может отличаться от телефона к телефону. Начиная с Android 15 Google снизили это время до 10 минут (600000 мс). Проверить его можно командой:

$ adb shell device_config get bluetooth scan_timeout_millis

Хорошая новость: таймер считается от каждого startScan. Как мы это используем — в разделе 4.

3.2 Скан без фильтра и пустой фильтр

С Android 8.1 скан без фильтра приостанавливается, когда гаснет экран (AOSP). В интернете часто советуют обойти это пустым фильтром — ScanFilter.Builder().build(). Когда-то это работало (AOSP). Мы проверили три варианта:

фильтр

Экран вкл, обнаружений/мин

Экран выкл, обнаружений/мин

без фильтра (null)

90

~0

пустой ScanFilter

80

~0

iBeacon (0×004C, 02 15)

80

45–60

Вывод простой: фильтр нужен настоящий. Для iBeacon — по manufacturer data Apple (0×004C) с префиксом 02 15, можно добавить и UUID ваших маяков.

3.3 Квота стартов и молчаливый отказ

Система разрешает приложению не больше 5 вызовов startScan за 30 секунд (scan_quota_count и scan_quota_window_millis). (AOSP) Мы перезапустили скан 7 раз с шагом около 5 секунд. Первые пять стартов прошли, шестой система отклонила:

E BtGatt.GattService: App ’com.example.blescanner’ is scanning too frequently

Седьмой снова прошёл — первый старт к тому моменту вышел из 30-секундного окна.

Самое неприятное — приложение об отказе не узнало. С API 33 есть код ошибки SCAN_FAILED_SCANNING_TOO_FREQUENTLY, но onScanFailed в нашем случае так и не вызвался. Для приложения скан «запущен», а результатов нет. Если в коде есть цикл «нет результатов → перезапустить», он легко упирается в квоту и сам себя выключает.

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

3.4 Выключенный экран и Foreground Service

По коду AOSP (AOSP) фоновое приложение при выключенном экране получает один из экономных режимов SCREEN_OFF. Исключение — приложения с Foreground Service: у них LOW_LATENCY сохраняется. На нашем Samsung это подтвердилось. Мы запустили скан и через 2 минуты выключили экран:

Минута после старта

Экран

Обнаружений/мин

1–2

вкл

55, 80

3–5

выкл

62, 45, 47

6–7

выкл

17, 2

Обнаружений при выключенном экране примерно вдвое меньше, и это видно в dumpsys: в момент, когда гаснет экран, Samsung переключает LOW_LATENCY с окна 4096 мс на интервал 4096 мс (100%) на окно 158,75 мс на интервал 305,6 мс — это около 52% времени.

На шестой минуте срабатывает тот же таймаут из раздела 3.1. Следовательно, с FGS выключенный экран сам по себе скан не режет. Режет таймаут, а при выключенном экране понижение может быть ещё глубже (AOSP). Решить это можно перезапуском, но об этом ниже.

3.5 Смерть процесса и смахивание из «Недавних»

Мы проверили два сценария:

Процесс убит (kill −9). Сервис с START_STICKY система перезапустила через 1,7 секунды, первое обнаружение пришло через 2,1 секунды после убийства. Новый скан снова шёл на полной скорости.

Приложение смахнуто из «Недавних». Пришёл onTaskRemoved, но процесс остался жив: сервис и скан продолжили работать, пауза в потоке результатов — 0,3 секунды. Без запущенного сервиса тот же жест на этом телефоне убивает процесс (в ApplicationExitInfo — REMOVE TASK).

4. Как мы это решаем?

Раньше наша логика сканирования была устроена довольно тривиально: когда приложение на экране — LOW_LATENCY, когда свёрнуто — LOW_POWER с фильтром по производителям маяков. Скан запускался по событиям жизненного цикла приложения и дальше жил сам по себе. На практике это значило всё, что описано в разделе 3: через 5 минут поток обнаружений падал в несколько раз, а после перезапуска процесса без интерфейса скан мог не стартовать вообще.

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

Таймаут длительного скана

Как мы уже успели выяснить, через scan_timeout_millis после старта скан понижается до LOW_POWER. На нашем тестовом устройстве это 5 минут, в AOSP по умолчанию было 30 (1800000 мс), на устройствах Android 15 и выше — 10 минут.

Как мы это исправили? Таймер системы считается от каждого вызова startScan. Поэтому мы перезапускаем скан раньше, чем он истечёт, — раз в 4 минуты. Узнать точное значение таймаута на конкретном телефоне приложение не может, читать device_config ему нельзя (AOSP), поэтому берём интервал с запасом под самый короткий известный нам таймаут.

const val RESTART_PERIOD_MS = 4 * 60_000L // меньше 5-минутного таймаута

fun onScanStarted() {
handler.removeCallbacks(restartTask)
handler.postDelayed(restartTask, RESTART_PERIOD_MS)
}

val restartTask = Runnable { restart() } // stopScan() + requestStart()

На тестовой реализации этого подхода провала на пятой минуте больше нет:

Без перезапуска, после 5-й минуты

С перезапуском раз в 4 минуты

Экран вкл, обнаружений/мин

~10

92

Экран выкл, обнаружений/мин

2-6

48

Ваш BLE-скан на Android тихо умирает через 5 минут. И вы об этом не знаете - 4

Цена. Радио дольше работает в активном режиме, а значит, расход батареи выше, чем с пониженным сканом. Каждый перезапуск — короткая пауза в потоке (в тесте максимум 3,4 с при включённом экране) и один старт из квоты, но раз в 4 минуты это незаметно. Расход батареи мы отдельно не мерили.

Скан без фильтра и пустой фильтр

При выключенном экране сканирование без фильтра или с пустым фильтром приостанавливается.

Как мы это исправили? Добавили фильтры под все форматы маяков, которые разбирает наш парсер. Фильтры в списке работают как «или»: пакет проходит, если подошёл хотя бы под один. Опционально, когда локация загружена и известны UUID её маяков, фильтр iBeacon можно сузить до них.

fun filters(): List<ScanFilter> = listOf(
// iBeacon: Apple (0×004C), префикс 02 15
ScanFilter.Builder()
.setManufacturerData(0×004C, byteArrayOf(0×02, 0×15), byteArrayOf(-1, −1)).build(),
// iBecom
ScanFilter.Builder().setManufacturerData(0×0059, byteArrayOf()).build(),
// Eddystone
ScanFilter.Builder().setServiceData(ParcelUuid.fromString("0000FEAA-0000-1000-8000-00805F9B34FB"), byteArrayOf()).build(),
// Kontakt.io
ScanFilter.Builder().setServiceData(ParcelUuid.fromString("0000FE6A-0000-1000-8000-00805F9B34FB«), byteArrayOf()).build(),
)

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

Квота стартов и молчаливый отказ

Система не позволяет делать больше 5 вызовов startScan за 30 секунд, шестой система отклоняет.

Как мы это исправили? Раньше старты шли из нескольких мест в коде, и не все из них учитывали лимит. Теперь любой запуск — плановый перезапуск, смена режима, watchdog, включение Bluetooth — идёт через один счётчик. Если лимит выбран, старт откладывается до момента, когда самый старый старт выйдет из 30-секундного окна, плюс небольшой запас. Если за это время пришли ещё запросы, выполняется только последний.

class StartQuota(val max: Int = 5, val windowMs: Long = 30_000) {
private val starts = ArrayDeque<Long>()
private var pending: (() -> Unit)? = null

fun runWhenAllowed(start: () -> Unit) {
val now = SystemClock.elapsedRealtime()
starts.removeAll { now — it > windowMs }
if (starts.size < max) {
starts.addLast(now)
start()
} else {
val firstScheduling = pending == null
pending = start // старые запросы заменяем последним
if (firstScheduling) {
val delay = starts.first() + windowMs — now + 2_000
handler.postDelayed({ pending?.let { pending = null; runWhenAllowed(it) } }, delay)
}
}
}
}

Цена. В худшем случае скан стартует с задержкой до ~30 секунд. Лимит система считает на всё приложение, поэтому если в нём сканирует кто-то ещё, наш счётчик может не совпасть с системным. Для этого нужен следующий пункт.

Молчаливый отказ при превышении квоты

Если система отклонила старт, то onScanFailed может не прийти. Приложение считает, что скан идёт, а результатов нет.

Как мы это исправили? Добавили watchdog. Он запоминает время последнего результата и, если тишина длится дольше порога, перезапускает скан через тот же счётчик квоты. Так watchdog сам не сможет упереться в лимит.

const val SILENCE_MS = 60_000L
var lastResultAt = 0L

fun onScanResult(result: ScanResult) {
lastResultAt = SystemClock.elapsedRealtime()
deliver(result)
}

val watchdogTask = object : Runnable {
override fun run() {
if (SystemClock.elapsedRealtime() - lastResultAt > SILENCE_MS) restart()
handler.postDelayed(this, SILENCE_MS)
}
}

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

Смерть процесса и смахивание из «Недавних»

Система может убить процесс при нехватке памяти или, начиная с Android 17, по лимиту памяти на приложение.

Как мы это исправили? Сервис возвращает START_STICKY, и система перезапускает его сама. Здесь мы поймали подводный камень. В старой версии скан запускался по событиям ON_START и ON_STOP от ProcessLifecycleOwner. Если процесс поднимался без интерфейса (а именно так и происходит при рестарте через START_STICKY) — эти события не приходили, и скан не стартовал до тех пор, пока пользователь не откроет приложение. Теперь скан стартует сразу, а режим выбирается по текущему состоянию приложения. События жизненного цикла нужны только для смены режима.

class ScanService : Service() {
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
startForeground(NOTIFICATION_ID, notification, FOREGROUND_SERVICE_TYPE_LOCATION)
scanController.start() // и при первом запуске, и после перезапуска (intent == null)
return START_STICKY
}
}

fun BleScanController.start() {
val visible = ProcessLifecycleOwner.get().lifecycle.currentState.isAtLeast(STARTED)
mode = if (visible) FOREGROUND else BACKGROUND
requestStart() // не ждём ON_START / ON_STOP
}

На тесте с kill −9 система перезапустила сервис за 1,7 с, первое обнаружение пришло через 2,1 с.

Цена. START_STICKY — не панацея. Система может увеличить паузу между перезапусками при повторных падениях, а часть систем и вовсе не поднимет сервис без разрешения на автозапуск.

Фоновые ограничения процесса

Без Foreground Service фоновый процесс рано или поздно останавливается. А с Android 12 сам сервис нельзя запустить из фона.

Как мы это исправили? Запускаем Foreground Service с типом location, пока приложение открыто. Дальше сервис живёт сам и переживает сворачивание и смахивание из «Недавних». При тестах на устройстве пауза в потоке после смахивания составила 0,3 с.

// в activity, пока приложение на экране
if (hasScanPermissions()) {
ContextCompat.startForegroundService(this, Intent(this, ScanService::class.java))
}

Цена. На Android 13+ вам необходимо запросить рантайм разрешение, вдобавок, далеко не каждому пользователю нравится видеть постоянное уведомление в шторке.

Режим скана в фоне понижается

Фоновое приложение система переводит в экономные режимы. Раньше мы и на своей стороне переключались в фоне на LOW_POWER, а это около 10 обнаружений в минуту при включённом экране и около 6 при выключенном.

Как мы это исправили? Пока работает Foreground Service, система сохраняет LOW_LATENCY и в фоне, если скан с фильтром. Поэтому мы добавили флаг, который оставляет LOW_LATENCY после сворачивания. Конечно, скорости как на включенном экране всё равно не будет: при тестах контроллер в этом случае слушает эфир около 52% времени и даёт около 48 обнаружений в минуту вместо 90. Это цена за стабильную работу.

fun settings(mode: Mode): ScanSettings = ScanSettings.Builder()
.setScanMode(
if (mode == FOREGROUND || config.lowLatencyInBackground) SCAN_MODE_LOW_LATENCY
else SCAN_MODE_LOW_POWER
)
.build()

Цена. Самая дорогая для батареи часть схемы: радио работает почти постоянно. Именно поэтому это опция, а не поведение по умолчанию: если позиция нужна раз в несколько секунд, хватит и LOW_POWER.

WorkManager и JobScheduler не чаще раза в 15 минут

Периодические задачи запускаются не чаще раза в 15 минут, а с Android 16 на них действуют квоты даже при запущенном сервисе. Для нашей задачи такое решение не подходит.

Как мы это исправили? Сам скан идёт только в сервисе. Периодическая задача раз в 15 минут проверяет, жив ли сервис и давно ли был последний результат. Если сервис умер, она пытается его поднять, а если система не даёт запустить сервис из фона — включает PendingIntent-скан как запасной вариант.

class ScanGuardWorker(ctx: Context, params: WorkerParameters) : Worker(ctx, params) {
override fun doWork(): Result {
if (ScanService.isAliveAndReceiving()) return Result.success()
try {
ContextCompat.startForegroundService(applicationContext, Intent(applicationContext, ScanService::class.java))
} catch (e: ForegroundServiceStartNotAllowedException) {
startPendingIntentScan(applicationContext) // запасной вариант
}
return Result.success()
}
}

// регистрация
WorkManager.getInstance(ctx).enqueueUniquePeriodicWork(
«scan-guard», ExistingPeriodicWorkPolicy.KEEP,
PeriodicWorkRequestBuilder<ScanGuardWorker>(15, TimeUnit.MINUTES).build()
)

Цена. Пауза до 15 минут, прежде чем страховка сработает, а в Doze mode может быть еще дольше. Запустить Foreground Service из фона на Android 12+ можно только в отдельных случаях, например если приложение исключено из оптимизации батареи или пришёл высокоприоритетный пуш. В остальных же случаях будет выброшено ForegroundServiceStartNotAllowedException. PendingIntent-скан в фоне система тоже понижает, так что это именно страховка, а не замена сервису.

Doze, standby bucket, настройки батареи и разрешения

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

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

Standby bucket. Пока работает Foreground Service, приложение считается активным. Но если сервис упал, а приложение давно не открывали, система переведёт его в более строгую группу — RESTRICTED (Android 12+) и наша страховка через worker будет запускаться редко. Группу можно проверить через UsageStatsManager.getAppStandbyBucket().

Оптимизация батареи. Приложение, исключённое из оптимизации, меньше страдает от Doze и может запускать Foreground Service из фона. Проверить это можно методом isIgnoringBatteryOptimizations() и, если нужно, открыть пользователю настройки. Прямой запрос REQUEST_IGNORE_BATTERY_OPTIMIZATIONS Google Play разрешает только приложениям, для которых Doze Mode и App Standby полностью ломают базовую функцию приложения. Для прошивок с собственными настройками («Никогда не усыплять» у Samsung, автозапуск у Xiaomi) лучше показать настройки по производителю.

Разрешения и состояние устройства. Перед стартом проверяем всё, что может молча остановить скан, и сообщаем приложению, что именно не так. Выключение и включение Bluetooth ловим через ACTION_STATE_CHANGED и перезапускаем скан через счётчик квоты.

fun diagnose(ctx: Context): List<Problem> = buildList {
if (!bluetoothEnabled()) add(BLUETOOTH_OFF)
if (SDK_INT >= 31 && !granted(BLUETOOTH_SCAN)) add(NO_BLUETOOTH_SCAN)
if (!granted(ACCESS_FINE_LOCATION)) add(NO_FINE_LOCATION)
if (!granted(ACCESS_BACKGROUND_LOCATION)) add(NO_BACKGROUND_LOCATION)
if (!locationServicesEnabled()) add(LOCATION_OFF)
if (SDK_INT >= 33 && !granted(POST_NOTIFICATIONS)) add(NO_NOTIFICATIONS)
if (!powerManager.isIgnoringBatteryOptimizations(ctx.packageName)) add(BATTERY_OPTIMIZED)
if (usageStats.appStandbyBucket >= STANDBY_BUCKET_RARE) add(STANDBY_RESTRICTED)
}

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

Итого

Безусловно, всё описанное — не абсолютная гарантия того, что сканирование будет работать идеально. С каждой новой версией Android и каждой новой прошивкой приходится искать всё более изощрённые способы ужиться с ограничениями. Тот же таймаут скана задаётся серверной настройкой и может поменяться без обновления системы, а Bluetooth-модуль с Android 16 обновляется отдельно от прошивки.

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

На нашем телефоне главной проблемой оказался таймаут длительного скана: через 5 минут система понижает режим, и обнаружений становится в 5-10 раз меньше. Приложение об этом не узнаёт: скан формально работает, колбэки приходят, просто редко.

Если коротко, для надёжного фонового сканирования нужно четыре вещи:

  1. Настоящий фильтр по формату маяка. Пустой фильтр при выключенном экране не работает.

  2. Перезапуск скана раньше таймаута, через единый счётчик стартов, чтобы не упереться в лимит.

  3. Контроль потока результатов. На onScanFailed полагаться нельзя, если результатов долго нет — перезапускаем скан.

  4. Foreground Service, который поднимает скан сразу после перезапуска процесса, не дожидаясь открытия интерфейса.

Прежде чем выбирать интервалы, проверьте, сколько длится таймаут на ваших устройствах:

adb shell device_config get bluetooth scan_timeout_millis

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

Большое спасибо за прочтение, и всем хорошего кода!

Автор: 9_hamden

Источник

* - обязательные к заполнению поля


https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js