Data Fetching Guide for iOS - Airbridge Help Center

Airbridge Device ID

Device identifier by Airbridge. (example: 82A16EC9-A273-48B6-9BB2-017EAB641109)

iOS SDK

import Airbridge

Airbridge.fetchDeviceUUID { deviceUUID in

}

#import <Airbridge/Airbridge.h>

[Airbridge fetchDeviceUUID:^(NSString * _Nonnull deviceUUID) {

}];

iOS SDK (Deprecated)

import AirBridge

AirBridge.deviceUUID

#import <AirBridge/AirBridge.h>

AirBridge.deviceUUID;

Airbridge Generated ID

Random UUID assigned by Airbridge upon app install on each device. (example: 82A16EC9-A273-48B6-9BB2-017EAB641109)

iOS SDK

import Airbridge

Airbridge.fetchAirbridgeGeneratedUUID { airbridgeGeneratedUUID in

}

    #import <Airbridge/Airbridge.h>

    [Airbridge fetchAirbridgeGeneratedUUID:^(NSString * _Nonnull airbridgeGeneratedUUID) {
        
    }];

iOS SDK (Deprecated)

import AirBridge

AirBridge.fetchAirbridgeGeneratedUUID { uuid in

}

    #import <AirBridge/AirBridge.h>

    [AirBridge fetchAirbridgeGeneratedUUID:^(NSString * _Nonnull uuid) {
        
    }];

ATT (App Tracking Transparency)

On iOS 14.5 and later, apps must obtain consent through ATT (App Tracking Transparency) to track users across other companies’ apps and websites or access the IDFA. Users can choose whether to allow tracking in the system prompt. You can use the Airbridge iOS SDK to request ATT authorization and check the current authorization status. Your app must explicitly call the authorization request API.

Before you begin

Initialize the Airbridge SDK before calling these APIs.
These APIs are available in the standard iOS SDK and are not provided in the Restricted SDK.
Add NSUserTrackingUsageDescription to your app’s Info.plist. This value explains the tracking purpose in the ATT prompt. Replace the example text below with a description of your app’s actual data usage.

