Configuring push notifications (iOS)

  func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
    FirebaseApp.configure()
   	Messaging.messaging().delegate = self

    if #available(iOS 10, *) {
      UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .badge, .sound]) { (granted, error) in
      if granted {
        DispatchQueue.main.async {
          UIApplication.shared.registerForRemoteNotifications()
        }

        guard let fcmToken = Messaging.messaging().fcmToken else {
          return
        }

        let mobilePushAgreement = true // true or false, should depend on device permissions and customer's agreement in the application

        Client.registerForPush(registrationToken:fcmToken, mobilePushAgreement:mobilePushAgreement, success: { (success) in
          // success
        }) { (error) in
          // failure
        }
      }
    } else {
      let settings = UIUserNotificationSettings(types: [.alert, .badge, .sound], categories: nil)
      application.registerUserNotificationSettings(settings)
    }
  }

  // MARK: - MessagingDelegate

  func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String) {
    if let registrationToken = fcmToken {
      let mobilePushAgreement = true // true or false, should depend on device permissions and customer's agreement in the application

      Client.registerForPush(registrationToken:registrationToken, mobilePushAgreement:mobilePushAgreement, success: { (success) in
        // success
      }) { (error) in
        // failure
      }
    }
  }

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  [FIRApp configure];
  [FIRMessaging messaging].delegate = self;

  if (@available(iOS 10, *)) {
    [UNUserNotificationCenter currentNotificationCenter].delegate = self;
    UNAuthorizationOptions authOptions = (UNAuthorizationOptionAlert | UNAuthorizationOptionSound | UNAuthorizationOptionBadge);
    [[UNUserNotificationCenter currentNotificationCenter] requestAuthorizationWithOptions:authOptions completionHandler:^(BOOL granted, NSError *error) {
      if (granted == YES) {
        [[UIApplication sharedApplication] registerForRemoteNotifications];
      }

      NSString *fcmToken = [FIRMessaging messaging].FCMToken;
      if (fcmToken == nil) {
        return;
      }

      BOOL mobilePushAgreement = YES; // YES or NO, should depend on device permissions and customer's agreement in the application

      [SNRClient registerForPush:fcmToken mobilePushAgreement:mobilePushAgreement success:^(BOOL isSuccess) {
        // success
      } failure:^(NSError *error) {
        // failure
      }];
    }];
} else {
  UIUserNotificationType allNotificationTypes = (UIUserNotificationTypeSound | UIUserNotificationTypeAlert | UIUserNotificationTypeBadge);
  UIUserNotificationSettings *settings = [UIUserNotificationSettings settingsForTypes:allNotificationTypes categories:nil];

  [[UIApplication sharedApplication] registerUserNotificationSettings:settings];
}

#pragma mark - FIRMessagingDelegate

- (void)messaging:(FIRMessaging *)messaging didReceiveRegistrationToken:(NSString *)fcmToken {
  if (fcmToken != nil) {
    BOOL mobilePushAgreement = YES; // YES or NO, should depend on device permissions and customer's agreement in the application

    [SNRClient registerForPush:fcmToken mobilePushAgreement:mobilePushAgreement success:^(BOOL isSuccess) {
      // success
    } failure:^(NSError *error) {
      // failure
    }];
  }
}

// MARK: - SyneriseDelegate

func snr_registerForPushNotificationsIsNeeded() -> Void {
  guard let fcmToken = Messaging.messaging().fcmToken else {
    return
  }

  let mobilePushAgreement = true // true or false, depending to customer's agreement in the application

  Client.registerForPush(registrationToken:fcmToken, mobilePushAgreement:mobilePushAgreement, success: { (success) in
    // success
  }) { (error) in
    // failure
  }
}

#pragma mark - SNRSyneriseDelegate

- (void)SNR_registerForPushNotificationsIsNeeded {
  NSString *fcmToken = [FIRMessaging messaging].FCMToken;

  if (fcmToken == nil) {
    return;
  }

  BOOL mobilePushAgreement = YES; // YES or NO, depending to customer's agreement in the application

  [SNRClient registerForPush:fcmToken mobilePushAgreement:mobilePushAgreement success:^(BOOL isSuccess) {
    // success
  } failure:^(NSError *error) {
    // failure
  }];
}

Synerise.settings.sdk.keychainGroupIdentifier = "YOUR_KEYCHAIN_GROUP_IDENTIFIER"
Synerise.settings.notifications.encryption = true

