Онлайн курсы по Swift

iOS разработчик с нуля
Кабинет студента

Введение

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

 

1. Регистрируем уведомления

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

Перед использованием любого из UserNotifications API вам нужно добавить следующий оператор импорта в любые Swift файлы, которые обращаются к фреймворку:

 

import UserNotifications

 

Далее, чтобы зарегистрировать приложение для уведомлений, вам необходимо добавить следующий код application(_:didFinishLaunchingWithOptions:) в AppDelegate:

 

let center = UNUserNotificationCenter.current()
let options: UNAuthorizationOptions = [.alert, .badge, .sound]
center.requestAuthorization(options: options) { (granted, error) in
    if granted {
        application.registerForRemoteNotifications()
    }
}

 

Изначально с помощью этого кода мы получаем ссылку на текущий объект UNUserNotificationCenter. Затем мы настраиваем наш UNAuthorizationOptions с возможностью уведомлений, которые мы хотим получать от нашего приложения. Обратите внимание, что здесь вы можете выбрать любую комбинацию параметров — например, просто alert или badge и sound.

Используя оба этих объекта, мы запрашиваем авторизацию для нашего приложения для отображения уведомлений, вызывая метод requestAuthorization(options:completionHandler:) для нашего UNUserNotificationCenter. Блок обработчика завершения кода имеет два переданных в него параметра:

 

  • Значение Bool указывающее, была ли предоставлена ​​авторизация пользователем.
  • Необязательный объект Error, который будет содержать информацию, если по какой-либо причине система не сможет запросить авторизацию для вашего приложения.

 

Вы увидите, что в приведенном выше коде, если авторизация предоставлена ​​пользователем, мы регистрируемся для удаленных уведомлений. Если вы хотите реализовать push-уведомления, эта строка кода обязательна.

Обратите внимание, что регистрация для удаленных уведомлений вызовет тот же обратный вызов метода UIApplication, что и в предыдущих версиях iOS. При успешном будет вызвано: application(_:didRegisterForRemoteNotificationsWithDeviceToken:), а при ошибке application(_:didFailToRegisterForRemoteNotificationsWithError:).

 

2. Уведомления по графику

В этом разделе нашего урока мы полностью сосредоточимся на локальных уведомлениях по графику, с использованием фреймворка UserNotifications. Отправка удаленных push-уведомлений не изменилась из-за введения этого нового фреймворка.

Локальное уведомление перед планированием представлено экземпляром класса UNNotificationRequest. Объекты этого типа состоят из следующих компонентов:

 

  • Идентификатор: уникальная String, которая позволяет отличать отдельные уведомления друг от друга.
  • Контент: объект UNNotificationContent, который содержит всю информацию, необходимую для отображения вашего уведомления, включая название, подзаголовок и значок с количеством уведомлений.
  • Триггер: объект UNNotificationTrigger, который используется системой для определения того, когда ваше уведомление должно быть «отправлено» в ваше приложение.

 

Во-первых, мы рассмотрим различные типы триггеров, которые вы можете настроить для локальных уведомлений. Класс UNNotificationTrigger является абстрактным классом, что означает, что вы никогда не должны создавать его экземпляры напрямую. Вместо этого вы будете использовать доступные подклассы. В настоящее время фреймворк UserNotifications предоставляет три из них:

 

  • UNTimeIntervalNotificationTrigger, который позволяет отправлять уведомление через определенное количество времени после его планирования.
  • UNCalendarNotificationTrigger, который позволяет отправлять уведомление в определенную дату и время, независимо от того, когда оно было запланировано.
  • UNLocationNotificationTrigger, который позволяет отправлять уведомления, когда пользователь входит или выезжает в указанный географический регион.

 

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

 

let timeTrigger = UNTimeIntervalNotificationTrigger(timeInterval: 60.0 * 60.0, repeats: false)
 
var date = DateComponents()
date.hour = 22
let calendarTrigger = UNCalendarNotificationTrigger(dateMatching: date, repeats: true)
 
let center = CLLocationCoordinate2D(latitude: 40.0, longitude: 120.0)
let region = CLCircularRegion(center: center, radius: 500.0, identifier: "Location")
region.notifyOnEntry = true;
region.notifyOnExit = false;
let locationTrigger = UNLocationNotificationTrigger(region: region, repeats: false)

 

