import AppTrackingTransparency
...
ATTrackingManager.requestTrackingAuthorization { _ in }

#import <AppTrackingTransparency/AppTrackingTransparency.h>
...
[ATTrackingManager requestTrackingAuthorizationWithCompletionHandler:^(ATTrackingManagerAuthorizationStatus status) {}];

import UIKit
import Airbridge
import AppTrackingTransparency

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    var observer: Any?

    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        let option = AirbridgeOptionBuilder(name: "YOUR_APP_NAME", token: "YOUR_APP_SDK_TOKEN")
            .build()
        Airbridge.initializeSDK(option: option)

        observer = NotificationCenter.default.addObserver(
            forName: UIApplication.didBecomeActiveNotification,
            object: nil,
            queue: nil
        ) { [weak self] _ in
            if #available(iOS 14, *) {
                ATTrackingManager.requestTrackingAuthorization { _ in }
            }
            if let observer = self?.observer {
                NotificationCenter.default.removeObserver(observer)
            }
        }

        return true
    }
}

#import "AppDelegate.h"
#import <Airbridge/Airbridge.h>
#import <AppTrackingTransparency/AppTrackingTransparency.h>

@interface AppDelegate ()

@end

@implementation AppDelegate {
    id observer;
}

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    AirbridgeOptionBuilder* optionBuilder = [[AirbridgeOptionBuilder alloc] initWithName:@"YOUR_APP_NAME"
                                                                                   token:@"YOUR_APP_SDK_TOKEN"];
    AirbridgeOption* option = [optionBuilder build];
    [Airbridge initializeSDKWithOption:option];

    __weak typeof(self) weakSelf = self;
    observer = [NSNotificationCenter.defaultCenter addObserverForName:UIApplicationDidBecomeActiveNotification
                                                            object:nil
                                                                queue:nil
                                                        usingBlock:^(NSNotification * _Nonnull notification) {
        if (@available(iOS 14, *)) {
            [ATTrackingManager requestTrackingAuthorizationWithCompletionHandler:^(ATTrackingManagerAuthorizationStatus status) {}];
        }
        if (weakSelf != nil && weakSelf->observer != nil) {
            [NSNotificationCenter.defaultCenter removeObserver:observer];
        }
    }];

    return YES;
}

@end

import SwiftUI
import Airbridge
import AppTrackingTransparency

@main
struct ExampleApp: App {
    init() {
        let option = AirbridgeOptionBuilder(name: "YOUR_APP_NAME", token: "YOUR_APP_SDK_TOKEN")
            .build()
        Airbridge.initializeSDK(option: option)

        var observer: Any?
        observer = NotificationCenter.default.addObserver(
            forName: UIApplication.didBecomeActiveNotification,
            object: nil,
            queue: nil
        ) { _ in
            if #available(iOS 14, *) {
                ATTrackingManager.requestTrackingAuthorization { _ in }
            }
            if let observer {
                NotificationCenter.default.removeObserver(observer)
            }
        }
    }
    
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

import Airbridge
...
Airbridge.trackDeeplink(url: url)
Airbridge.trackDeeplink(userActivity: userActivity)

#import <Airbridge/Airbridge.h>
...
[Airbridge trackDeeplinkWithUrl:url];
[Airbridge trackDeeplinkWithUserActivity:userActivity];

import Airbridge
...
// when terminated app is opened with scheme deeplink or universal links
func scene(
    _ scene: UIScene,
    willConnectTo session: UISceneSession,
    options connectionOptions: UIScene.ConnectionOptions
) {
    // when app is opened with scheme deeplink
    if let url = connectionOptions.urlContexts.first?.url {
        // track deeplink
        Airbridge.trackDeeplink(url: url)
    }
    // when app is opened with universal links
    else if let userActivity = connectionOptions.userActivities.first {
        // track deeplink
        Airbridge.trackDeeplink(userActivity: userActivity)
    }
}