<key>NSUserTrackingUsageDescription</key>
<string>[Describe your app's actual tracking purpose]</string>

Request ATT authorization

Call requestTrackingAuthorization to forward an authorization request to Apple’s ATT API. The SDK does not wait for the app to become active, so call this API while the app is active. To request authorization at app launch, call it after SDK initialization when the app becomes active, such as in applicationDidBecomeActive or sceneDidBecomeActive. Interpret the return value separately from the completion handler:

A return value of true means the SDK accepted the request for processing. It does not indicate whether the prompt appeared or whether the user authorized tracking.
If the SDK is not initialized or is disabled, the API returns false without calling the completion handler.
The completion handler runs on the main queue and receives the ATT status as AirbridgeTrackingAuthorization.

import Airbridge

// Call after SDK initialization while the app is active.
let accepted = Airbridge.requestTrackingAuthorization { status in
    // Handle the ATT result on the main queue.
    switch status {
    case .notDetermined:
        // The user has not made a decision yet.
        break
    case .authorized:
        // Tracking is authorized.
        break
    case .denied:
        // Tracking is denied.
        break
    case .restricted:
        // Tracking is restricted.
        break
    @unknown default:
        break
    }
}

if !accepted {
    // The request was not accepted and the completion handler will not be called.
    // Check that the SDK is initialized and enabled.
}

#import <Airbridge/Airbridge.h>

// Call after SDK initialization while the app is active.
BOOL accepted = [Airbridge requestTrackingAuthorizationWithCompletionHandler:^(AirbridgeTrackingAuthorization status) {
    // Handle the ATT result on the main queue.
    switch (status) {
        case AirbridgeTrackingAuthorizationNotDetermined:
            // The user has not made a decision yet.
            break;
        case AirbridgeTrackingAuthorizationAuthorized:
            // Tracking is authorized.
            break;
        case AirbridgeTrackingAuthorizationDenied:
            // Tracking is denied.
            break;
        case AirbridgeTrackingAuthorizationRestricted:
            // Tracking is restricted.
            break;
    }
}];

if (!accepted) {
    // The request was not accepted and the completion handler will not be called.
    // Check that the SDK is initialized and enabled.
}

Check the ATT authorization status

trackingAuthorizationStatus() synchronously returns the current ATT status. Checking the status does not display the ATT prompt or request authorization. If the SDK is not initialized or is disabled, the API returns notDetermined. In this case, first check that the SDK is initialized and enabled.

import Airbridge

let status = Airbridge.trackingAuthorizationStatus()

switch status {
case .notDetermined:
    // The user has not made a decision yet.
    break
case .authorized:
    // Tracking is authorized.
    break
case .denied:
    // Tracking is denied.
    break
case .restricted:
    // Tracking is restricted.
    break
@unknown default:
    break
}

#import <Airbridge/Airbridge.h>

AirbridgeTrackingAuthorization status = [Airbridge trackingAuthorizationStatus];

switch (status) {
    case AirbridgeTrackingAuthorizationNotDetermined:
        // The user has not made a decision yet.
        break;
    case AirbridgeTrackingAuthorizationAuthorized:
        // Tracking is authorized.
        break;
    case AirbridgeTrackingAuthorizationDenied:
        // Tracking is denied.
        break;
    case AirbridgeTrackingAuthorizationRestricted:
        // Tracking is restricted.
        break;
}

Understand ATT statuses

Both the request result and the status query use AirbridgeTrackingAuthorization.

Status	Meaning
`notDetermined`	The user has not made a decision yet.
`authorized`	Tracking is authorized.
`denied`	Tracking is denied.
`restricted`	Tracking is not allowed due to device or system restrictions.

In environments that do not support ATT, such as iOS versions earlier than 14, requests and status queries return authorized when the standard SDK is initialized and enabled. This is the SDK’s return value for unsupported environments and must not be interpreted as user consent through an ATT prompt. You do not need to add an iOS version check in your app to call these APIs.

If the prompt does not appear

Whether the ATT prompt appears depends on Apple’s behavior and the user’s settings. The prompt may not appear even when the request returns true. Check the following:

Make sure the app is active. The prompt may not appear if you request authorization before the app becomes active or while it is in the background.
Check whether another permission request, such as notifications, is waiting for a response. Request ATT authorization after the previous request completes instead of making permission requests simultaneously. iOS does not retain simultaneous permission requests to display later.
Check the completion handler or status query result. If the status is notDetermined, check the display conditions and request authorization again from your app as needed. The SDK does not automatically retry or merge duplicate requests.
Check whether the user denied tracking in Settings or the system restricts tracking requests. Calling the API again after the status has been determined does not guarantee that the prompt will reappear or that authorization will change.
Check the NSUserTrackingUsageDescription value in Info.plist.

Users can change tracking permissions in Settings. Check the current status when needed, such as when the app becomes active again. The SDK’s status query does not subscribe to settings changes in real time. For prompt and permission request conditions, refer to Apple’s ATT request documentation.

Use with the existing ATT timeout setting

Consider the ATT authorization request API together with the SDK’s existing ATT decision timeout setting. The SDK’s existing ATT status checks and processing wait behavior remain unchanged. By default, processing for the install event, deferred deep links, and attribution waits up to 30 seconds for the ATT status to be determined. If you configured a different timeout, that value applies. requestTrackingAuthorization forwards the authorization request without restarting or extending the existing timeout. trackingAuthorizationStatus() does not change ATT decision processing or the stored processing state. If the timeout expires while ATT authorization is still undetermined, the SDK’s pending processing may proceed. Review the existing autoDetermineTrackingAuthorizationTimeout setting based on when your app requests authorization and how much time users need to respond. This setting controls the SDK’s processing wait time and does not change whether the ATT prompt appears or the user’s authorization status.

IDFA

Advertising ID issued by Apple. (example: 82A16EC9-A273-48B6-9BB2-017EAB641109)

import AdSupport

ASIdentifierManager.shared().advertisingIdentifier.uuidString

#import <AdSupport/AdSupport.h>

ASIdentifierManager.sharedManager.advertisingIdentifier.UUIDString;

IDFV

Unique ID that publishers can use to identify which apps a specific user has installed. (example: 82A16EC9-A273-48B6-9BB2-017EAB641109)

UIDevice.current.identifierForVendor?.uuidString

UIDevice.currentDevice.identifierForVendor.UUIDString;

Limit Ad Tracking

Device’s Limit AD Tracking information. (example: true)

import AdSupport

ASIdentifierManager.shared().isAdvertisingTrackingEnabled

#import <AdSupport/AdSupport.h>

ASIdentifierManager.sharedManager.advertisingTrackingEnabled;

Device Model

Device model name. (example: iPhone)

UIDevice.current.localizedModel

UIDevice.currentDevice.localizedModel;

Device Identifier

Device identifier name. (example: iPhone9,3)

var systemInfo = utsname()
uname(&systemInfo)
        
return String(cString: &systemInfo.machine.0, encoding: .utf8)

#import <sys/utsname.h>

struct utsname systemInfo;
uname(&systemInfo);
        
return [NSString stringWithCString:systemInfo.machine
                          encoding:NSUTF8StringEncoding];

Device Manufacturer

Device manufacturer information. (example: Apple)

"Apple"

@"Apple"

OS Name

Device OS name. (example: iOS)

UIDevice.current.systemName

UIDevice.currentDevice.systemName;

OS Version

Device OS version. (example: 13.3)

UIDevice.current.systemVersion

UIDevice.currentDevice.systemVersion;

Locale

Device locale settings. (example: ko-KR)

func getSystemLocale() -> String? {
    guard let language = getSystemLanguage() else { return nil }
    guard let country = getSystemCountry() else { return nil }
    
    return "\(language)-\(country)"
}

func getSystemLanguage() -> String? {
    let languages = Locale.preferredLanguages
    
    if languages.count < 1 {
        return nil
    }
    
    let languageSource = languages[0]
    
    guard let barIndex = languageSource.range(of: "-") else {
        return languageSource
    }
    
    return String(languageSource[..<barIndex.lowerBound])
}

func getSystemCountry() -> String? {
    return Locale.autoupdatingCurrent.regionCode
}

+ (NSString *)getSystemLocale {
    NSString* language = [#ClassName# getSystemLanguage];
    NSString* country = [#ClassName# getSystemCountry];
    if(language == nil || country == nil) {
        return nil;
    }
    return [NSString stringWithFormat:@"%@-%@", language, country];
}

+ (NSString*) getSystemLanguage {
    NSArray* preferredLanguages = NSLocale.preferredLanguages;
    if (preferredLanguages.count < 1) {
        return nil;
    }
    NSString* languageSource = preferredLanguages[0];
    if (languageSource == nil) {
        return nil;
    }
    NSRange barIndex = [languageSource rangeOfString:@"-"];
    if (barIndex.location != NSNotFound) {
        languageSource = [languageSource substringToIndex:barIndex.location];
    }
    return languageSource;
}

+ (NSString*) getSystemCountry {
    NSLocale* locale = NSLocale.autoupdatingCurrentLocale;
    if (locale == nil) {
        return nil;
    }
    return [locale objectForKey:NSLocaleCountryCode];
}

Timezone

Device timezone settings. (example: US/Pacific)

TimeZone.current.description

NSTimeZone.systemTimeZone.name;

Orientation

Device display orientation. Values will be either “portrait” or “landscape”. (example: portrait)

if UIDevice.current.orientation.isLandscape {
    return @"landscape"
} else {
    return @"portrait"
}

UIInterfaceOrientation orientation = [UIApplication sharedApplication].statusBarOrientation;
if (UIInterfaceOrientationIsLandscape(orientation))
    return @"landscape";
else
    return @"portrait";

Screen Density

Device’s screen density. (example: 3.000)

String(format: "%.3f", UIScreen.main.scale)

[NSString stringWithFormat:@"%.3f", UIScreen.mainScreen.scale];

Screen Width

Device’s actual width. (example: 375.0)

String(format: "%.f", UIScreen.main.bounds.size.width)

[NSString stringWithFormat:@"%.f", UIScreen.mainScreen.bounds.size.width];

Screen Height

Device’s actual height. (example: 667.0)

String(format: "%.f", UIScreen.main.bounds.size.height)

[NSString stringWithFormat:@"%.f", UIScreen.mainScreen.bounds.size.height];

Network Carrier

Device network carrier information.

import CoreTelephony

let info = CTTelephonyNetworkInfo()

if #available(iOS 12.1, *) {
    let providers = info.serviceSubscriberCellularProviders
    return providers?.values.first?.carrierName
} else {
    let provider = info.subscriberCellularProvider
    return provider?.carrierName
}

#import <CoreTelephony/CTCarrier.h>
#import <CoreTelephony/CTTelephonyNetworkInfo.h>

CTTelephonyNetworkInfo* networkInfo = [[CTTelephonyNetworkInfo alloc] init];

if (@available(iOS 12.1, *)) {
    NSDictionary<NSString*, CTCarrier*>* providers = [networkInfo serviceSubscriberCellularProviders];
    return providers.allValues.firstObject.carrierName;
} else {
    CTCarrier* provider = [networkInfo subscriberCellularProvider];
    return provider.carrierName;
}

Cellular Status

Device mobile data status. (example: true)

import SystemConfiguration

func isCellular() -> Bool {
    return network() == .cellular
}

enum Network {
    case wifi
    case cellular
    case none
}

func getNetworkInfo() -> Network {
    var zeroAddress = sockaddr()
    bzero(&zeroAddress, MemoryLayout.size(ofValue: zeroAddress))
    zeroAddress.sa_len = __uint8_t(MemoryLayout.size(ofValue: zeroAddress))
    zeroAddress.sa_family = sa_family_t(AF_INET)

    guard let reachability = SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, &zeroAddress) else {
        return .none
    }

    var flags = SCNetworkReachabilityFlags()
    if !SCNetworkReachabilityGetFlags(reachability, &flags) {
        return .none
    }

    if !flags.contains(.reachable) {
        return .none
    }

    if flags.contains(.connectionRequired)
        && !((flags.contains(.connectionOnDemand) || flags.contains(.connectionOnTraffic))
            && !flags.contains(.interventionRequired)) {
        return .none
    }
    
    if flags.contains(.isWWAN) {
        return .cellular
    } else {
        return .wifi
    }
}

#import <SystemConfiguration/SystemConfiguration.h>
#import <netinet/in.h>

+ (BOOL) isCellular {
    return [#ClassName# getNetworkInfo] == CELLULAR;
}

typedef enum : NSInteger {
    WIFI,
    CELLULAR,
    NONE
} ABNetwork;

+ (ABNetwork) getNetworkInfo {
    struct sockaddr_in zeroAddress;
    bzero(&zeroAddress, sizeof(zeroAddress));
    zeroAddress.sin_len = sizeof(zeroAddress);
    zeroAddress.sin_family = AF_INET;
    SCNetworkReachabilityRef reachability
        = SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, (const struct sockaddr *) &zeroAddress);
    if (reachability == nil) {
        return NONE;
    }
    SCNetworkReachabilityFlags flags;
    if (!SCNetworkReachabilityGetFlags(reachability, &flags)) {
        return NONE;
    }
    if ((flags & kSCNetworkReachabilityFlagsReachable) == 0) {
        return NONE;
    }
    if (((flags & kSCNetworkReachabilityFlagsConnectionRequired) != 0)
        && !(((flags & kSCNetworkReachabilityFlagsConnectionOnDemand ) != 0 || (flags & kSCNetworkReachabilityFlagsConnectionOnTraffic) != 0)
             && (flags & kSCNetworkReachabilityFlagsInterventionRequired) == 0))
    {
        return NONE;
    }
    if ((flags & kSCNetworkReachabilityFlagsIsWWAN) == kSCNetworkReachabilityFlagsIsWWAN) {
        return CELLULAR;
    } else {
        return WIFI;
    }
}

WiFi Status

Device wifi status. (example: true)

import SystemConfiguration

func isWifi() -> Bool {
    return network() == .wifi
}

enum Network {
    case wifi
    case cellular
    case none
}

func getNetworkInfo() -> Network {
    var zeroAddress = sockaddr()
    bzero(&zeroAddress, MemoryLayout.size(ofValue: zeroAddress))
    zeroAddress.sa_len = __uint8_t(MemoryLayout.size(ofValue: zeroAddress))
    zeroAddress.sa_family = sa_family_t(AF_INET)

    guard let reachability = SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, &zeroAddress) else {
        return .none
    }

    var flags = SCNetworkReachabilityFlags()
    if !SCNetworkReachabilityGetFlags(reachability, &flags) {
        return .none
    }

    if !flags.contains(.reachable) {
        return .none
    }

    if flags.contains(.connectionRequired)
        && !((flags.contains(.connectionOnDemand) || flags.contains(.connectionOnTraffic))
            && !flags.contains(.interventionRequired)) {
        return .none
    }
    
    if flags.contains(.isWWAN) {
        return .cellular
    } else {
        return .wifi
    }
}

