Привет, Хабр! Я Юра Бучин, iOS Developer команды Anticrisis Core в Т-Банке. Расскажу как мы построили альтернативный канал коммуникации с клиентом Apple Push Notification service (APNs).

APNs — основной канал коммуникации с пользователем, когда приложение не активно. В ситуациях, когда канал становится недоступным из-за санкций, наложенных на приложение, на помощь приходят локальные push-уведомления.

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

В статье разберем:

  • чем локальные пуши отличаются от remote и когда их стоит использовать;

  • как их планировать, отслеживать и удалять;

  • как организовать статусную модель взаимодействия, чтобы не терять пуши;

  • как использовать Background Tasks для планирования в фоне;

  • грабли, на которые мы наступили.

Мотивация

A penny saved is a penny got. (Бенджамин Франклин)

«Сэкономил — считай, заработал». (My perfect simple English)

Push-уведомления — основной инструмент коммуникации с пользователем вне приложения. В штатном режиме для этого используются remote-пуши через APNs. Они надежны, доставляются оперативно, и работу с ними достаточно легко настроить.

Если APNs становится недоступен для приложения, можно рассмотреть альтернативы. Собрал их в таблице.

СМС

Local Push

Инфраструктура

Нужен шлюз, договор с оператором

Не нужна со стороны Apple, сервер для отправки заданий — по желанию

Стоимость

Высокая (за каждое сообщение)

Бесплатно (канал доставки)

Доработка клиента

Не требуется

Требуется

Real-time

Да (с задержками)

Нет (планируется заранее)

Зависимость от ОС

Нет

Да (только для iOS)

Охват

Любой телефон

Только ваше приложение

СМС полноценной альтернативой назвать сложно. Это дорого, не мгновенно, и пользователь может воспринять СМС как спам. Но такой способ не требует доработки приложения и работает на любом устройстве.

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

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

Планирование локального пуша

Перед тем как планировать локальные пуши, нужно получить разрешение пользователя. Механизм тот же, что и для remote:

UNUserNotificationCenter.current().requestAuthorization(options: [
                                            .alert, .sound, .badge]) { granted, error in
    if let error = error {
        // Обработать ошибку
        return
    }

    if granted {
        // Можно планировать пуши
    }
}

Разрешение запрашивается один раз. Пользователь может изменить его позже в настройках системы. Подробнее о методе можно прочитать в документации Apple Developer Documentation: requestAuthorization.

Запрос от операционной системы разрешения на отправку нотификаций приложением.
Запрос от операционной системы разрешения на отправку нотификаций приложением.

Чтобы запланировать локальный пуш, нужно создать UNNotificationRequest и добавить его в UNUserNotificationCenter. Подробнее почитать о методах можно на сайте Apple UNNotificationRequest, add(_:).

import UserNotifications
 
// 1. Создаем контент
let content = UNMutableNotificationContent()
content.title = "Hello Everyone"
content.body = "Статья про Local Push"
content.sound = .default
 
// 2. Создаем триггер (время, календарь или геолокацию)
let trigger = UNTimeIntervalNotificationTrigger(
    timeInterval: 10,   // через 10 секунд
    repeats: false  	// без повтора
)
 
// 3. Создаем запрос
let identifier = UUID().uuidString
let request = UNNotificationRequest(
    identifier: identifier,
    content: content,
    trigger: trigger
)
 
// 4. Добавляем в центр уведомлений
UNUserNotificationCenter.current().add(request) { error in
    if let error = error {
        // Обработать ошибку
    }
}

API iOS предоставляет три типа триггеров.

Триггер

Описание

Пример использования

UNTimeIntervalNotificationTrigger

Через заданный интервал времени

Напомнить через час

UNCalendarNotificationTrigger

В конкретные дату и время

Ежедневный отчет в 09:00

UNLocationNotificationTrigger

При входе/выходе из геозоны