#import <Airbridge/Airbridge.h>
...
// when terminated app is opened with scheme deeplink or universal links
- (void)scene:(UIScene *)scene willConnectToSession:(UISceneSession *)session options:(UISceneConnectionOptions *)connectionOptions {
    // when app is opened with scheme deeplink
    NSURL* url = connectionOptions.URLContexts.allObjects.firstObject.URL;
    NSUserActivity* userActivity = connectionOptions.userActivities.allObjects.firstObject;
    if (url != nil) {
        // track deeplink
        [Airbridge trackDeeplinkWithUrl:url];
    }
    else if (userActivity != nil) {
        // track deeplink
        [Airbridge trackDeeplinkWithUserActivity:userActivity];
    }
}

import Airbridge
...
// when backgrounded app is opened with scheme deeplink
func scene(
    _ scene: UIScene,
    openURLContexts URLContexts: Set<UIOpenURLContext>
) {
    guard let url = URLContexts.first?.url else { return }

    // track deeplink
    Airbridge.trackDeeplink(url: url)
}

#import <Airbridge/Airbridge.h>
...
// when backgrounded app is opened with scheme deeplink
- (void)scene:(UIScene *)scene openURLContexts:(NSSet<UIOpenURLContext *> *)URLContexts {
    NSURL* url = URLContexts.allObjects.firstObject.URL;
    if (url == nil) { return; }

    // track deeplink
    [Airbridge trackDeeplinkWithUrl:url];
}

import Airbridge
...
// when backgrounded app is opened with universal links
func scene(
    _ scene: UIScene,
    continue userActivity: NSUserActivity
) {
    // track deeplink
    Airbridge.trackDeeplink(userActivity: userActivity)
}

// when backgrounded app is opened with universal links
- (void)scene:(UIScene *)scene continueUserActivity:(NSUserActivity *)userActivity {
    // track deeplink
    [Airbridge trackDeeplinkWithUserActivity:userActivity];
}

import Airbridge
...
// handle deeplink
var isHandled = Airbridge.handleDeeplink(url: url) { url in
    // when app is opened with airbridge deeplink
    // show proper content using url (YOUR_SCHEME://...)
}
if isHandled { return }

// when app is opened with other deeplink
// use existing logic as it is
...
// handle deeplink
var isHandled = Airbridge.handleDeeplink(userActivity: userActivity) { url in
    // when app is opened with airbridge deeplink
    // show proper content using url (YOUR_SCHEME://...)
}
if isHandled { return }

// when app is opened with other deeplink
// use existing logic as it is

#import <Airbridge/Airbridge.h>
...
// handle deeplink
BOOL isHandled = [Airbridge handleDeeplinkWithUrl:url onSuccess:^(NSURL* url) {
    // when app is opened with airbridge deeplink
    // show proper content using url (YOUR_SCHEME://...)
}];
if (isHandled) { return; }

// when app is opened with other deeplink
// use existing logic as it is
...
// handle deeplink
BOOL isHandled = [Airbridge handleDeeplinkWithUserActivity:userActivity onSuccess:^(NSURL* url) {
    // when app is opened with airbridge deeplink
    // show proper content using url (YOUR_SCHEME://...)
}];
if (isHandled) { return; }

// when app is opened with other deeplink
// use existing logic as it is

import Foundation
...
// when app is opened with airbridge deeplink
func handleAirbridgeDeeplink(url: URL) {
    // show proper content using url (YOUR_SCHEME://...)
}

import Foundation
...
// when app is opened with airbridge deeplink
- (void)handleAirbridgeDeeplink:(NSURL *)url {
    // show proper content using url (YOUR_SCHEME://...)
}