#import <SystemConfiguration/SystemConfiguration.h>
#import <netinet/in.h>

+ (BOOL) isWifi {
    return [#ClassName# getNetworkInfo] == WIFI;
}

typedef enum : NSInteger {
    WIFI,
    CELLULAR,
    NONE
} ABNetwork;

+ (ABNetwork) getNetworkInfo {
    struct sockaddr_in zeroAddress;
    bzero(&zeroAddress, sizeof(zeroAddress));
    zeroAddress.sin_len = sizeof(zeroAddress);
    zeroAddress.sin_family = AF_INET;
    SCNetworkReachabilityRef reachability
        = SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, (const struct sockaddr *) &zeroAddress);
    if (reachability == nil) {
        return NONE;
    }
    SCNetworkReachabilityFlags flags;
    if (!SCNetworkReachabilityGetFlags(reachability, &flags)) {
        return NONE;
    }
    if ((flags & kSCNetworkReachabilityFlagsReachable) == 0) {
        return NONE;
    }
    if (((flags & kSCNetworkReachabilityFlagsConnectionRequired) != 0)
        && !(((flags & kSCNetworkReachabilityFlagsConnectionOnDemand ) != 0 || (flags & kSCNetworkReachabilityFlagsConnectionOnTraffic) != 0)
             && (flags & kSCNetworkReachabilityFlagsInterventionRequired) == 0))
    {
        return NONE;
    }
    if ((flags & kSCNetworkReachabilityFlagsIsWWAN) == kSCNetworkReachabilityFlagsIsWWAN) {
        return CELLULAR;
    } else {
        return WIFI;
    }
}

