iOS SDK setup

// FILE: OneSignalNotificationServiceExtension/NotificationService.swift
// PURPOSE: Enables rich notifications (images) and confirmed receipt analytics
// REQUIREMENT: This extension must share an App Group with the main app target (configured in next steps)
// WHEN IT RUNS: iOS calls this extension when a push has "mutable-content": true
//               (automatically set when you include images or action buttons)

import UserNotifications
import OneSignalExtension

class NotificationService: UNNotificationServiceExtension {
    
    // Callback to deliver the modified notification to iOS
    var contentHandler: ((UNNotificationContent) -> Void)?
    
    // The original push request from APNs
    var receivedRequest: UNNotificationRequest!
    
    // A mutable copy of the notification we can modify (add images, etc.)
    var bestAttemptContent: UNMutableNotificationContent?

    // Called when a push notification arrives with mutable-content: true
    // You have ~30 seconds to modify the notification before iOS displays it
    override func didReceive(_ request: UNNotificationRequest, withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
        self.receivedRequest = request
        self.contentHandler = contentHandler
        self.bestAttemptContent = (request.content.mutableCopy() as? UNMutableNotificationContent)

        if let bestAttemptContent = bestAttemptContent {
            // DEBUGGING: Uncomment to verify NSE is running
            // bestAttemptContent.body = "[Modified] " + bestAttemptContent.body

            // OneSignal processes the notification:
            // - Downloads and attaches images
            // - Reports confirmed receipt to dashboard
            // - Handles action buttons
            OneSignalExtension.didReceiveNotificationExtensionRequest(self.receivedRequest, with: bestAttemptContent, withContentHandler: self.contentHandler)
        }
    }

    // Called if didReceive() takes too long (~30 seconds)
    // Delivers whatever content we have so the notification isn't lost
    override func serviceExtensionTimeWillExpire() {
        if let contentHandler = contentHandler, let bestAttemptContent = bestAttemptContent {
            OneSignalExtension.serviceExtensionTimeWillExpireRequest(self.receivedRequest, with: self.bestAttemptContent)
            contentHandler(bestAttemptContent)
        }
    }
}

// FILE: OneSignalNotificationServiceExtension/NotificationService.m
// PURPOSE: Enables rich notifications (images) and confirmed receipt analytics
// REQUIREMENT: This extension must share an App Group with the main app target (configured in next steps)
// WHEN IT RUNS: iOS calls this extension when a push has "mutable-content": true
//               (automatically set when you include images or action buttons)

#import <OneSignalExtension/OneSignalExtension.h>
#import "NotificationService.h"

@interface NotificationService ()

@property (nonatomic, strong) void (^contentHandler)(UNNotificationContent *contentToDeliver); // Callback to deliver modified notification
@property (nonatomic, strong) UNNotificationRequest *receivedRequest;                          // Original push request from APNs
@property (nonatomic, strong) UNMutableNotificationContent *bestAttemptContent;                // Mutable copy we can modify

@end

@implementation NotificationService

// Called when a push arrives with mutable-content: true
// You have ~30 seconds to modify the notification before iOS displays it
- (void)didReceiveNotificationRequest:(UNNotificationRequest *)request
                   withContentHandler:(void (^)(UNNotificationContent * _Nonnull))contentHandler {
    
    self.receivedRequest = request;
    self.contentHandler = contentHandler;
    self.bestAttemptContent = [request.content mutableCopy];

    // DEBUGGING: Uncomment to verify NSE is running
    // NSLog(@"Running NotificationServiceExtension");
    // self.bestAttemptContent.body = [@"[Modified] " stringByAppendingString:self.bestAttemptContent.body];

    // OneSignal downloads images, reports confirmed receipt, handles action buttons
    [OneSignalExtension didReceiveNotificationExtensionRequest:self.receivedRequest
                                withMutableNotificationContent:self.bestAttemptContent
                                            withContentHandler:self.contentHandler];
}