import Airbridge
...
// when terminated app is opened with scheme deeplink or universal links
func scene(
    _ scene: UIScene,
    willConnectTo session: UISceneSession,
    options connectionOptions: UIScene.ConnectionOptions
) {
    // when app is opened with scheme deeplink
    if let url = connectionOptions.urlContexts.first?.url {
        // track deeplink
        Airbridge.trackDeeplink(url: url)

        // handle deeplink
        var isHandled = Airbridge.handleDeeplink(url: url) { url in
            // when app is opened with airbridge deeplink
            // show proper content using url (YOUR_SCHEME://...)
            handleAirbridgeDeeplink(url: url)
        }
        if isHandled { return }

        // when app is opened with other deeplink
        // use existing logic as it is
    }
    // when app is opened with universal links
    else if let userActivity = connectionOptions.userActivities.first {
        // track deeplink
        Airbridge.trackDeeplink(userActivity: userActivity)

        // handle deeplink
        var isHandled = Airbridge.handleDeeplink(userActivity: userActivity) { url in
            // when app is opened with airbridge deeplink
            // show proper content using url (YOUR_SCHEME://...)
            handleAirbridgeDeeplink(url: url)
        }
        if isHandled { return }

        // when app is opened with other deeplink
        // use existing logic as it is
    }
}

#import <Airbridge/Airbridge.h>
...
// when terminated app is opened with scheme deeplink or universal links
- (void)scene:(UIScene *)scene willConnectToSession:(UISceneSession *)session options:(UISceneConnectionOptions *)connectionOptions {
    // when app is opened with scheme deeplink
    NSURL* url = connectionOptions.URLContexts.allObjects.firstObject.URL;
    NSUserActivity* userActivity = connectionOptions.userActivities.allObjects.firstObject;
    if (url != nil) {
        // track deeplink
        [Airbridge trackDeeplinkWithUrl:url];

        // handle deeplink
        BOOL isHandled = [Airbridge handleDeeplinkWithUrl:url onSuccess:^(NSURL* url) {
            // when app is opened with airbridge deeplink
            // show proper content using url (YOUR_SCHEME://...)
            [self handleAirbridgeDeeplink:url];
        }];
        if (isHandled) { return; }

        // when app is opened with other deeplink
        // use existing logic as it is
    }
    else if (userActivity != nil) {
        // track deeplink
        [Airbridge trackDeeplinkWithUserActivity:userActivity];

        // handle deeplink
        BOOL isHandled = [Airbridge handleDeeplinkWithUserActivity:userActivity onSuccess:^(NSURL* url) {
            // when app is opened with airbridge deeplink
            // show proper content using url (YOUR_SCHEME://...)
            [self handleAirbridgeDeeplink:url];
        }];
        if (isHandled) { return; }

        // when app is opened with other deeplink
        // use existing logic as it is
    }
}

import Airbridge
...
// when backgrounded app is opened with scheme deeplink
func scene(
    _ scene: UIScene,
    openURLContexts URLContexts: Set<UIOpenURLContext>
) {
    guard let url = URLContexts.first?.url else { return }

    // track deeplink
    Airbridge.trackDeeplink(url: url)

    // handle deeplink
    var isHandled = Airbridge.handleDeeplink(url: url) { url in
        // when app is opened with airbridge deeplink
        // show proper content using url (YOUR_SCHEME://...)
        handleAirbridgeDeeplink(url: url)
    }
    if isHandled { return }

    // when app is opened with other deeplink
    // use existing logic as it is
}

#import <Airbridge/Airbridge.h>
...
// when backgrounded app is opened with scheme deeplink
- (void)scene:(UIScene *)scene openURLContexts:(NSSet<UIOpenURLContext *> *)URLContexts {
    NSURL* url = URLContexts.allObjects.firstObject.URL;
    if (url == nil) { return; }

    // track deeplink
    [Airbridge trackDeeplinkWithUrl:url];

    // handle deeplink
    BOOL isHandled = [Airbridge handleDeeplinkWithUrl:url onSuccess:^(NSURL* url) {
        // when app is opened with airbridge deeplink
        // show proper content using url (YOUR_SCHEME://...)
        [self handleAirbridgeDeeplink:url];
    }];
    if (isHandled) { return; }

    // when app is opened with other deeplink
    // use existing logic as it is
}

