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

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

import Airbridge
import AppTrackingTransparency
...
var observer: Any?
...
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)
    }
}

#import <Airbridge/Airbridge.h>
#import <AppTrackingTransparency/AppTrackingTransparency.h>
...
id observer;
...
AirbridgeOptionBuilder* optionBuilder = [[AirbridgeOptionBuilder alloc] initWithName:@"YOUR_APP_NAME"
                                                                               token:@"YOUR_APP_SDK_TOKEN"];
[optionBuilder setAutoDetermineTrackingAuthorizationEnabled:NO];
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];
    }
}];

import SwiftUI
import Airbridge
import AppTrackingTransparency

@main
struct ExampleApp: App {
    var observer: Any?

    init() {
        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)
            }
        }
    }
    
    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 }

    // 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; }

    // 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 }

    // 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; }

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

    return isHandled;
}