Напомнить о покупке при входе в магазин

На каждое приложение действуют ограничения:

  • 64 — максимальное количество запланированных локальных пушей с разными триггерами;

  • 20 — максимум пушей с триггером UNLocationNotificationTrigger.

Неинтуитивная логика срабатывает при превышении лимитов: система оставляет 64 пуша с ближайшими датами срабатывания, остальные молча отбрасываются. Но, если упереться в лимит для пушей с триггером UNLocationNotificationTrigger, 21 добавляемый пуш с этим триггером будет просто проигнорирован при добавлении и в очереди планирования останутся 20 ранее запланированных пушей. Ни в том ни другом случае не приходит ошибки в add callback, так что стоит контролировать количество запланированных пушей самостоятельно.

Как понять, что пуш показался

С remote-пушами все просто: Notification Service Extension (NSE) получает управление перед показом. С локальными пушами NSE не отрабатывает. Остается только опрашивать систему через UNUserNotificationCenter. Предлагаю ввести терминологию очередей пушей (локальных и ремоут) в системе.

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

let notificationCenter = UNUserNotificationCenter.current()
 
// Получить запланированные, но еще не доставленные пуши
notificationCenter.getPendingNotificationRequests { requests in
    for request in requests {
        print("Ожидает: \(request.identifier), триггер: \(request.trigger.debugDescription)")
    }
}

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

let notificationCenter = UNUserNotificationCenter.current()

// Получить доставленные пуши (те, что висят в Центре уведомлений)
notificationCenter.getDeliveredNotifications { notifications in
    for notification in notifications {
        print("Доставлен: \(notification.request.identifier)")
    }
}

Сравнивая содержимое этих очередей, можно понять, какие пуши уже показаны, а какие еще в очереди.

Для локальных геопушей нужен еще запрос разрешения на отслеживание геолокации в значении While Using, иначе такие пуши не будут показываться при соблюдении условий срабатывания триггера UNLocationNotificationTrigger.

Запрос от операционной системы разрешения на отслеживание геолокации пользователя приложением.
Запрос от операционной системы разрешения на отслеживание геолокации пользователя приложением.

Пуши с триггером UNLocationNotificationTrigger не попадают в getDeliveredNotifications. Система доставляет их, но в очереди доставленных они не отображаются.

Как отследить доставку такого пуша:

  1. По пропаже из pending. Если пуш с геотриггером был в статусе planned и пропал из getPendingNotificationRequests, значит, он доставлен. Переводим в delivered. Это работает, только если мы полностью контролируем добавление и удаление пушей из очереди.

  2. Core Location. Можно отслеживать вход и выход из геозоны самостоятельно и сверять с запланированными пушами. В статье этот способ подробно рассматривать не будем.

Можно триггерить геопуш на симуляторе. Для этого нужно указать его координату через меню Features → Location → Custom Location.

Ввод координаты в Simulator
Выбор меню Features → Location в тулбаре приложения Simulator.
Выбор меню Features → Location в тулбаре приложения Simulator.
Выбор меню Custom Location.
Выбор меню Custom Location.
Ввод координат в Custom Location.
Ввод координат в Custom Location.

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

Как понять, что пользователь взаимодействовал с локальным пушем

Если пользователь смахнул доставленный пуш из Центра уведомлений, система никак не предупредит об этом приложение. Пуш просто исчезает из getDeliveredNotifications.

При тапе на локальный пуш система обрабатывает его через те же методы UNUserNotificationCenterDelegate, что и remote-пуши:

func userNotificationCenter(
    _ center: UNUserNotificationCenter,
    didReceive response: UNNotificationResponse,
    withCompletionHandler completionHandler: @escaping () -> Void
) {
    let isLocalPush = response.notification.request.content.userInfo["isLocalPush"] as? Bool ?? false

    // ...обработка

    completionHandler()
}