import Airbridge
...
// when backgrounded app is opened with universal links
func scene(
    _ scene: UIScene,
    continue userActivity: NSUserActivity
) {
    // track deeplink
    Airbridge.trackDeeplink(userActivity: userActivity)

    // handle deeplink
    var isHandled = Airbridge.handleDeeplink(userActivity: userActivity) { url in
        // when app is opened with airbridge deeplink
        // show proper content using url (YOUR_SCHEME://...)
        handleAirbridgeDeeplink(url: url)
    }
    if isHandled { return }

    // when app is opened with other deeplink
    // use existing logic as it is
}

// when backgrounded app is opened with universal links
- (void)scene:(UIScene *)scene continueUserActivity:(NSUserActivity *)userActivity {
    // track deeplink
    [Airbridge trackDeeplinkWithUserActivity:userActivity];

    // handle deeplink
    BOOL isHandled = [Airbridge handleDeeplinkWithUserActivity:userActivity onSuccess:^(NSURL* url) {
        // when app is opened with airbridge deeplink
        // show proper content using url (YOUR_SCHEME://...)
        [self handleAirbridgeDeeplink:url];
    }];
    if (isHandled) { return; }

    // when app is opened with other deeplink
    // use existing logic as it is
}

import Airbridge
...
Airbridge.trackDeeplink(url: url)
Airbridge.trackDeeplink(userActivity: userActivity)

#import <Airbridge/Airbridge.h>
...
[Airbridge trackDeeplinkWithUrl:url];
[Airbridge trackDeeplinkWithUserActivity:userActivity];

import Airbridge
...
// handle deeplink
var isHandled = Airbridge.handleDeeplink(url: url) { url in
    // when app is opened with airbridge deeplink
    // show proper content using url (YOUR_SCHEME://...)
}
if isHandled { return }

// when app is opened with other deeplink
// use existing logic as it is
...
// handle deeplink
var isHandled = Airbridge.handleDeeplink(userActivity: userActivity) { url in
    // when app is opened with airbridge deeplink
    // show proper content using url (YOUR_SCHEME://...)
}
if isHandled { return }

// when app is opened with other deeplink
// use existing logic as it is

#import <Airbridge/Airbridge.h>
...
// handle deeplink
BOOL isHandled = [Airbridge handleDeeplinkWithUrl:url onSuccess:^(NSURL* url) {
    // when app is opened with airbridge deeplink
    // show proper content using url (YOUR_SCHEME://...)
}];
if (isHandled) { return; }

// when app is opened with other deeplink
// use existing logic as it is
...
// handle deeplink
BOOL isHandled = [Airbridge handleDeeplinkWithUserActivity:userActivity onSuccess:^(NSURL* url) {
    // when app is opened with airbridge deeplink
    // show proper content using url (YOUR_SCHEME://...)
}];
if (isHandled) { return; }

// when app is opened with other deeplink
// use existing logic as it is

import Airbridge
...
Airbridge.trackDeeplink(url: url)
Airbridge.trackDeeplink(userActivity: userActivity)

#import <Airbridge/Airbridge.h>
...
[Airbridge trackDeeplinkWithUrl:url];
[Airbridge trackDeeplinkWithUserActivity:userActivity];

import Airbridge
...
// when app is opened with scheme deeplink
func application(
    _ app: UIApplication,
    open url: URL,
    options: [UIApplication.OpenURLOptionsKey : Any] = [:]
) -> Bool {
    // track deeplink
    Airbridge.trackDeeplink(url: url)

    return true
}

#import <Airbridge/Airbridge.h>
...
// when app is opened with scheme deeplink
- (BOOL)application:(UIApplication *)app openURL:(NSURL *)url options:(NSDictionary<UIApplicationOpenURLOptionsKey,id> *)options {
    // track deeplink
    [Airbridge trackDeeplinkWithUrl:url];

    return YES;
}