SNRSynerise.settings.sdk.keychainGroupIdentifier = @"YOUR_KEYCHAIN_GROUP_IDENTIFIER";
SNRSynerise.settings.notifications.encryption = YES;

import UserNotifications
import SyneriseSDK

class NotificationService: UNNotificationServiceExtension {

  var contentHandler: ((UNNotificationContent) -> Void)?
  var bestAttemptContent: UNMutableNotificationContent?

  override func didReceive(_ request: UNNotificationRequest, withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
    self.contentHandler = contentHandler
    self.bestAttemptContent = (request.content.mutableCopy() as? UNMutableNotificationContent)
    
    if let bestAttemptContent = self.bestAttemptContent {
        Synerise.settings.sdk.appGroupIdentifier = "YOUR_APP_GROUP_IDENTIFIER"
        Synerise.settings.sdk.keychainGroupIdentifier = "YOUR_KEYCHAIN_GROUP_IDENTIFIER"
        
        NotificationServiceExtension.setDelegate(self)
        NotificationServiceExtension.setNotificationDelegate(self)

        #if DEBUG
        NotificationServiceExtension.setDebugModeEnabled(true)
        #endif
        
        NotificationServiceExtension.setDecryptionFallbackNotificationTitleAndBody(title: "(Encrypted))", body: "(Encrypted)")
        NotificationServiceExtension.didReceiveNotificationExtensionRequest(request, withMutableNotificationContent: bestAttemptContent)
        
        contentHandler(bestAttemptContent)
    }
  }

  override func serviceExtensionTimeWillExpire() {
    // Called just before the extension will be terminated by the system.
    // Use this as an opportunity to deliver your "best attempt" at modified content, otherwise the original push payload will be used.
    
    if let contentHandler = self.contentHandler, let bestAttemptContent =  self.bestAttemptContent {
        contentHandler(bestAttemptContent)
    }
  }
}

extension NotificationService: NotificationServiceExtensionDelegate {
  
  func notificationServiceExtensionDidFailProcessingWithError(_ error: Error) {
#if DEBUG
        self.bestAttemptContent?.title = error.localizedDescription
#endif
  }
    
  func notificationServiceExtensionDidFailDecryptionWithError(_ error: Error) {
#if DEBUG
    self.bestAttemptContent?.title = error.localizedDescription
#endif
  }
}

extension NotificationService: NotificationDelegate {
    // This method is called when a Synerise notification is received.
    func snr_notificationDidReceive(notificationInfo: NotificationInfo) {
        //...
    }
}

#import "NotificationService.h"
#import <UserNotifications/UserNotifications.h>
#import <SyneriseSDK/SyneriseSDK.h>

@interface NotificationService () <SNRNotificationServiceExtensionDelegate, SNRNotificationDelegate>

@property (nonatomic, strong) void (^contentHandler)(UNNotificationContent *contentToDeliver);
@property (nonatomic, strong) UNMutableNotificationContent *bestAttemptContent;

@end

@implementation NotificationService

- (void)didReceiveNotificationRequest:(UNNotificationRequest *)request withContentHandler:(void (^)(UNNotificationContent * _Nonnull))contentHandler {
    self.contentHandler = contentHandler;
    self.bestAttemptContent = [request.content mutableCopy];
    
    SNRSynerise.settings.sdk.appGroupIdentifier = @"YOUR_APP_GROUP_IDENTIFIER";
    SNRSynerise.settings.sdk.keychainGroupIdentifier = @"YOUR_KEYCHAIN_GROUP_IDENTIFIER";
    
    [SNRNotificationServiceExtension setDelegate:self];
    [SNRNotificationServiceExtension setNotificationDelegate:self];

#ifdef DEBUG
    [SNRNotificationServiceExtension setDebugModeEnabled:YES];
#endif
    
    [SNRNotificationServiceExtension setDecryptionFallbackNotificationTitle:@"(Encrypted)" andBody:@"(Encrypted)"];
    [SNRNotificationServiceExtension didReceiveNotificationExtensionRequest:request withMutableNotificationContent:self.bestAttemptContent];
    
    self.contentHandler(self.bestAttemptContent);
}

- (void)serviceExtensionTimeWillExpire {
    // Called just before the extension will be terminated by the system.
    // Use this as an opportunity to deliver your "best attempt" at modified content, otherwise the original push payload will be used.

    self.contentHandler(self.bestAttemptContent);
}

#pragma mark - SNRNotificationServiceExtensionDelegate