С помощью приведенного выше кода были созданы следующие условия триггера:

 

  • timeTrigger сработает через час после запланированного уведомления. Параметр timeInterval переданный в UNTimeIntervalNotificationTrigger, измеряется в секундах.
  • calendarTrigger будет непрерывно запускаться каждый день в 10:00 PM (22:00). Точную дату и время срабатывания триггера можно легко изменить, изменив другие свойства объекта DateComponents, который вы передаете в инициализатор UNCalendarNotificationTrigger.
  • locationTrigger сработает, когда пользователь будет находиться в пределах 500 метров от обозначенной координаты, в данном случае 40°N 120°E. Как вы можете видеть из кода, этот тип триггера может использоваться для любой координаты и/или региона, а также может инициировать уведомление при входе и выходе из региона.

 

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

 

let content = UNMutableNotificationContent()
content.title = "Notification Title"
content.subtitle = "Notification Subtitle"
content.body = "Some notification body information to be displayed."
content.badge = 1
content.sound = UNNotificationSound.default()

 

Наконец, нам просто нужно создать объект UNNotificationRequest и запланировать его. Это можно осуществить с помощью следующего кода:

 

let request = UNNotificationRequest(identifier: "LocalNotification", content: content, trigger: timeTrigger)
UNUserNotificationCenter.current().add(request) { error in
    if let error = error {
        // Do something with error
    } else {
        // Request was added successfully
    }
}

Изначально с помощью этого кода мы создаем объект запроса в инициализатор, передавая идентификатор, объект содержимого и триггер. Затем мы вызываем метод add(_:completionHandler:) для текущего объекта UNUserNotificationCenter и используем обработчик завершения для выполнения алгоритмы на основании того, было ли уведомление запланировано правильно.

 

3. Получение уведомлений

При использовании фреймворка UserNotifications, обработка входящих уведомлений обрабатывается объектом, который вы назначаете в соответствии с протоколом UNUserNotificationCenterDelegate. Это может быть любой объект, и вам не обязательно быть делегировано приложением, как в предыдущих версиях iOS.

Однако важно отметить, что вы должны установить своё поручение до того, как приложение будет полностью запущено. Для iOS приложения это означает, что вы должны назначить свое поручение либо в методе application(_:willFinishLaunchingWithOptions:), либо в application(_:didFinishLaunchingWithOptions:). Настройка делегирования для пользовательских уведомлений выполняется очень легко с помощью следующего кода:

 

UNUserNotificationCenter.current().delegate = delegateObject

Теперь ваш делегат установлен, когда приложение получает уведомление, есть только два метода, о которых вам нужно побеспокоиться. Оба метода передаются объекту UNNotification, который отображает полученное уведомление. Этот объект содержит свойство date, которое сообщает вам, когда было доставлено уведомление, и свойство request, которое является экземпляром класса UNNotificationRequest, упомянутого ранее. Из этого объекта запроса вы можете получить доступ к содержимому уведомления, а также (если необходимо) триггер для уведомления. Этот объект-триггер будет экземпляром одного из подклассов UNNotificationTrigger, упомянутых ранее, или, в случае push-уведомлений, экземпляром класса UNPushNotificationTrigger.

Первый метод, определенный протоколом UNUserNotificationCenterDelegate — это метод userNotificationCenter(_:willPresent:withCompletionHandler:). Он вызывается только тогда, когда ваше приложение запущено на переднем плане и получает уведомление. Отсюда вы можете получить доступ к контенту уведомления и при необходимости показать свой собственный интерфейс вашего приложения. Кроме того, вы можете сообщить системе, показать уведомление с различными параметрами, обычно это тогда, когда приложение не запущено. Доступны следующие варианты:

  • Alert — Оповещение для отображения системного интерфейса для уведомления
  • Sound — Звук для воспроизведения звука, связанного с уведомлением
  • Badge — пузырик-счетчик для редактирования «пузыря» вашего приложения на главном экране пользователя

В следующем коде показана примерная реализация метода userNotificationCenter(_:willPresent:withCompletionHandler:):

 

func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
    let content = notification.request.content
    // Process notification content
     
    completionHandler([.alert, .sound]) // Display notification as regular alert and play sound
}

 

Другим методом, определенным протоколом UNUserNotificationCenterDelegate, является метод userNotificationCenter(_:didReceive:withCompletionHandler:). Этот метод вызывается, когда пользователь взаимодействует с уведомлением для вашего приложения любым способом, в том числе отклоняя его или открывая из него ваше приложение.

Вместо объекта UNNotification, этот метод имеет объект UNNotificationResponse, переданный в него в качестве параметра. Этот объект содержит объект UNNotification, отображающий полученное уведомление. Он также включает свойство actionIdentifier, чтобы определить, как пользователь взаимодействовал с уведомлением. В случае отклонения уведомления или открытия вашего приложения фреймворк UserNotifications предоставит вам постоянные идентификаторы действий для сравнения.

В следующем коде показана примерная реализация метода userNotificationCenter(_:didReceive:withCompletionHandler:):

 

