Use the iOS SDK

# other podfile info

target 'Your-Target' do
  use_frameworks!

  pod 'CMPComapiFoundation'
end

pod install

#import <CMPComapiFoundation/CMPComapiFoundation.h>

import CMPComapiFoundation

// Use "development" for builds you run from Xcode.
// Use "production" for TestFlight, ad hoc, and App Store builds.
let config = ComapiConfig()
    .setApnsEnvironment("production")

#if DEBUG
let apnsEnvironment = "development"
#else
let apnsEnvironment = "production"
#endif

let config = ComapiConfig()
    .setApnsEnvironment(apnsEnvironment)

// These values come from the Authentication section of your push notification
// profile in Dotdigital Marketing.
NSString *idClaim = <ID claim value>;
NSString *issuer = <Issuer value>;
NSString *audience = <Audience value>;
NSString *secret = <Shared secret value>;

- (void)client:(CMPComapiClient *)client didReceiveAuthenticationChallenge:(CMPAuthenticationChallenge *)challenge completion:(void (^)(NSString * _Nullable))continueWithToken {
    // Request a JWT from your provider, which should be your backend server.
    [YourProviderServer getTokenForNonce:challenge.nonce
                                     id:idClaim
                                 issuer:issuer
                               audience:audience
                                 secret:secret
                             completion:^(NSString *token, NSError *error) {
        // Call the continueWithToken block with the generated token.
        if (token && !error) {
            continueWithToken(token);
        } else {
            // Pass nil so that the SDK does not wait for a token that never arrives.
            continueWithToken(nil);
        }
    }];
}

extension LoginViewModel: AuthenticationDelegate {
    func client(_ client: ComapiClient,
                didReceive challenge: AuthenticationChallenge,
                completion continueWithToken: @escaping (String?) -> Void) {
        // Request a JWT from your provider, which should be your backend server.
        YourProviderServer.token(forNonce: challenge.nonce) { token in
            // Pass nil if the request fails, so that the SDK does not wait for a
            // token that never arrives.
            continueWithToken(token)
        }
    }
}

// Create a config object with your API space ID and an object that conforms to
// the CMPAuthenticationDelegate protocol.
CMPComapiConfig *config = [[[CMPComapiConfig alloc] init]
    setApiSpaceID:@"<API_SPACE_ID>"];
[config setAuthDelegate:self];

let config = ComapiConfig()
    .setApiSpaceID("<API_SPACE_ID>")
    .setAuthDelegate(self)
    .setApnsEnvironment("production")

#if DEBUG
let logLevel = LogLevel.debug
#else
let logLevel = LogLevel.warning
#endif

let config = ComapiConfig()
    .setApiSpaceID("<API_SPACE_ID>")
    .setAuthDelegate(self)
    .setLogLevel(logLevel)

CMPComapiClient *client = [CMPComapi initialiseWithConfig:config];
// The client instance is ready to use.

let client = Comapi.initialise(with: config)
// The client instance is ready to use.

[CMPComapi initialiseSharedInstanceWithConfig:config];

CMPComapiClient *client = [CMPComapi shared];
// The shared client is ready to use.

let client = Comapi.initialiseSharedInstance(with: config)
// The shared client is ready to use.

[client.services.session startSessionWithCompletion:^{
    // Session created successfully.
} failure:^(NSError * _Nullable error) {
    // An error occurred.
    NSLog(@"Failed to start session: %@", error.localizedDescription);
}];

client.services.session.startSession(completion: {
    // Session created successfully.
}, failure: { error in
    // An error occurred.
    print("Failed to start session: \(String(describing: error))")
})

[client.services.session endSessionWithCompletion:^(CMPResult<NSNumber *> *result) {
    if (result.error) {
        // An error occurred.
    } else if ([result.object boolValue]) {
        // Session ended successfully.
    }
}];

client.services.session.endSession(completion: { result in
    if let error = result.error {
        // An error occurred.
        print("Failed to end session: \(error)")
    } else if result.object?.boolValue == true {
        // Session ended successfully.
    }
})

#import <UserNotifications/UserNotifications.h>