- (void)notificationServiceExtensionDidFailProcessingWithError:(NSError *)error {
#ifdef DEBUG
    self.bestAttemptContent.body = error.localizedDescription;
#endif
}

- (void)notificationServiceExtensionDidFailDecryptionWithError:(NSError *)error {
#ifdef DEBUG
    self.bestAttemptContent.body = error.localizedDescription;
#endif
}

#pragma mark - SNRNotificationDelegate

// This method is called when a Synerise notification is received.
- (void)SNR_notificationDidReceive:(SNRNotificationInfo *)notificationInfo {
    //...
}

@end

- (void)didReceiveNotificationRequest:(UNNotificationRequest *)request withContentHandler:(void (^)(UNNotificationContent * _Nonnull))contentHandler {
  self.contentHandler = contentHandler;
  self.bestAttemptContent = [request.content mutableCopy];

  //...
  [SNRNotificationServiceExtension setDebugModeEnabled:YES];
  //...
}

// Support for Push Notifications on iOS 9
// Support for Silent Notifications

func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
  let isSyneriseNotification: Bool = Synerise.isSyneriseNotification(userInfo)
  
  if isSyneriseNotification {
    Synerise.handleNotification(userInfo)
    completionHandler(.noData)
  }
}

func application(_ application: UIApplication, handleActionWithIdentifier identifier: String?, forRemoteNotification userInfo: [AnyHashable : Any], completionHandler: @escaping () -> Void) {
  let isSyneriseNotification: Bool = Synerise.isSyneriseNotification(userInfo)
  
  if isSyneriseNotification {
    Synerise.handleNotification(userInfo, actionIdentifier: identifier)
    completionHandler()
  }
}

// Support for Push Notifications on iOS 10 and above

// MARK: - UNUserNotificationCenterDelegate

@available(iOS 10.0, *)
func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
  let userInfo = response.notification.request.content.userInfo
  
  let isSyneriseNotification: Bool = Synerise.isSyneriseNotification(userInfo)
  
  if isSyneriseNotification {
    Synerise.handleNotification(userInfo, actionIdentifier: response.actionIdentifier)
    completionHandler()
  }
}

@available(iOS 10.0, *)
func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
  let userInfo = notification.request.content.userInfo

  let isSyneriseNotification: Bool = Synerise.isSyneriseNotification(userInfo)
  
  if isSyneriseNotification {
    Synerise.handleNotification(userInfo)
    completionHandler(UNNotificationPresentationOptions.init(rawValue: 0))
  }
}

// Support for Push Notifications on iOS 9
// Support for Silent Notifications

- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
  BOOL isSyneriseNotification = [SNRSynerise isSyneriseNotification:userInfo];
  
  if (isSyneriseNotification) {
    [SNRSynerise handleNotification:userInfo];
    completionHandler(UIBackgroundFetchResultNoData);
  }
}

- (void)application:(UIApplication *)application handleActionWithIdentifier:(nullable NSString *)identifier forRemoteNotification:(NSDictionary *)userInfo completionHandler:(void(^)())completionHandler {
  BOOL isSyneriseNotification = [SNRSynerise isSyneriseNotification:userInfo];
  
  if (isSyneriseNotification) {
    [SNRSynerise handleNotification:userInfo actionIdentifier:identifier];
    completionHandler();
  }
}

// Support for Push Notifications on iOS 10 and above

// pragma mark - UNUserNotificationCenterDelegate

- (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void (^)(void))completionHandler NS_AVAILABLE_IOS(10) {
  NSDictionary *userInfo = response.notification.request.content.userInfo;

  BOOL isSyneriseNotification = [SNRSynerise isSyneriseNotification:userInfo];
  
  if (isSyneriseNotification) {
    [SNRSynerise handleNotification:userInfo actionIdentifier:response.actionIdentifier];
    completionHandler();
  }
}

- (void)userNotificationCenter:(UNUserNotificationCenter *)center willPresentNotification:(UNNotification *)notification withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler NS_AVAILABLE_IOS(10) {
  NSDictionary *userInfo = notification.request.content.userInfo;

  BOOL isSyneriseNotification = [SNRSynerise isSyneriseNotification:userInfo];
  if (isSyneriseNotification) {
    [SNRSynerise handleNotification:userInfo];
    completionHandler(UNNotificationPresentationOptionNone);
  }
}

@available(iOS 10.0, *)
func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
  let userInfo = notification.request.content.userInfo

  let isSyneriseNotification: Bool = Synerise.isSyneriseNotification(userInfo)

  if isSyneriseNotification {
    Synerise.handleNotification(userInfo)
    completionHandler(UNNotificationPresentationOptions.init(rawValue: 0))
  } else {
    // Handle other notification in your own way
  }
}