// Called if didReceiveNotificationRequest() takes too long (~30 seconds)
// Delivers whatever content we have so the notification isn't lost
- (void)serviceExtensionTimeWillExpire {
    [OneSignalExtension serviceExtensionTimeWillExpireRequest:self.receivedRequest
                                   withMutableNotificationContent:self.bestAttemptContent];
    self.contentHandler(self.bestAttemptContent);
}

@end

// In application(_:didFinishLaunchingWithOptions:), BEFORE OneSignal.initialize()
UNUserNotificationCenter.current().delegate = self

// In application:didFinishLaunchingWithOptions:, BEFORE [OneSignal initialize:]
[UNUserNotificationCenter currentNotificationCenter].delegate = self;

func application(_ application: UIApplication,
                 didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    OneSignal.Notifications.didRegisterForRemoteNotifications(deviceToken: deviceToken)
}

func application(_ application: UIApplication,
                 didFailToRegisterForRemoteNotificationsWithError error: Error) {
    OneSignal.Notifications.didFailToRegisterForRemoteNotifications(error: error as NSError)
}

- (void)application:(UIApplication *)application
    didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
    [OneSignal.Notifications didRegisterForRemoteNotificationsWithDeviceToken:deviceToken];
}

- (void)application:(UIApplication *)application
    didFailToRegisterForRemoteNotificationsWithError:(NSError *)error {
    [OneSignal.Notifications didFailToRegisterForRemoteNotificationsWithError:error];
}

func application(_ application: UIApplication,
                 didReceiveRemoteNotification userInfo: [AnyHashable: Any],
                 fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
    OneSignal.Notifications.didReceiveRemoteNotification(userInfo: userInfo,
                                                        completionHandler: completionHandler)
}

- (void)application:(UIApplication *)application
    didReceiveRemoteNotification:(NSDictionary *)userInfo
    fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
    [OneSignal.Notifications didReceiveRemoteNotification:userInfo
                                        completionHandler:completionHandler];
}

func userNotificationCenter(_ center: UNUserNotificationCenter,
                            willPresent notification: UNNotification,
                            withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
    OneSignal.Notifications.willPresentNotification(
        payload: notification.request.content.userInfo
    ) { notif in
        if notif != nil {
            if #available(iOS 14.0, *) {
                completionHandler([.banner, .list, .sound])
            } else {
                completionHandler([.alert, .sound])
            }
        } else {
            completionHandler([])
        }
    }
}

- (void)userNotificationCenter:(UNUserNotificationCenter *)center
       willPresentNotification:(UNNotification *)notification
         withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler {
    [OneSignal.Notifications
        willPresentNotificationWithPayload:notification.request.content.userInfo
        completion:^(OSNotification *notif) {
            if (notif) {
                if (@available(iOS 14.0, *)) {
                    completionHandler(UNNotificationPresentationOptionBanner |
                                      UNNotificationPresentationOptionList |
                                      UNNotificationPresentationOptionSound);
                } else {
                    completionHandler(UNNotificationPresentationOptionAlert |
                                      UNNotificationPresentationOptionSound);
                }
            } else {
                completionHandler(UNNotificationPresentationOptionNone);
            }
        }];
}

func userNotificationCenter(_ center: UNUserNotificationCenter,
                            didReceive response: UNNotificationResponse,
                            withCompletionHandler completionHandler: @escaping () -> Void) {
    OneSignal.Notifications.didReceiveNotificationResponse(response)
    completionHandler()
}

- (void)userNotificationCenter:(UNUserNotificationCenter *)center
    didReceiveNotificationResponse:(UNNotificationResponse *)response
             withCompletionHandler:(void (^)(void))completionHandler {
    [OneSignal.Notifications didReceiveNotificationResponse:response];
    completionHandler();
}

OneSignal.Notifications.setBadgeCount(5)

[OneSignal.Notifications setBadgeCount:5];