Package Name

Application package name. (example: co.ab180.ablog)

Bundle.main.bundleIdentifier

NSBundle.mainBundle.bundleIdentifier;

Version

Application version name. (example: 1.0.0)

Bundle.main.infoDictionary?["CFBundleShortVersionString"]

[NSBundle.mainBundle.infoDictionary objectForKey:@"CFBundleShortVersionString"];

Event Timestamp

Timestamp(milliseconds) of when the event was sent. (example: 1581043739682)

UInt64(Date().timeIntervalSince1970 * 1000)

[NSNumber numberWithUnsignedLongLong:NSDate.date.timeIntervalSince1970 * 1000];

​Airbridge Device ID

​iOS SDK

​iOS SDK (Deprecated)

​Airbridge Generated ID

​iOS SDK

​iOS SDK (Deprecated)

​ATT (App Tracking Transparency)

​Before you begin

​Request ATT authorization

​Check the ATT authorization status

​Understand ATT statuses

​If the prompt does not appear

​Use with the existing ATT timeout setting

​IDFA

​IDFV

​Limit Ad Tracking

​Device Model

​Device Identifier

​Device Manufacturer

​OS Name

​OS Version

​Locale

​Timezone

​Orientation

​Screen Density

​Screen Width

​Screen Height

​Network Carrier

​Cellular Status

​WiFi Status

​Package Name

​Version

​Event Timestamp

Airbridge Device ID

iOS SDK

iOS SDK (Deprecated)

Airbridge Generated ID

iOS SDK

iOS SDK (Deprecated)

ATT (App Tracking Transparency)

Before you begin

Request ATT authorization

Check the ATT authorization status

Understand ATT statuses

If the prompt does not appear

Use with the existing ATT timeout setting

IDFA

IDFV

Limit Ad Tracking

Device Model

Device Identifier

Device Manufacturer

OS Name

OS Version

Locale

Timezone

Orientation

Screen Density

Screen Width

Screen Height

Network Carrier

Cellular Status

WiFi Status

Package Name

Version

Event Timestamp