func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
    let actionIdentifier = response.actionIdentifier
     
    switch actionIdentifier {
    case UNNotificationDismissActionIdentifier: // Notification was dismissed by user
        // Do something
        completionHandler()
    case UNNotificationDefaultActionIdentifier: // App was opened from notification
        // Do something
        completionHandler()
    default:
        completionHandler()
    }
}

 

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

 

4. Управление уведомлениями

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

Из-за этого фреймворк UserNotifications предоставляет следующие методы для текущего экземпляра UNUserNotificationCenter для работы с незавершенными локальными уведомлениями и доставки уведомлений, которые еще не обработаны:

 

  • getPendingNotificationRequests(completionHandler:) предоставляет вам массив объектов UNNotificationRequest в обработчике завершения. Этот массив будет содержать все запланированные локальные уведомления, которые ещё не были запущены.
  • removePendingNotificationRequests(withIdentifiers:) удаляет все запланированные локальные уведомления с идентификаторами, содержащимися в массиве String, который вы передаете в качестве параметра.
  • removeAllPendingNotificationRequests удаляет все запланированные локальные уведомления для вашего приложения.
  • getDeliveredNotifications(completionHandler:) предоставляет вам массив объектов UNNotification в обработчике завершения. Этот массив будет содержать все уведомления, которые будут показываться в вашем приложении, которые всё ещё видны в Центре уведомлений пользователя.
  • removeDeliveredNotifications(withIdentifiers:) удаляет все доставленные уведомления с идентификаторами, содержащимися в массиве String, который вы передаёте из Центра уведомлений пользователя.
  • removeAllDeliveredNifications удаляет всё полученные уведомления для вашего приложения.

 

5. Уведомления о пользовательских действиях

Фреймворк UserNotifications также упрощает возможность использовать для вашего приложения пользовательские категории уведомлений и действия.

Во-первых, вам нужно определить пользовательские действия и категории, которые ваше приложение поддерживает, используя классы UNNotificationAction и UNNotificationCategory соответственно. Для действий, в которых вы хотите, чтобы пользователь мог вводить текст, вы можете использовать класс UNTextInputNotificationAction, который является подклассом UNNotificationAction. После определения ваших действий и категорий вам просто нужно вызвать метод setNotificationCategories(_:) для текущего экземпляра UNUserNotificationCenter. Следующий код показывает, как вы могли бы легко записывать ответы и удалять действия для категории уведомления сообщений в своем приложении:

 

let replyAction = UNTextInputNotificationAction(identifier: "com.usernotificationstutorial.reply", title: "Reply", options: [], textInputButtonTitle: "Send", textInputPlaceholder: "Type your message")
let deleteAction = UNNotificationAction(identifier: "com.usernotificationstutorial.delete", title: "Delete", options: [.authenticationRequired, .destructive])
let category = UNNotificationCategory(identifier: "com.usernotificationstutorial.message", actions: [replyAction, deleteAction], intentIdentifiers: [], options: [])
center.setNotificationCategories([category])

 

Затем, когда пользователь использует одно из ваших настраиваемых действий для уведомления, вызывается тот же самый метод userNotificationCenter(_:didReceive:withCompletionHandler:), который мы рассмотрели ранее. В этом случае идентификатор действия передаваемого объекта UNNotificationResponse будет таким же, как и тот, который вы определили для своего действия. Важно также отметить, что если пользователь взаимодействовал с действием уведомления посредством текстового поля, объект ответа, переданный в этот метод, будет иметь тип UNTextInputNotificationResponse.

Следующий код показывает пример реализации этого метода, включая логику для действий, созданных ранее:

 

func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
    let actionIdentifier = response.actionIdentifier
    let content = response.notification.request.content
     
    switch actionIdentifier {
    case UNNotificationDismissActionIdentifier: // Notification was dismissed by user
        // Do something
        completionHandler()
    case UNNotificationDefaultActionIdentifier: // App was opened from notification
        // Do something
        completionHandler()
    case "com.usernotificationstutorial.reply":
        if let textResponse = response as? UNTextInputNotificationResponse {
            let reply = textResponse.userText
            // Send reply message
            completionHandler()
        }
    case "com.usernotificationstutorial.delete":
        // Delete message
        completionHandler()
    default:
        completionHandler()
    }
}

 

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

 

Заключение

Фреймворк UserNotifications предоставляет полностью функциональный и простой в использовании объектно-ориентированный API для работы с локальными и удаленными уведомлениями на iOS, watchOS и tvOS. Это упрощает планирование локальных уведомлений для различных сценариев, а также значительно упрощает весь поток обработки входящих уведомлений и настраиваемых действий.

Пролистать наверх