// when app is opened with universal links
func application(
    _ application: UIApplication,
    continue userActivity: NSUserActivity,
    restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
) -> Bool {
    // track deeplink
    Airbridge.trackDeeplink(userActivity: userActivity)

    return true
}

#import <Airbridge/Airbridge.h>
...
// when app is opened with universal links
- (BOOL)application:(UIApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void (^)(NSArray<id<UIUserActivityRestoring>> * _Nullable))restorationHandler {
    // track deeplink
    [Airbridge trackDeeplinkWithUserActivity:userActivity];

    return YES;
}

import Airbridge
...
// handle deeplink
var isHandled = Airbridge.handleDeeplink(url: url) { url in
    // when app is opened with airbridge deeplink
    // show proper content using url (YOUR_SCHEME://...)
}
if isHandled { return }

// when app is opened with other deeplink
// use existing logic as it is
...
// handle deeplink
var isHandled = Airbridge.handleDeeplink(userActivity: userActivity) { url in
    // when app is opened with airbridge deeplink
    // show proper content using url (YOUR_SCHEME://...)
}
if isHandled { return }

// when app is opened with other deeplink
// use existing logic as it is

#import <Airbridge/Airbridge.h>
...
// handle deeplink
BOOL isHandled = [Airbridge handleDeeplinkWithUrl:url onSuccess:^(NSURL* url) {
    // when app is opened with airbridge deeplink
    // show proper content using url (YOUR_SCHEME://...)
}];
if (isHandled) { return; }

// when app is opened with other deeplink
// use existing logic as it is
...
// handle deeplink
BOOL isHandled = [Airbridge handleDeeplinkWithUserActivity:userActivity onSuccess:^(NSURL* url) {
    // when app is opened with airbridge deeplink
    // show proper content using url (YOUR_SCHEME://...)
}];
if (isHandled) { return; }

// when app is opened with other deeplink
// use existing logic as it is

import Foundation
...
// when app is opened with airbridge deeplink
func handleAirbridgeDeeplink(url: URL) {
    // show proper content using url (YOUR_SCHEME://...)
}

import Foundation
...
// when app is opened with airbridge deeplink
- (void)handleAirbridgeDeeplink:(NSURL *)url {
    // show proper content using url (YOUR_SCHEME://...)
}

import Airbridge
...
// when app is opened with scheme deeplink
func application(
    _ app: UIApplication,
    open url: URL,
    options: [UIApplication.OpenURLOptionsKey : Any] = [:]
) -> Bool {
    // track deeplink
    Airbridge.trackDeeplink(url: url)

    // handle deeplink
    var isHandled = Airbridge.handleDeeplink(url: url) { url in
        // when app is opened with airbridge deeplink
        // show proper content using url (YOUR_SCHEME://...)
        handleAirbridgeDeeplink(url: url)
    }
    if isHandled { return true }

    // when app is opened with other deeplink
    // use existing logic as it is

    return isHandled
}

#import <Airbridge/Airbridge.h>
...
// when app is opened with scheme deeplink
- (BOOL)application:(UIApplication *)app openURL:(NSURL *)url options:(NSDictionary<UIApplicationOpenURLOptionsKey,id> *)options {
    // track deeplink
    [Airbridge trackDeeplinkWithUrl:url];

    // handle deeplink
    BOOL isHandled = [Airbridge handleDeeplinkWithUrl:url onSuccess:^(NSURL* url) {
        // when app is opened with airbridge deeplink
        // show proper content using url (YOUR_SCHEME://...)
        [self handleAirbridgeDeeplink:url];
    }];
    if (isHandled) { return YES; }

    // when app is opened with other deeplink
    // use existing logic as it is

    return isHandled;
}