- (void)userNotificationCenter:(UNUserNotificationCenter *)center willPresentNotification:(UNNotification *)notification withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler NS_AVAILABLE_IOS(10) {
  NSDictionary *userInfo = notification.request.content.userInfo;

  BOOL isSyneriseNotification = [SNRSynerise isSyneriseNotification:userInfo];
  if (isSyneriseNotification) {
    [SNRSynerise handleNotification:userInfo];
    completionHandler(UNNotificationPresentationOptionNone);
  } else {
    // Handle other notification in your own way
  }
}

@available(iOS 10.0, *)
func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
  let userInfo = notification.request.content.userInfo

  let isSyneriseNotification: Bool = Synerise.isSyneriseNotification(userInfo)

  if isSyneriseNotification {
    let isNotificationEncrypted: Bool = Synerise.isNotificationEncrypted(userInfo)
    if isNotificationEncrypted == true {
        if let userInfoDecrypted = Synerise.decryptNotification(userInfo) {
            // Handle decrypted payload in your own way
        }

    Synerise.handleNotification(userInfo)
    completionHandler(UNNotificationPresentationOptions.init(rawValue: 0))
  }
}

- (void)userNotificationCenter:(UNUserNotificationCenter *)center willPresentNotification:(UNNotification *)notification withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler NS_AVAILABLE_IOS(10) {
  NSDictionary *userInfo = notification.request.content.userInfo;

  BOOL isSyneriseNotification = [SNRSynerise isSyneriseNotification:userInfo];
  if (isSyneriseNotification) {
      BOOL isNotificationEncrypted = [SNRSynerise isNotificationEncrypted:userInfo];
      if (isNotificationEncrypted == YES) {
        NSDictionary *userInfoDecrypted = [SNRSynerise decryptNotification:userInfo];
        if (userInfoDecrypted != nil) {
            // Handle decrypted payload in your own way
        }

    [SNRSynerise handleNotification:userInfo];
    completionHandler(UNNotificationPresentationOptionNone);
  }
}

import UserNotifications
import SyneriseSDK

class NotificationService: UNNotificationServiceExtension {

  var contentHandler: ((UNNotificationContent) -> Void)?
  var bestAttemptContent: UNMutableNotificationContent?

  override func didReceive(_ request: UNNotificationRequest, withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
    self.contentHandler = contentHandler
    self.bestAttemptContent = (request.content.mutableCopy() as? UNMutableNotificationContent)
    
    if let bestAttemptContent = self.bestAttemptContent {
      var userInfo = notification.request.content.userInfo
      let isSyneriseNotification: Bool = Synerise.isSyneriseNotification(userInfo)

      if isSyneriseNotification == true {
        //...
      } else {
        let isNotificationEncrypted: Bool = Synerise.isNotificationEncrypted(userInfo)
        if isNotificationEncrypted == true {
          if let userInfoDecrypted = Synerise.decryptNotification(userInfo) {
            bestAttemptContent.title = userInfoDecrypted["aps"]?["alert"]?["title"]
            bestAttemptContent.body = userInfoDecrypted["aps"]?["alert"]?["body"]
            bestAttemptContent.userInfo = userInfoDecrypted;
          } else {
            bestAttemptContent.title = "YOUR_FALLBACK_TITLE"
            bestAttemptContent.body = "YOUR_FALLBACK_BODY"
          }
        }
      }

      contentHandler(bestAttemptContent)
    }
  }
}

#import "NotificationService.h"
#import <UserNotifications/UserNotifications.h>
#import <SyneriseSDK/SyneriseSDK.h>
  
@interface NotificationService ()

@property (nonatomic, strong) void (^contentHandler)(UNNotificationContent *contentToDeliver);
@property (nonatomic, strong) UNMutableNotificationContent *bestAttemptContent;

@end

@implementation NotificationService

- (void)didReceiveNotificationRequest:(UNNotificationRequest *)request withContentHandler:(void (^)(UNNotificationContent * _Nonnull))contentHandler {
    self.contentHandler = contentHandler;
    self.bestAttemptContent = [request.content mutableCopy];
    
    NSDictionary *userInfo = notification.request.content.userInfo;

    BOOL isSyneriseNotification = [SNRSynerise isSyneriseNotification:userInfo];
    if (isSyneriseNotification == YES) {
      //...
    } else {
      BOOL isNotificationEncrypted = [SNRSynerise isNotificationEncrypted:userInfo];
      if (isNotificationEncrypted == YES) {
        NSDictionary *userInfoDecrypted = [SNRSynerise decryptNotification:userInfo];
        if (userInfoDecrypted != nil) {
          bestAttemptContent.title = userInfoDecrypted[@"aps"][@"alert"][@"title"];
          bestAttemptContent.body = userInfoDecrypted[@"aps"][@"alert"][@"body"];
          bestAttemptContent.userInfo = userInfoDecrypted;
        } else {
          bestAttemptContent.title = "YOUR_FALLBACK_TITLE"
          bestAttemptContent.body = "YOUR_FALLBACK_BODY"
        }
      }
    }

    self.contentHandler(self.bestAttemptContent);
}

@end

extension SyneriseManager: NotificationDelegate {
    // This method is called when a Synerise notification is received.
    func snr_notificationDidReceive(notificationInfo: NotificationInfo) {
        //...
    }

    // This method is called when a Synerise notification is dismissed.
    func snr_notificationDidDissmis(notificationInfo: NotificationInfo) {
        //...
    }
    
    // This method is called when a Synerise notification is clicked.
    func snr_notificationClicked(notificationInfo: NotificationInfo) {
        //...
    }
    
    // This method is called when an action button is clicked in a Synerise notification.
    func snr_notificationClicked(notificationInfo: NotificationInfo, actionButton: String) {
        //...
    }
}

#pragma mark - SNRNotificationDelegate

// This method is called when a Synerise notification is received.
- (void)SNR_notificationDidReceive:(SNRNotificationInfo *)notificationInfo {
    //...
}

// This method is called when a Synerise notification is dismissed.
- (void)SNR_notificationDidDissmis:(SNRNotificationInfo *)notificationInfo {
    //...
}

// This method is called when a Synerise notification is clicked.
- (void)SNR_notificationClicked:(SNRNotificationInfo *)notificationInfo {
    //...
}

// This method is called when an action button is clicked in a Synerise notification.
- (void)SNR_notificationActionButtonClicked:(SNRNotificationInfo *)notificationInfo actionButton:(NSString *)actionButton {
    //...
}

Synerise.settings.sdk.appGroupIdentifier = "YOUR_APP_GROUP_IDENTIFIER"
Synerise.settings.sdk.keychainGroupIdentifier = "YOUR_KEYCHAIN_GROUP_IDENTIFIER"

let singleMediaCategory = UNNotificationCategory(identifier: SNRSingleMediaContentExtensionViewControllerCategoryIdentifier, actions: [], intentIdentifiers: [], options: [])

let carouselPrevious = UNNotificationAction(identifier: SNRCarouselContentExtensionViewControllerPreviousItemIdentifier, title: "Previous", options: [])
let carouselAction = UNNotificationAction(identifier: SNRCarouselContentExtensionViewControllerChooseItemIdentifier, title: "Go!", options: UNNotificationActionOptions.foreground)
let carouselNext = UNNotificationAction(identifier: SNRCarouselContentExtensionViewControllerNextItemIdentifier, title: "Next", options: [])
let carouselCategory = UNNotificationCategory(identifier: SNRCarouselContentExtensionViewControllerCategoryIdentifier, actions: [carouselPrevious, carouselAction, carouselNext], intentIdentifiers: [], options: [])

UNUserNotificationCenter.current().setNotificationCategories([singleMediaCategory, carouselCategory])

SNRSynerise.settings.notifications.appGroupIdentifier = @"YOUR_APP_GROUP_IDENTIFIER";
SNRSynerise.settings.sdk.keychainGroupIdentifier = @"YOUR_KEYCHAIN_GROUP_IDENTIFIER";

UNNotificationCategory *singleMediaCategory = [UNNotificationCategory categoryWithIdentifier:SNRSingleMediaContentExtensionViewControllerCategoryIdentifier actions:@[] intentIdentifiers:@[] options:0];

UNNotificationAction *carouselPreviousAction = [UNNotificationAction actionWithIdentifier:SNRCarouselContentExtensionViewControllerPreviousItemIdentifier title:@"Previous" options:0];
UNNotificationAction *carouselGoAction = [UNNotificationAction actionWithIdentifier:SNRCarouselContentExtensionViewControllerChooseItemIdentifier title:@"Go" options:0];
UNNotificationAction *carouselNextAction = [UNNotificationAction actionWithIdentifier:SNRCarouselContentExtensionViewControllerNextItemIdentifier title:@"Next" options:0];
UNNotificationCategory *carouselCategory = [UNNotificationCategory categoryWithIdentifier:SNRCarouselContentExtensionViewControllerCategoryIdentifier actions:@[carouselPreviousAction, carouselGoAction, carouselNextAction] intentIdentifiers:@[] options:0];

[[UNUserNotificationCenter currentNotificationCenter] setNotificationCategories:[NSSet setWithObjects:singleMediaCategory, carouselCategory, nil]];

import UIKit
import UserNotifications
import UserNotificationsUI
import SyneriseSDK

class NotificationViewController: SingleMediaContentExtensionViewController, UNNotificationContentExtension {

  func didReceive(_ notification: UNNotification) {
  Synerise.settings.sdk.appGroupIdentifier = "YOUR_APP_GROUP_IDENTIFIER"
  Synerise.settings.sdk.keychainGroupIdentifier = "YOUR_KEYCHAIN_GROUP_IDENTIFIER"

    self.contentViewIsScrollable = false
    self.imageContentMode = .scaleAspectFit

    setSyneriseNotification(notification)
  }

  func didReceive(_ response: UNNotificationResponse, completionHandler completion: @escaping (UNNotificationContentExtensionResponseOption) -> Void) {
    setSyneriseNotificationResponse(response, completionHandler: completion)
  }
}

#import <UIKit/UIKit.h>
#import <UserNotifications/UserNotifications.h>
#import <UserNotificationsUI/UserNotificationsUI.h>
#import <SyneriseSDK/SyneriseSDK.h>

@interface SingleMediaNotificationViewController : SNRSingleMediaContentExtensionViewController <UNNotificationContentExtension>

@end

#import "SingleMediaNotificationViewController.h"

@implementation SingleMediaNotificationViewController

- (void)didReceiveNotification:(UNNotification *)notification {
  SNRSynerise.settings.notifications.appGroupIdentifier = @"YOUR_APP_GROUP_IDENTIFIER";
  SNRSynerise.settings.sdk.keychainGroupIdentifier = @"YOUR_KEYCHAIN_GROUP_IDENTIFIER";

  self.contentViewIsScrollable = NO;
  self.imageContentMode = UIViewContentModeScaleAspectFit;

  [self setSyneriseNotification:notification];
}

- (void)didReceiveNotificationResponse:(UNNotificationResponse *)response completionHandler:(void (^)(UNNotificationContentExtensionResponseOption))completion {
  [self setSyneriseNotificationResponse:response completionHandler:completion];
}

@end

import UIKit
import UserNotifications
import UserNotificationsUI
import SyneriseSDK

class NotificationViewController: CarouselContentExtensionViewController, UNNotificationContentExtension {

  func didReceive(_ notification: UNNotification) {
  Synerise.settings.sdk.appGroupIdentifier = "YOUR_APP_GROUP_IDENTIFIER"
  Synerise.settings.sdk.keychainGroupIdentifier = "YOUR_KEYCHAIN_GROUP_IDENTIFIER"

    self.imageContentMode = .scaleAspectFit

    setSyneriseNotification(notification)
  }

  func didReceive(_ response: UNNotificationResponse, completionHandler completion: @escaping (UNNotificationContentExtensionResponseOption) -> Void) {
    setSyneriseNotificationResponse(response, completionHandler: completion)
  }
}

#import <UIKit/UIKit.h>
#import <UserNotifications/UserNotifications.h>
#import <UserNotificationsUI/UserNotificationsUI.h>
#import <SyneriseSDK/SyneriseSDK.h>

@interface CarouselNotificationViewController : SNRCarouselContentExtensionViewController <UNNotificationContentExtension>

@end

#import "CarouselNotificationViewController.h"

@implementation CarouselNotificationViewController

- (void)didReceiveNotification:(UNNotification *)notification {
  SNRSynerise.settings.notifications.appGroupIdentifier = @"YOUR_APP_GROUP_IDENTIFIER";
  SNRSynerise.settings.sdk.keychainGroupIdentifier = @"YOUR_KEYCHAIN_GROUP_IDENTIFIER";

  [self setSyneriseNotification:notification];
}

- (void)didReceiveNotificationResponse:(UNNotificationResponse *)response completionHandler:(void (^)(UNNotificationContentExtensionResponseOption))completion {
  [self setSyneriseNotificationResponse:response completionHandler:completion];
}

@end