Так как локальные и remote-пуши приходят в один и тот же делегат, нужно заранее предусмотреть способ их различать. Проще всего добавить флаг в userInfo:

content.userInfo = ["isLocalPush": true]

Тогда при обработке всегда можно понять, откуда пришел пуш.

Как удалять локальные пуши

Локальные пуши можно удалять из обеих очередей. Изучить документацию о методах для удаления локальных пушей можно на сайте Apple:

let center = UNUserNotificationCenter.current()

// Удалить из запланированных
center.removePendingNotificationRequests(withIdentifiers: ["id1", "id2"])

// Удалить из доставленных
center.removeDeliveredNotifications(withIdentifiers: ["id1", "id2"])

Есть методы для удаления всех пушей сразу (removeAllPendingNotificationRequests, removeAllDeliveredNotifications), но в контексте локальных пушей они опасны: могут удалить и remote-пуши, которые система тоже хранит в этих очередях.

Ограничение: пуши с UNLocationNotificationTrigger нельзя удалить из очереди доставленных — метод removeDeliveredNotifications на них не действует.

Статусная модель

Система не сообщает приложению о некоторых событиях:

  • пользователь смахнул пуш — нет колбэка;

  • геопуш доставлен — не попадает в getDeliveredNotifications;

  • пуш заменен другим — старая запись просто исчезает.

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

Для обычных пушей (TimeInterval, Calendar):

failure

planned ──► delivered ──► read
  │              │
  ├──► skipped   └──► deleted
  ├──► displaced
  └──► deleted

Для геопушей (Location):

failure

planned ──► delivered ──► read
  │
  └──► displaced
  └──► deleted

Статусы skipped и delivered → deleted для геопушей не используются: skipped — потому, что мы не можем отличить «не доставлен» от «доставлен, но не виден в delivered», delivered → deleted — потому, что геопуши нельзя удалить из очереди доставленных.

Описание статусов:

  • planned — пуш запланирован, ждет доставки. Можно получить информацию о пуше при вызове getPendingNotificationRequests.

  • delivered — пуш доставлен. Появился в Центре уведомлений или пропал из очереди планирования для гео.

  • read — пользователь тапнул по пушу.

  • failure — ошибка при вызове add(_:), пуш не был запланирован.

  • skipped — пуш не вернулся при вызове getDeliveredNotifications (только для обычных пушей).

  • displaced — пуш был вытеснен другим при планировании из-за превышения лимитов (64 — обычные, 20 — гео).

  • deleted — пуш был удален через API.

Пример реализации:

enum LocalPushStatus: String, Codable {
    case planned
    case delivered
    case read
    case skipped
    case displaced
    case deleted
    case failure
}

struct LocalPushEvent: Codable {
    let identifier: String
    let status: LocalPushStatus
}

Для хранения статусов можно использовать любое персистентное хранилище и организовывать работу с ним с помощью CoreData, SwiftData, Realm или просто UserDefaults для простых случаев. Главное — сохранять историю переходов, чтобы можно было восстановить картину.

Алгоритм перехода статусов локального пуша: 

  1. При планировании пуша создаем запись со статусом planned. Если при планировании уперлись в лимиты у вытесненного или недобавленного пуша, ставим статус displaced.

  2. Периодически в фоне или при входе в приложение опрашиваем getDeliveredNotifications и getPendingNotificationRequests.

  3. Сверяем с сохраненными статусами. Если пуш был planned и появился в delivered → delivered (для обычных). Если пуш был planned (гео) и пропал из pending → delivered. Если пуш был planned (обычный) и не появился в delivered в ожидаемый срок → skipped. Если пуш был delivered и пропал из delivered → skipped (смахнули).

  4. При тапе через делегат → read.

  5. При удалении → deleted.

Background Tasks

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

Когда приложение активно, проблем нет: инициировали запрос, получили данные, запланировали пуши. Но, когда приложение в фоне, на помощь приходят Background Tasks.