- (void)requestNotificationPermission {
    UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
    [center requestAuthorizationWithOptions:(UNAuthorizationOptionAlert |
                                             UNAuthorizationOptionSound |
                                             UNAuthorizationOptionBadge)
                          completionHandler:^(BOOL granted, NSError * _Nullable error) {
        if (!granted) {
            // The user declined. Do not register for remote notifications.
            return;
        }
        dispatch_async(dispatch_get_main_queue(), ^{
            [[UIApplication sharedApplication] registerForRemoteNotifications];
        });
    }];
}

import UserNotifications

func requestNotificationPermission() {
    UNUserNotificationCenter.current()
        .requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
            guard granted else {
                // The user declined. Do not register for remote notifications.
                return
            }
            DispatchQueue.main.async {
                UIApplication.shared.registerForRemoteNotifications()
            }
        }
}

- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
    NSMutableString *token = [NSMutableString stringWithCapacity:deviceToken.length * 2];

    // Convert the deviceToken bytes to a hexadecimal string. Use unsigned char,
    // because a signed char sign-extends any byte above 0x7F and corrupts the token.
    const unsigned char *bytes = (const unsigned char *)deviceToken.bytes;
    for (NSUInteger i = 0; i < deviceToken.length; i++) {
        [token appendFormat:@"%02x", bytes[i]];
    }

    // Pass the hexadecimal string version of the token to the SDK.
    if (token.length > 0) {
        CMPComapiClient *client = [CMPComapi shared];
        if (client) {
            [client setPushToken:token completion:^(BOOL success, NSError *error) {
                if (error || !success) {
                    NSLog(@"Failed to register APNS token: %@", error.localizedDescription);
                } else {
                    // APNS token registered successfully.
                }
            }];
        }
    }

    // The rest of your push notification code.
}

- (void)application:(UIApplication *)application didFailToRegisterForRemoteNotificationsWithError:(NSError *)error {
    // Registration failed. This is common on the iOS Simulator and when the
    // device has no network connection. There is no token for this session,
    // so log the error and do not retry in a loop.
    NSLog(@"Failed to register for remote notifications: %@", error.localizedDescription);
}

func application(_ application: UIApplication,
                 didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    let token = deviceToken.map { String(format: "%02x", $0) }.joined()

    client?.set(pushToken: token, completion: { success, error in
        if let error = error {
            print("Failed to register APNS token: \(error)")
        } else if success {
            // APNS token registered successfully.
        }
    })
}

func application(_ application: UIApplication,
                 didFailToRegisterForRemoteNotificationsWithError error: Error) {
    // Registration failed. This is common on the iOS Simulator and when the
    // device has no network connection. There is no token for this session,
    // so log the error and do not retry in a loop.
    print("Failed to register for remote notifications: \(error)")
}

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    [UNUserNotificationCenter currentNotificationCenter].delegate = self;
    return YES;
}

func application(_ application: UIApplication,
                 didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    UNUserNotificationCenter.current().delegate = self
    return true
}

- (void)userNotificationCenter:(UNUserNotificationCenter *)center
       willPresentNotification:(UNNotification *)notification
         withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler {

    // Let iOS display the notification banner and play a sound, even though the
    // app is in the foreground.
    if (@available(iOS 14.0, *)) {
        completionHandler(UNNotificationPresentationOptionBanner |
                          UNNotificationPresentationOptionSound |
                          UNNotificationPresentationOptionList);
    } else {
        completionHandler(UNNotificationPresentationOptionAlert |
                          UNNotificationPresentationOptionSound);
    }
}

func userNotificationCenter(_ center: UNUserNotificationCenter,
                            willPresent notification: UNNotification,
                            withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {

    // Let iOS display the notification banner and play a sound, even though the
    // app is in the foreground.
    if #available(iOS 14.0, *) {
        completionHandler([.banner, .sound, .list])
    } else {
        completionHandler([.alert, .sound])
    }
}