// when app is opened with universal links
func application(
    _ application: UIApplication,
    continue userActivity: NSUserActivity,
    restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
) -> Bool {
    // track deeplink
    Airbridge.trackDeeplink(userActivity: userActivity)

    // handle deeplink
    var isHandled = Airbridge.handleDeeplink(userActivity: userActivity) { url in
        // when app is opened with airbridge deeplink
        // show proper content using url (YOUR_SCHEME://...)
        handleAirbridgeDeeplink(url: url)
    }
    if isHandled { return true }

    // when app is opened with other deeplink
    // use existing logic as it is

    return isHandled
}

#import <Airbridge/Airbridge.h>
...
// when app is opened with universal links
- (BOOL)application:(UIApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void (^)(NSArray<id<UIUserActivityRestoring>> * _Nullable))restorationHandler {
    // track deeplink
    [Airbridge trackDeeplinkWithUserActivity:userActivity];

    // handle deeplink
    BOOL isHandled = [Airbridge handleDeeplinkWithUserActivity:userActivity onSuccess:^(NSURL* url) {
        // when app is opened with airbridge deeplink
        // show proper content using url (YOUR_SCHEME://...)
        [self handleAirbridgeDeeplink:url];
    }];
    if (isHandled) { return YES; }

    // when app is opened with other deeplink
    // use existing logic as it is

    return isHandled;
}

import Airbridge
...
// track standard event (provided by sdk)
Airbridge.trackEvent(category: AirbridgeCategory.ORDER_COMPLETED)
// track standard event (not provided by sdk)
Airbridge.trackEvent(category: "airbridge.ecommerce.order.canceled")
// track custom event
Airbridge.trackEvent(category: "eventViewed")

#import <Airbridge/Airbridge.h>
...
// track standard event (provided by sdk)
[Airbridge trackEventWithCategory:AirbridgeCategory.ORDER_COMPLETED];
// track standard event (not provided by sdk)
[Airbridge trackEventWithCategory:@"airbridge.ecommerce.order.canceled"];
// track custom event
[Airbridge trackEventWithCategory:@"eventViewed"];

import Airbridge
...
Airbridge.trackEvent(
    category: AirbridgeCategory.ORDER_COMPLETED,
    semanticAttributes: [
        // action
        AirbridgeAttribute.ACTION: "Tool",
        // label
        AirbridgeAttribute.LABEL: "Hammer",
        // value
        AirbridgeAttribute.VALUE: 10,
        // semantic attribute (provided by sdk)
        AirbridgeAttribute.CURRENCY: "USD",
        AirbridgeAttribute.PRODUCTS: [
            [
                // semantic attribute value (provided by sdk)
                AirbridgeAttribute.PRODUCT_ID: "12345",
                // semantic attribute value (not provided by sdk)
                "name": "PlasticHammer",
            ],
        ],
        // semantic attribute (not provided by sdk)
        "totalQuantity": 1,
    ],
    customAttributes: [
        // custom attribute
        "promotion": "FirstPurchasePromotion",
    ]
)

#import <Airbridge/Airbridge.h>
...
[Airbridge trackEventWithCategory:@"event" semanticAttributes:@{
    // action
    AirbridgeAttribute.ACTION: @"Tool",
    // label
    AirbridgeAttribute.LABEL: @"Hammer",
    // value
    AirbridgeAttribute.VALUE: @(10),
    // semantic attribute (provided by sdk)
    AirbridgeAttribute.CURRENCY: @"USD",
    AirbridgeAttribute.PRODUCTS: @[
        @{
            // semantic attribute value (provided by sdk)
            AirbridgeAttribute.PRODUCT_ID: @"12345",
            // semantic attribute value (not provided by sdk)
            @"name": @"PlasticHammer",
        },
    ],
    // semantic attribute (not provided by sdk)
    @"totalQuantity": @(1),
}, customAttributes:@{
    // custom attribute
    @"promotion": @"FirstPurchasePromotion",
}];