BackgroundTasks — фреймворк, который позволяет приложению регистрировать задачи для выполнения в фоновом режиме. Система сама решает, когда запустить задачу, исходя из расписания, состояния батареи и других факторов. Подробнее — в документации по BackgroundTasks: Apple Developer Documentation: Background Tasks.

Для настройки BackgroundTasks в приложении нужно добавить данные в Info.plist.

<key>UIBackgroundModes</key>
<array>
    <string>fetch</string>
    <string>processing</string>
</array>
<key>BGTaskSchedulerPermittedIdentifiers</key>
<array>
    <string>LocalPush.refresh</string>
    <string>LocalPush.processing_power</string>
    <string>LocalPush.processing_notpower</string>
</array>

В BGTaskSchedulerPermittedIdentifiers нужно добавить идентификаторы для фоновых задач. Каждый тип задачи — свой уникальный идентификатор.

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

  • refresh — будем использовать идентификатор для регистрации и планирования refresh-задачи;

  • processing_power — будем использовать идентификатор для регистрации и планирования processing-задачи, которой для запуска нужно подключение к питанию;

  • processing_notpower — будем использовать идентификатор для регистрации и планирования processing-задачи, которой для запуска не обязательно нужно подключение к питанию.

Регистрировать задачи нужно при запуске приложения, например в AppDelegate.application(_:didFinishLaunchingWithOptions:).

func registerBGTaskHandlers() {
	BGTaskScheduler.shared.register(
      forTaskWithIdentifier: "LocalPush.refresh", 
      using: nil
    ) { task in
	    self.handleAppRefresh(task: task as! BGAppRefreshTask)
	}
  
	BGTaskScheduler.shared.register(
      forTaskWithIdentifier: "LocalPush.processing_power", 
      using: nil
    ) { task in 
        self.handleProcessingTask(task: task as! BGProcessingTask)
    }
  
    BGTaskScheduler.shared.register(
      forTaskWithIdentifier: "LocalPush.processing_notpower", 
      using: nil
    ) { task in
        self.handleProcessingTask(task: task as! BGProcessingTask)
    }
}

Наши грабли: на момент реализации приложение падало при попытке регистрации задач с одним и тем же идентификатором несколько раз подряд. Убедитесь, что register(forTaskWithIdentifier:using:handler:) вызывается ровно один раз для каждого идентификатора за жизненный цикл приложения.

После регистрации задачи нужно запланировать.

func scheduleAllTasks() {
    // BGAppRefreshTask — минимальный интервал 15 минут
    let refreshRequest = BGAppRefreshTaskRequest(identifier: "LocalPush.refresh")
    refreshRequest.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60)
     
    // BGProcessingTask — для более тяжелых операций
    let powerRequest = BGProcessingTaskRequest(identifier: "LocalPush.processing_power")
    // Для запуска таски нужен интернет
    powerRequest.requiresNetworkConnectivity = true
    // Требуется подключение телефона к зарядке
    powerRequest.requiresExternalPower = true
     
    let noPowerRequest = BGProcessingTaskRequest(identifier: "LocalPush.processing_notpower")
    // Для запуска таски нужен интернет
    noPowerRequest.requiresNetworkConnectivity = true
    // Не требуется подключение телефона к зарядке
    noPowerRequest.requiresExternalPower = false
    do {
        try BGTaskScheduler.shared.submit(refreshRequest)
        try BGTaskScheduler.shared.submit(powerRequest)
        try BGTaskScheduler.shared.submit(noPowerRequest)
    } catch {
        print("Не удалось запланировать BGTask: \(error)")
    }
}

Важно: планирование задач доступно только на реальном устройстве. Мы используем все три типа тасок для максимизации вероятности получения актуальных локальных пушей для пользователя.

Если сравнивать разные типы в разрезе количества запусков, тут фаворитом будет BGAppRefreshTaskRequest.