func userNotificationCenter(_ center: UNUserNotificationCenter,
                            willPresent notification: UNNotification,
                            withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {

    let content = notification.request.content
    let title = content.title
    let body = content.body

    // Display your own in-app banner with the title and body here.

    // Pass an empty option set so that iOS does not also display the notification.
    completionHandler([])
}

- (void)userNotificationCenter:(UNUserNotificationCenter *)center
didReceiveNotificationResponse:(UNNotificationResponse *)response
         withCompletionHandler:(void (^)(void))completionHandler {

    CMPComapiClient *client = [CMPComapi shared];
    if (!client) {
        completionHandler();
        return;
    }

    [client handleNotificationResponse:response completion:^(BOOL isDeepLinkLaunched, NSDictionary * _Nonnull data) {

        if (isDeepLinkLaunched) {
            // The SDK opened the deep link. There is nothing more to do.
            completionHandler();
            return;
        }

        if (data[@"dd_deepLink"]) {
            // The SDK did not open the link, so handle it in your app.
            NSString *url = data[@"dd_deepLink"][@"url"];
            NSLog(@"Deep link: %@", url);

        } else if (data[@"dd_data"]) {
            // Custom data from the Dotdigital Marketing push message.
            NSDictionary *ddData = data[@"dd_data"];
            NSLog(@"Custom data: %@", ddData);
        }

        completionHandler();
    }];
}

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

    guard let client = client else {
        completionHandler()
        return
    }

    client.handle(notificationResponse: response, completion: { didHandleLink, data in

        if didHandleLink {
            // The SDK opened the deep link. There is nothing more to do.
            completionHandler()
            return
        }

        if let deepLink = data["dd_deepLink"] as? NSDictionary,
           let url = deepLink["url"] as? String {
            // The SDK did not open the link, so handle it in your app.
            print("Deep link: \(url)")

        } else if let customData = data["dd_data"] as? NSDictionary {
            // Read the custom data payload.
            print("Custom data: \(customData)")
        }

        completionHandler()
    })
}

if ([CMPComapiClient isDotdigitalOriginated:response.notification.request.content.userInfo]) {
    // Dotdigital Marketing sent this message.
}

if ComapiClient.isDotdigitalOriginated(response.notification.request.content.userInfo) {
    // Dotdigital Marketing sent this message.
}

func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
    guard let url = URLContexts.first?.url else { return }
    route(to: url)
}

// Called when your app launches from a cold start through a deep link.
func scene(_ scene: UIScene,
           willConnectTo session: UISceneSession,
           options connectionOptions: UIScene.ConnectionOptions) {
    if let url = connectionOptions.urlContexts.first?.url {
        route(to: url)
    }
}

private func route(to url: URL) {
    // Inspect the host and path, then navigate to the correct screen in your app.
    // For myappscheme://product/123, url.host is "product" and url.path is "/123".
}

func application(_ app: UIApplication,
                 open url: URL,
                 options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool {
    route(to: url)
    return true
}

- (BOOL)application:(UIApplication *)app
            openURL:(NSURL *)url
            options:(NSDictionary<UIApplicationOpenURLOptionsKey, id> *)options {
    [self routeToURL:url];
    return YES;
}

func application(_ application: UIApplication,
                 continue userActivity: NSUserActivity,
                 restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
    guard userActivity.activityType == NSUserActivityTypeBrowsingWeb,
          let url = userActivity.webpageURL else {
        return false
    }
    route(to: url)
    return true
}

{
  "dd_deepLink": {
    "url": "myappscheme://product/123",
    "trackingUrl": "https://<tracking endpoint supplied by Dotdigital Marketing>"
  }
}

{
  "dd_data": {
    "productId": "123",
    "campaign": "summer-sale",
    "screen": "product-detail"
  }
}

- (void)application:(UIApplication *)application
didReceiveRemoteNotification:(NSDictionary *)userInfo
fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {

    NSDictionary *ddData = userInfo[@"dd_data"];
    if (ddData) {
        // Process the custom data here.
    }

    completionHandler(UIBackgroundFetchResultNewData);
}

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

    if let ddData = userInfo["dd_data"] as? [String: Any] {
        // Process the custom data here.
    }

    completionHandler(.newData)
}