Количество запусков BGAppRefreshTaskRequest взято за единицу, а другие типы — это соотношение <Количество планирований BGProcessingTaskRequest> / <Количество планирований BGAppRefreshTaskRequest>
Количество запусков BGAppRefreshTaskRequest взято за единицу, а другие типы — это соотношение <Количество планирований BGProcessingTaskRequest> / <Количество планирований BGAppRefreshTaskRequest>

После планирования BGTask выполняется системой в фоне. Время работы ограничено:

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

Ждать, пока система решит запустить фоновую задачу, неудобно. Есть два способа запустить ее вручную.

Способ 1: через LLDB. Описан в документации Apple: Starting and Terminating Tasks During Development:

  1. Устанавливаем breakpoint в коде, который выполняется после успешного вызова submit(_:).

  2. Запускаем приложение на устройстве до срабатывания точки останова.

  3. В LLDB выполняем: e -l objc -- (void)[[BGTaskScheduler sharedScheduler] _simulateLaunchForTaskWithIdentifier:@"LocalPush.refresh"].

  4. Возобновляем выполнение — система вызовет обработчик задачи.

Способ 2: из кода (приватный API). Есть возможность вызвать приватный API из кода. Для этого мы делаем инстанс селектора по строке NSSelectorFromString("_simulateLaunchForTaskWithIdentifier:") и исполняем его на инстансе BGTaskScheduler.

func simulateBGTask(identifier: String) {
    let selector = NSSelectorFromString("_simulateLaunchForTaskWithIdentifier:")
    BGTaskScheduler.shared.perform(selector, with: identifier)
}

Этот способ использует приватный API, поэтому не должен попадать в релизную сборку. Обернем в #if DEBUG:

#if DEBUG

    simulateBGTask(identifier: "LocalPush.refresh")

#endif

Можно добавить этот код в дебаг меню приложения и при тестировании триггерить запуск нужной Background-таски.

Заключение

Соберем в таблицу все неочевидные моменты, с которыми столкнулись. Теперь все ограничения и грабли будут в одном месте.

№

Проблема

Описание

1

Геопуши не в delivered

UNLocationNotificationTrigger не попадает в getDeliveredNotifications

2

Геопуши не удаляются

removeDeliveredNotifications не действует на пуши с геотриггером

3

Смахивание без колбэка

Система не сообщает приложению, что пользователь смахнул пуш

4

Падение при повторной регистрации BGTask

register(forTaskWithIdentifier:...) с одним идентификатором дважды — crash

5

BGTask только на устройстве

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

6

NSE не работает для локальных

Notification Service Extension не вызывается для локальных пушей

7

Лимиты без ошибок

При превышении лимита 64⁄20 пуша система молча игнорирует добавление новых пушей в очередь

8

Одно пространство для local и remote

getDeliveredNotifications и getPendingNotificationRequests возвращают и local, и remote-пуши вместе

Локальные пуши — дополнение для ситуаций, когда основной канал недоступен. Канал доставки бесплатен и не зависит от APNs-инфраструктуры, но, если хочется инициировать пуши с сервера, серверная инфраструктура для отправки заданий клиенту все равно потребуется.

Рекомендую использовать локальные пуши при блокировке или бане приложения, для маркетинговых коммуникаций с отложенным показом или как fallback-канал, если APNs недоступны.

И не рекомендую использовать для real-time-коммуникаций (здесь без APNs не обойтись) или если достаточно remote-пушей и нет риска их потери.

Главные выводы:

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

  2. Background Tasks — единственный способ планировать пуши в фоне, но тестировать их можно только на реальном устройстве.

  3. Геопуши капризные: они не попадают в очередь доставленных пушей, не удаляются из нее и ограничены 20 штуками.

  4. Стоит не забывать помечать локальные пуши, например с помощью добавления флага isLocalPush в userInfo, чтобы отличать локальные пуши от remote.

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