Unity SDK - Airbridge Help Center

Install the Airbridge SDK and implement the necessary settings by following the steps below.

Install SDK

The Airbridge Unity SDK can be installed using the method below. After installation, you can confirm whether the SDK has been properly installed through the Unity SDK Test. Depending on policies and environments, restrictions on collecting device IDs like GAID and IDFA may be required. When installing the Restricted SDK version, the device IDs are not collected.

Unity Package Manager
Manual installation

In Unity, click Window > Package Manager from the top menu.
Click the + button in the upper-left corner of the Package Manager window.
Add package from git URL…
Enter the following URL and click Install.
- https://github.com/ab180/airbridge-unity-sdk-deployment.git

To install the SDK that does not collect device IDs, enter the following Restricted SDK URL and click Install.

https://github.com/ab180/airbridge-unity-sdk-restricted-deployment

After installation, the Airbridge tab appears at the top of Unity.

Initialize SDK

Enter the correct App Name and App Token values in the SDK Settings window. The App Name and App Token can be found on the [Settings]>[Tokens] page in the Airbridge dashboard.

Configure SDK settings

Select [Airbridge]>[Airbridge Settings] from the top menu bar in Unity to open the SDK settings window. You may fill in the fields or click on the checkboxes that are necessary for your service.

NoteFor Airbridge Unity SDK v4.2.0 or earlier, select AB180 > Airbridge Settings from the top menu bar in Unity.

Configuring SDK settings per build setting

NoteAirbridge Unity SDK v.4.5.0 or later is required.

You can apply different SDK settings per build setting. For more details, refer to this section.

References for configuring the SDK settings

Key Value	Reference
App Name	Initialize SDK Enable app launch with Airbridge Deep Links
App Token	Initialize SDK
Log Level	SDK logs
iOS URI Scheme	Enable app launch with Airbridge Deep Links
Android URI Scheme	Enable app launch with Airbridge Deep Links
Custom Domain	Set up Custom Domain
Session Timeout Seconds	Configure in-app event sessions
User Info Hash Enabled	Hash user information
Track Airbridge Link Only	Track only Airbridge Deep Links
Auto Start Tracking Enabled	Opt-in setup Opt-out setup
Facebook Deferred App Link Enabled	Set up Meta deferred app links
iOS Tracking Authorize Timeout Seconds	Configure ATT prompt
SDK Signature Secret ID	SDK Signature
SDK Signature Secret	SDK Signature
Track In Session Life Cycle Event Enabled	Collect in-session lifecycle events
Clear Event Buffer On Initialize Enabled	Clear unsent in-app events
SDK Enabled	Initialize the Airbridge SDK with all functions disabled
Event Buffer Count Limit	Configure in-app event storage
Event Buffer Size Limit In Gibibyte	Configure in-app event storage
Event Transmit Interval Seconds	Configure in-app event transmission frequency
Meta Install Referrer (Facebook App ID)	Set up Meta Install Referrer collection
Is Handle Airbridge Deeplink Only	Receive Airbridge Deep Links only
Calculate SKAdNetwork By Server Enabled	Calculating SKAdNetwork Conversion Value on the Server

Configure ATT prompt

NoteThe functions necessary to ensure compliance with privacy policies should be reviewed with legal counsel.

In the iOS environment, the IDFA can only be collected when users consent to data tracking through the App Tracking Transparency (ATT) prompt. Event collection should be delayed until the user allows tracking. If the install event is collected before the user allows tracking through the ATT prompt, the install event data will lack an identifier, making performance measurement difficult. We recommend setting a sufficient delay time for event collection to collect identifiers.

Prepare the text you will use in the ATT prompt.
Provide the ATT prompt following this guide provided by Apple.
If the install event is not collected, the Airbridge React Native SDK delays collecting install events for 30 seconds until the user allows tracking each time the app is launched. If the user exits the app before deciding whether to allow tracking, the SDK will not collect the install event and will try again at the next app launch.

In the SDK settings, configure the iOS Tracking Authorize Timeout Seconds to set a sufficient delay time for collecting install events. The default value is 30 seconds, and it can be set to up to 3600 seconds (1 hour).

AttentionSet a sufficient delay time to collect the app install event. If the SDK collects install events before users can allow tracking on the ATT prompt, the IDFA won’t be collected along with the install events.

Opt-in setup

AttentionOptional settings. Configure only if necessary.

The opt-in policy requires user consent before using user data. After setting the Auto Start Tracking Enabled in the SDK settings to false, call the StartTracking function at the point of time when you can collect events. The SDK will start collecting events when the startTracking function is called.

Airbridge.StartTracking();

Opt-out setup

AttentionOptional settings. Configure only if necessary.

The opt-out policy allows the use of user information until the user explicitly declines. After setting the Auto Start Tracking Enabled in the SDK settings to true, call the StopTracking function at the point of time when you can no longer collect events. The SDK will stop collecting events when the stopTracking function is called.

Airbridge.StopTracking();

SDK Signature

AttentionOptional settings. Configure only if necessary.

With the SDK Signature, you can prevent SDK spoofing and use verified events to measure ad performance. The SDK Signature credentials, which are the Secret ID and the Secret, are required for the SDK Signature setup. They can be found on the [Management]>[Fraud Validation Rules]>[SDK Signature] page in the Airbridge dashboard. For more details on how to find the SDK Signature credentials, refer to this Airbridge guide. Once you have the credentials, go to the SDK settings and enter the Secret ID as sdkSignatureID and the Secret as sdkSignatureSecret.

Deep Linking

Deep linking allows you to redirect users from ads to specific locations within your app. The data collected from the tracking link enables you to monitor the performance of the deep link in Airbridge.

How Airbridge Deep Links work

When a user clicks on the Airbridge tracking link, the scheme deep link embedded in the tracking link is converted into an Airbridge Deep Link, which can be either an HTTP deep link or a scheme deep link. This Airbridge Deep Link redirects the user to the desired app location. Then, the Airbridge SDK converts the Airbridge Deep Link back to the original scheme deep link embedded in the tracking link and passes it to the app.

Example scheme deep link embedded in the tracking link: YOUR_SCHEME://product/12345
Examples of Airbridge Deep Links
- HTTP deep link format 1: https://YOUR_APP_NAME.airbridge.io/~~~
- HTTP deep link format 2: https://YOUR_APP_NAME.abr.ge/~~~
- Scheme deep link format: YOUR_SCHEME://product/12345?airbridge_referrer=~~~

When the app is installed on the device and the tracking link is clicked, the app opens through the Airbridge Deep Link. The Airbridge SDK converts the Airbridge Deep Link into the scheme deep embedded in the tracking link and passes it to the app. When the app is not installed on the device and the tracking link is clicked, the Airbridge SDK saves the Airbridge Deep Link. After the user is redirected to the app store or website and the app is installed and launched, the Airbridge SDK converts the saved Airbridge Deep Link into the scheme deep link embedded in the tracking link and passes it to the app.

Set up deep linking

For the deep linking setup, the following information is required.

Deep link information submitted in the Airbridge dashboard
In-app location address for user redirection

First, submit the deep link information to the Airbridge dashboard.

How to enter the deep link information into Airbridge dashboard

For the deep linking setup, the following information must be entered into the Airbridge dashboard.

iOS

iOS URI scheme: The Airbridge Deep Link is converted to a scheme deep link using the iOS URI scheme.
iOS App ID: The universal link domain of the Airbridge Deep Link is set using the iOS App ID.

Android

Android URI scheme: The Airbridge deep link is converted to a scheme deep link using the Android URI scheme. This information is necessary for the App Link and URI scheme.
Package name: This is the Android app identifier necessary for the App Link and URI scheme.
Android sha256_cert_fingerprints: This is used for setting the App Link domain. This information is necessary for the App Link.

AttentionTo properly redirect users as intended, submit different information for the production app and the development app.

Follow the steps below to submit the necessary information to the Airbridge dashboard.

iOS

Navigate to [Tracking Link]>[Deep Links] in the Airbridge dashboard.
Enter the iOS URI scheme in the iOS URI Scheme field. Include ://. For example, if the iOS URI scheme is demo, enter demo://.
In the Apple Developer Dashboard, navigate to [Identifier] of the app you want to set up the deep link. Find the App ID Prefix and Bundle ID.
The iOS App ID is in the format of App ID Prefix+ . + Bundle ID. Enter the iOS App ID into the iOS App ID field. For example, if the App ID Prefix is prefix and the Bundle ID is example, the iOS App ID is prefix.example.

Android

For apps that use Google Play’s Play App Signing, Google’s servers re-sign the APK after the developer uploads it. This changes the Android sha256_cert_fingerprints, so you must register the final signing value from the Google Play Console—not from your local keystore—for App Links to work correctly. Register the Android URI scheme, package name, and Android sha256_cert_fingerprints in Airbridge according to your signing method.

Play App signing
using original key

Naviagate to [Tracking Link]>[Deep Links] in the Airbridge dashboard.
Enter the Android URI scheme into the Android URI Scheme field. Include ://. For example, if the URI scheme is demo, you must enter demo://.
Enter the package name in the Package name field.
Go to the Google Play Console and select your app.
Navigate to [App integrity].
Copy the SHA-256 certificate fingerprint from the App signing key certificate section.

AttentionMake sure to copy from the correct section. This page contains two certificate entries:

App signing key certificate ← Use this value
Upload key certificate ← Do NOT use this value

These are two different values. Registering the upload key certificate will cause App Links to stop working.

Enter the SHA256 value into the sha256_cert_fingerprints field.

Naviagate to [Tracking Link]>[Deep Links] in the Airbridge dashboard.
Enter the Android URI scheme into the Android URI Scheme field. Include ://. For example, if the URI scheme is demo, you must enter demo://.
Enter the package name in the Package name field.
You need to find the sha256_cert_fingerprints. Run the following command from the keystore file you are deploying.

keytool -J-Duser.language=en -list -v -keystore YOUR_KEYSTORE.keystore

Find the SHA256 value in the results. The SHA256 value is the sha256_cert_fingerprints.

Certificate fingerprints:
    MD5:  4C:65:04:52:F0:3F:F8:65:08:D3:71:86:FC:EF:C3:49
    SHA1: C8:BF:B7:B8:94:EA:5D:9D:38:59:FE:99:63:ED:47:B2:D9:5A:4E:CC
    SHA256: B5:EF:4D:F9:DC:95:E6:9B:F3:9A:5E:E9:D6:E0:D8:F6:7B:AB:79:C8:78:67:34:D9:A7:01:AB:6A:86:01:0E:99

Enter the SHA256 value into the sha256_cert_fingerprints field.

After entering the deep link information into the Airbridge dashboard, an additional setup is required to enable the following.

App launch with Airbridge Deep Links
Airbridge Deep Link event collection
User redirection with Airbridge Deep Links

For detailed instructions, refer to the information below.

Enable app launch with Airbridge Deep Links

Perform the following setup to enable app launch with Airbridge Deep Links after the user clicks on a tracking link.

iOS

In the SDK settings, enter the iOS URI scheme that you entered on the [Tracking Link]>[Deep Links] page in the Airbridge dashboard into the iOS URI Scheme field. The Universal Link domain will be automatically set up using the App Name value in the SDK settings.

Android

In the SDK settings, enter the Android URI scheme that you entered on the [Tracking Link]>[Deep Links] page in the Airbridge dashboard into the Android URI Scheme field. The App Name value will be used to set up the App Links automatically.

Enable Airbridge Deep Link event collection

AttentionThe following settings are applied automatically. They are not applied automatically only if you use a custom App Controller on iOS with Unity Engine earlier than 2022.3.72, or if you use a custom Android Activity on Android. In those cases, apply them manually.

iOS

In Unity Engine 2022.3.72 and later, SceneDelegate events are collected automatically. In Unity Engine versions earlier than 2022.3.72, deep links are collected through the AppController AppDelegate (Assets/Plugins/Airbridge/iOS/Delegate/AUAppController.mm). If you use a custom AppDelegate, add the following code to your custom AppDelegate.

#import "UnityAppController.h"
#import "AirbridgeUnityDelegate.h"

@interface YourAppController : UnityAppController

@end

@implementation YourAppController

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary<UIApplicationLaunchOptionsKey,id> *)launchOptions {
    [AirbridgeUnityDelegate instance];
    return [super application:application didFinishLaunchingWithOptions:launchOptions];
}

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

- (BOOL)application:(UIApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void (^)(NSArray<id<UIUserActivityRestoring>>* _Nullable))restorationHandler {
    [super application:application continueUserActivity:userActivity restorationHandler:restorationHandler];
    return [AirbridgeUnityDelegate trackDeeplinkWithUserActivity:userActivity];
}

@end

IMPL_APP_CONTROLLER_SUBCLASS(AppController)

Android

The Airbridge Unity SDK uses Android Activity (Assets/Plugins/Airbridge/Android/java/co/ab180/airbridge/unity/AirbridgeActivity.java). If you are using a custom Activity, add the following code.

import co.ab180.airbridge.unity.AirbridgeUnity

override fun onResume() {
    super.onResume()
    AirbridgeUnity.processHandleDeeplink(intent)
}

override fun onNewIntent(intent: Intent?) {
    super.onNewIntent(intent)
    setIntent(intent)
}

import co.ab180.airbridge.unity.AirbridgeUnity;

@Override
protected void onResume() {
    super.onResume();
    AirbridgeUnity.processHandleDeeplink(getIntent());
}

@Override
protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    setIntent(intent);
}

Redirect the user through the collected Airbridge Deep Link

When the Airbridge Deep Link is executed, it is converted into a scheme deep link and passed to the onDeeplinkReceived callback. And if a deep link that is not an Airbridge Deep Link is executed, it is passed to the callback without being converted.
Use the received deep link to redirect the user to the intended destination.

Airbridge.SetOnDeeplinkReceived((string deeplink) =>
{
    // show proper content using url
});

Set up deferred deep linking

When a user clicks on a tracking link with deferred deep linking capabilities and the app is not installed on the device, the Airbridge SDK collects the deep link as follows.

How the Airbridge SDK collects deferred deep links

After initialization, the Airbridge SDK attempts to collect a deep link when all of the following conditions are met. When the app is closed before collection, the Airbridge SDK considers it as if there has not been an Airbridge Deep Link.

The Airbridge.startTracking function is called with the opt-in settings in place. Or, opt-in has not been set.
The user’s response to the ATT prompt has been determined. Or, the event collection delay time configured regarding the ATT prompt has expired.

Deferred deep links are automatically passed to onDeeplinkReceived callback, so no additional settings are required.

Set up custom domain

AttentionOptional settings. Configure only if necessary.

Enter the custom domain address into the Airbridge dashboard by referring to this article
In the SDK Settings, enter the custom domain address in the Custom Domain and click Add URL.

AttentionThe custom domain address you add to the SDK should be the same as the custom domain address entered into the Airbridge dashboard.

In-app Events

The Airbridge SDK collects user actions from the app as per settings and sends them as in-app events.

Understanding Airbridge Events

Send in-app events

SDK setup for hybrid appsYou can set up the Unity SDK to handle Airbridge-related tasks within the in-app website without changing the website’s code for your hybrid app.

Hybrid App Setup (v4)

The Airbridge.TrackEvent function must be called to send events. Refer to the information below about the required Airbridge.TrackEvent function components and their types.

public static void TrackEvent(
    string category,
    Dictionary<string, object> semanticAttributes = null,
    Dictionary<string, object> customAttributes = null
)

Component	Required	Type	Description
category	Required	String	Categories in Events
semanticAttributes	Optional	Dictionary<string, object>	Semantic attributes for events
customAttributes	Optional	Dictionary<string, object>	Custom attributes for events

Refer to the component definition and available strings below.

Event Category

The Standard Event Categories provided by the Airbridge SDK can be found in the AirbridgeCategory. You can also enter the Event Categories from the list of Standard Events.

Lists of Standard Events

Custom events can be sent by entering the event name set in the event taxonomy.Refer to the example below.

// track standard event (provided by sdk)
Airbridge.TrackEvent(AirbridgeCategory.ORDER_COMPLETED);
// track standard event (not provided by sdk)
Airbridge.TrackEvent("airbridge.ecommerce.order.canceled");
// track custom event
Airbridge.TrackEvent("eventViewed");

Attributes

AttentionThe Airbridge SDK v4 attributes differ from the previous version. The previous version’s attributes do not include action, label, and value.

Additional information about the event can be collected using attributes.

Action, Label: Collect information that can be used as GroupBys in the Airbridge reports
Value: Collect information that can be used for sales analysis. Airbridge can perform calculations using the collected data.
Semantic Attribute: Collect predefined attributes by Airbridge.
Custom Attributes: Collect attributes defined by Airbridge users.

In the Airbridge.TrackEvent function, you can enter Action, Label, Value, and Semantic Attributes using the semanticAttributes parameter and Custom Attributes using the customAttributes parameter.The semantic attributes predefined by Airbridge can be found in the user guide below.

List of semantic attributes

Refer to the example below.

Airbridge.TrackEvent(
    category: AirbridgeCategory.ORDER_COMPLETED,
    semanticAttributes: new Dictionary<string, object>()
    {
        // action
        { AirbridgeAttribute.ACTION, "Tool" },
        // label
        { AirbridgeAttribute.LABEL, "Hammer" },
        // value
        { AirbridgeAttribute.VALUE, 10 },
        // semantic attribute (provided by sdk)
        { AirbridgeAttribute.CURRENCY, "USD" },
        {
            AirbridgeAttribute.PRODUCTS, new List<object>()
            {
                new Dictionary<string, object>()
                {
                    // 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: new Dictionary<string, object>()
    {
        // custom attribute
        { "promotion", "FirstPurchasePromotion" }
    }
);

AttentionSemantic attributes and custom attributes only allow JSON as a data type.

JSON types: String, Number, Boolean, Object<String, JSON>, Array<JSON>
Types that cannot be used in semantic attributes and custom attributes: Struct, Class, etc.

The standard event categories and semantic attributes provided by the SDK are as follows.

Event Category of Standard Events provided by the SDK (AirbridgeCategory)

Key	Data
SIGN_UP	airbridge.user.signup
SIGN_IN	airbridge.user.signin
SIGN_OUT	airbridge.user.signout
HOME_VIEWED	airbridge.ecommerce.home.viewed
PRODUCT_LIST_VIEWED	airbridge.ecommerce.productList.viewed
SEARCH_RESULTS_VIEWED	airbridge.ecommerce.searchResults.viewed
PRODUCT_VIEWED	airbridge.ecommerce.product.viewed
ADD_PAYMENT_INFO	airbridge.addPaymentInfo
ADD_TO_WISHLIST	airbridge.addToWishlist
ADDED_TO_CART	airbridge.ecommerce.product.addedToCart
INITIATE_CHECKOUT	airbridge.initiateCheckout
ORDER_COMPLETED	airbridge.ecommerce.order.completed
ORDER_CANCELED	airbridge.ecommerce.order.canceled
START_TRIAL	airbridge.startTrial
SUBSCRIBE	airbridge.subscribe
UNSUBSCRIBE	airbridge.unsubscribe
AD_IMPRESSION	airbridge.adImpression
AD_CLICK	airbridge.adClick
COMPLETE_TUTORIAL	airbridge.completeTutorial
ACHIEVE_LEVEL	airbridge.achieveLevel
UNLOCK_ACHIEVEMENT	airbridge.unlockAchievement
RATE	airbridge.rate
SHARE	airbridge.share
SCHEDULE	airbridge.schedule
SPEND_CREDITS	airbridge.spendCredits

Semantic Attributes provided by the SDK (AirbridgeAttribute)

Key	Data	Data type
ACTION	action	string
LABEL	label	string
VALUE	value	float
CURRENCY	currency	string
PRODUCTS	products	array
PRODUCT_ID	productID	string
PRODUCT_NAME	name	string
PRODUCT_PRICE	price	float
PRODUCT_QUANTITY	quantity	int
PRODUCT_CURRENCY	currency	string
PRODUCT_POSITION	position	int
PRODUCT_CATEGORY_ID	categoryID	string
PRODUCT_CATEGORY_NAME	categoryName	string
PRODUCT_BRAND_ID	brandID	string
PRODUCT_BRAND_NAME	brandName	string
PERIOD	period	string
IS_RENEWAL	isRenewal	boolean
RENEWAL_COUNT	renewalCount	int
PRODUCT_LIST_ID	productListID	string
CART_ID	cartID	string
TRANSACTION_ID	transactionID	string
TRANSACTION_TYPE	transactionType	string
TRANSACTION_PAIRED_EVENT_CATEGORY	transactionPairedEventCategory	string
TRANSACTION_PAIRED_EVENT_TIMESTAMP	transactionPairedEventTimestamp	int
TOTAL_QUANTITY	totalQuantity	int
QUERY	query	string
IN_APP_PURCHASED	inAppPurchased	boolean
CONTRIBUTION_MARGIN	contributionMargin	float
LIST_ID	listID	string
RATE_ID	rateID	string
RATE	rate	float
MAX_RATE	maxRate	float
ACHIEVEMENT_ID	achievementID	string
SHARED_CHANNEL	sharedChannel	string
DATE_TIME	datetime	string
DESCRIPTION	description	string
IS_REVENUE	isRevenue	boolean
PLACE	place	string
SCHEDULE_ID	scheduleID	string
TYPE	type	string
LEVEL	level	string
SCORE	score	float
AD_PARTNERS	adPartners	array
IS_FIRST_PER_USER	isFirstPerUser	boolean

Refer to the example codes for each type of data below.

Airbridge.TrackEvent(
    category: "event",
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.VALUE, 10 },
    },
    customAttributes: new Dictionary<string, object>()
    {
        { "string", "string" },
        { "number", 1000 },
        { "boolean", true },
        {
            "object", new Dictionary<string, object>()
            {
                { "key", "value" }
            }
        },
        { "array", new List<object>() { "value" } },
    }
);

Additional in-app event settings

AttentionThe default settings will apply if no additional settings are configured. Proceed after reviewing whether additional settings are necessary.

Configure additional settings for sending in-app events if necessary.

Configure in-app event sessions

The Airbridge SDK includes session information when sending event data.When the app moves to the background or the process is terminated, the background entry time is recorded. When the app returns to the foreground or the process is restarted, the re-entry time is recorded. If the time difference between the last background entry and re-entry exceeds the session timeout, the previous session ends and a new session begins.The default session timeout is 300 seconds (5 minutes). In the SDK settings, you can configure Session Timeout Seconds up to 604,800 seconds (7 days).

AttentionThe Airbridge SDK collects Open events and Foreground events that initiate a new session. However, those events are not collected during a session. To collect them while the session is being maintained, additional settings are required.

Configure in-app event transmission frequency

The default transmission interval is set to 0 seconds. In the SDK settings, you can adjust Event Transmit Interval Seconds to modify it to a maximum of 86,400 seconds (1 day).

Configure in-app event storage

The following table shows the default and maximum values for the number of events and storage size.

	Number of Events	Storage Size
Default Value	INT_MAX	1024 GiB
Maximum Value Allowed	INT_MAX	1024 GiB

In the SDK settings, If you want to limit the number of events the SDK stores, use the Buffer Count Limit, and to limit the storage size of the SDK, use the Event Buffer Size Limit In Gibibyte.

Clear unsent in-app events

When the event deletion option is activated, all in-app events that are not transmitted during the Airbridge SDK’s initialization process are deleted. By default, the event deletion option is inactive.In the SDK settings, set Clear Event Buffer On Initialize Enabled to true to activate the event deletion option.

Configure device IDs

The Airbridge SDK supports functions to include device identifiers in all events for transmission.

Function	Description
`Airbridge.SetDeviceAlias`	Adds additional device identifiers. Up to 10 identifiers can be entered. - Key: Maximum 128 characters. It must satisfy the regular expression `^[a-zA-Z_][a-zA-Z0-9_]*$`. - Value: Maximum 128 characters.
`Airbridge.RemoveDeviceAlias`	Deletes only specified device identifiers.
`Airbridge.ClearDeviceAlias`	Deletes all device identifiers.

Refer to the example below.

Airbridge.SetDeviceAlias("string", "string");
Airbridge.RemoveDeviceAlias("string");
Airbridge.ClearDeviceAlias();

Example codes

Airbridge collects in-app events that are classified as Standard Events and Custom Events. Standard Events are events predefined by Airbridge. Refer to the example codes below.

Sign Up

Airbridge.SetUserID("string");
Airbridge.SetUserAlias("string", "string");
Airbridge.SetUserEmail("string");
Airbridge.SetUserPhone("string");
Airbridge.SetUserAttribute("string", "string");
        
Airbridge.TrackEvent(AirbridgeCategory.SIGN_UP);

Sign In

Airbridge.SetUserID("string");
Airbridge.SetUserAlias("string", "string");
Airbridge.SetUserEmail("string");
Airbridge.SetUserPhone("string");
Airbridge.SetUserAttribute("string", "string");
        
Airbridge.TrackEvent(AirbridgeCategory.SIGN_IN);

Sign Out

Airbridge.TrackEvent(AirbridgeCategory.SIGN_OUT);

Airbridge.ClearUser();

Home viewed

Airbridge.TrackEvent(AirbridgeCategory.HOME_VIEWED);

Product list viewed

Airbridge.TrackEvent(
    category: AirbridgeCategory.PRODUCT_LIST_VIEWED,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.LIST_ID, "84e6e236-38c4-48db-9b49-16e4cc064386" },
        { AirbridgeAttribute.CURRENCY, "USD" },
        {
            AirbridgeAttribute.PRODUCTS, new List<object>()
            {
                new Dictionary<string, object>()
                {
                    { AirbridgeAttribute.PRODUCT_ID, "0117b32a-5a6c-4d4c-b64c-7858e07dba78" },
                    { AirbridgeAttribute.PRODUCT_NAME, "PlasticHammer" },
                    { AirbridgeAttribute.PRODUCT_PRICE, 10 },
                    { AirbridgeAttribute.PRODUCT_QUANTITY, 1 },
                    { AirbridgeAttribute.PRODUCT_CURRENCY, "USD" }
                },
                new Dictionary<string, object>()
                {
                    { AirbridgeAttribute.PRODUCT_ID, "d6ab2fbe-decc-4362-b719-d257a131e91e" },
                    { AirbridgeAttribute.PRODUCT_NAME, "PlasticFork" },
                    { AirbridgeAttribute.PRODUCT_PRICE, 1 },
                    { AirbridgeAttribute.PRODUCT_QUANTITY, 1 },
                    { AirbridgeAttribute.PRODUCT_CURRENCY, "USD" }
                },
            }
        }
    }
);

Search result viewed, Product viewed, Add payment info, Add to wishlist, Add to cart

Search result viewed

Airbridge.TrackEvent(
    category: AirbridgeCategory.SEARCH_RESULTS_VIEWED,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.QUERY, "Plastic" },
        { AirbridgeAttribute.CURRENCY, "USD" },
        {
            AirbridgeAttribute.PRODUCTS, new List<object>()
            {
                new Dictionary<string, object>()
                {
                    { AirbridgeAttribute.PRODUCT_ID, "0117b32a-5a6c-4d4c-b64c-7858e07dba78" },
                    { AirbridgeAttribute.PRODUCT_NAME, "PlasticHammer" },
                    { AirbridgeAttribute.PRODUCT_PRICE, 10 },
                    { AirbridgeAttribute.PRODUCT_QUANTITY, 1 },
                    { AirbridgeAttribute.PRODUCT_CURRENCY, "USD" }
                },
                new Dictionary<string, object>()
                {
                    { AirbridgeAttribute.PRODUCT_ID, "d6ab2fbe-decc-4362-b719-d257a131e91e" },
                    { AirbridgeAttribute.PRODUCT_NAME, "PlasticFork" },
                    { AirbridgeAttribute.PRODUCT_PRICE, 1 },
                    { AirbridgeAttribute.PRODUCT_QUANTITY, 1 },
                    { AirbridgeAttribute.PRODUCT_CURRENCY, "USD" }
                },
            }
        }
    }
);

Product viewed

Airbridge.TrackEvent(
    category: AirbridgeCategory.PRODUCT_VIEWED,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.CURRENCY, "USD" },
        {
            AirbridgeAttribute.PRODUCTS, new List<object>()
            {
                new Dictionary<string, object>()
                {
                    { AirbridgeAttribute.PRODUCT_ID, "0117b32a-5a6c-4d4c-b64c-7858e07dba78" },
                    { AirbridgeAttribute.PRODUCT_NAME, "PlasticHammer" },
                    { AirbridgeAttribute.PRODUCT_PRICE, 10 },
                    { AirbridgeAttribute.PRODUCT_QUANTITY, 1 },
                    { AirbridgeAttribute.PRODUCT_CURRENCY, "USD" }
                },
            }
        }
    }
);

Add payment info

Airbridge.TrackEvent(
    category: AirbridgeCategory.ADD_PAYMENT_INFO,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.TYPE, "CreditCard" },
    }
);

Add to wishlist

Airbridge.TrackEvent(
    category: AirbridgeCategory.ADD_TO_WISHLIST,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.LIST_ID, "189a2f8b-83ee-4074-8158-726be54e57d4" },
        { AirbridgeAttribute.CURRENCY, "USD" },
        {
            AirbridgeAttribute.PRODUCTS, new List<object>()
            {
                new Dictionary<string, object>()
                {
                    { AirbridgeAttribute.PRODUCT_ID, "0117b32a-5a6c-4d4c-b64c-7858e07dba78" },
                    { AirbridgeAttribute.PRODUCT_NAME, "PlasticHammer" },
                    { AirbridgeAttribute.PRODUCT_PRICE, 10 },
                    { AirbridgeAttribute.PRODUCT_QUANTITY, 1 },
                    { AirbridgeAttribute.PRODUCT_CURRENCY, "USD" }
                },
            }
        }
    }
);

Add to cart

Airbridge.TrackEvent(
    category: AirbridgeCategory.ADDED_TO_CART,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.CART_ID, "421eaeb7-6e80-4694-933e-f2e1a55e9cbd" },
        { AirbridgeAttribute.CURRENCY, "USD" },
        {
            AirbridgeAttribute.PRODUCTS, new List<object>()
            {
                new Dictionary<string, object>()
                {
                    { AirbridgeAttribute.PRODUCT_ID, "0117b32a-5a6c-4d4c-b64c-7858e07dba78" },
                    { AirbridgeAttribute.PRODUCT_NAME, "PlasticHammer" },
                    { AirbridgeAttribute.PRODUCT_PRICE, 10 },
                    { AirbridgeAttribute.PRODUCT_QUANTITY, 1 },
                    { AirbridgeAttribute.PRODUCT_CURRENCY, "USD" }
                },
            }
        }
    }
);

Initiate checkout

Airbridge.TrackEvent(
    category: AirbridgeCategory.INITIATE_CHECKOUT,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.TRANSACTION_ID, "0a7ee1ec-33da-4ffb-b775-89e80e75978a" },
        { AirbridgeAttribute.CURRENCY, "USD" },
        {
            AirbridgeAttribute.PRODUCTS, new List<object>()
            {
                new Dictionary<string, object>()
                {
                    { AirbridgeAttribute.PRODUCT_ID, "0117b32a-5a6c-4d4c-b64c-7858e07dba78" },
                    { AirbridgeAttribute.PRODUCT_NAME, "PlasticHammer" },
                    { AirbridgeAttribute.PRODUCT_PRICE, 10 },
                    { AirbridgeAttribute.PRODUCT_QUANTITY, 1 },
                    { AirbridgeAttribute.PRODUCT_CURRENCY, "USD" },
                },
                new Dictionary<string, object>()
                {
                    { AirbridgeAttribute.PRODUCT_ID, "d6ab2fbe-decc-4362-b719-d257a131e91e" },
                    { AirbridgeAttribute.PRODUCT_NAME, "PlasticFork" },
                    { AirbridgeAttribute.PRODUCT_PRICE, 1 },
                    { AirbridgeAttribute.PRODUCT_QUANTITY, 1 },
                    { AirbridgeAttribute.PRODUCT_CURRENCY, "USD" },
                },
            }
        }
    }
);

Order completed

Airbridge.TrackEvent(
    category: AirbridgeCategory.ORDER_COMPLETED,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.VALUE, 11 },
        { AirbridgeAttribute.TRANSACTION_ID, "8065ef16-162b-4a82-b683-e51aefdda7d5" },
        { AirbridgeAttribute.CURRENCY, "USD" },
        { AirbridgeAttribute.IN_APP_PURCHASED, true },
        {
            AirbridgeAttribute.PRODUCTS, new List<object>()
            {
                new Dictionary<string, object>()
                {
                    { AirbridgeAttribute.PRODUCT_ID, "0117b32a-5a6c-4d4c-b64c-7858e07dba78" },
                    { AirbridgeAttribute.PRODUCT_NAME, "PlasticHammer" },
                    { AirbridgeAttribute.PRODUCT_PRICE, 10 },
                    { AirbridgeAttribute.PRODUCT_QUANTITY, 1 },
                    { AirbridgeAttribute.PRODUCT_CURRENCY, "USD" },
                },
                new Dictionary<string, object>()
                {
                    { AirbridgeAttribute.PRODUCT_ID, "d6ab2fbe-decc-4362-b719-d257a131e91e" },
                    { AirbridgeAttribute.PRODUCT_NAME, "PlasticFork" },
                    { AirbridgeAttribute.PRODUCT_PRICE, 1 },
                    { AirbridgeAttribute.PRODUCT_QUANTITY, 1 },
                    { AirbridgeAttribute.PRODUCT_CURRENCY, "USD" },
                },
            }
        }
    }
);

Order canceled

Airbridge.TrackEvent(
    category: AirbridgeCategory.ORDER_CANCELED,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.VALUE, 11 },
        { AirbridgeAttribute.TRANSACTION_ID, "8065ef16-162b-4a82-b683-e51aefdda7d5" },
        { AirbridgeAttribute.CURRENCY, "USD" },
        { AirbridgeAttribute.IN_APP_PURCHASED, true },
        {
            AirbridgeAttribute.PRODUCTS, new List<object>()
            {
                new Dictionary<string, object>()
                {
                    { AirbridgeAttribute.PRODUCT_ID, "0117b32a-5a6c-4d4c-b64c-7858e07dba78" },
                    { AirbridgeAttribute.PRODUCT_NAME, "PlasticHammer" },
                    { AirbridgeAttribute.PRODUCT_PRICE, 10 },
                    { AirbridgeAttribute.PRODUCT_QUANTITY, 1 },
                    { AirbridgeAttribute.PRODUCT_CURRENCY, "USD" },
                },
                new Dictionary<string, object>()
                {
                    { AirbridgeAttribute.PRODUCT_ID, "d6ab2fbe-decc-4362-b719-d257a131e91e" },
                    { AirbridgeAttribute.PRODUCT_NAME, "PlasticFork" },
                    { AirbridgeAttribute.PRODUCT_PRICE, 1 },
                    { AirbridgeAttribute.PRODUCT_QUANTITY, 1 },
                    { AirbridgeAttribute.PRODUCT_CURRENCY, "USD" },
                },
            }
        }
    }
);

Start trial

Airbridge.TrackEvent(
    category: AirbridgeCategory.START_TRIAL,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.TRANSACTION_ID, "ef1e5271-0370-407c-b1e9-669a8df1dc2c" },
        { AirbridgeAttribute.CURRENCY, "USD" },
        { AirbridgeAttribute.PERIOD, "P1M" },
        {
            AirbridgeAttribute.PRODUCTS, new List<object>()
            {
                new Dictionary<string, object>()
                {
                    { AirbridgeAttribute.PRODUCT_ID, "306a57cb-f653-4220-a208-8405d8e4d506" },
                    { AirbridgeAttribute.PRODUCT_NAME, "MusicStreamingMembership" },
                    { AirbridgeAttribute.PRODUCT_PRICE, 15 },
                    { AirbridgeAttribute.PRODUCT_CURRENCY, "USD" },
                },
            }
        }
    }
);

Airbridge.TrackEvent(
    category: AirbridgeCategory.SUBSCRIBE,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.VALUE, 15 },
        { AirbridgeAttribute.CURRENCY, "USD" },
        { AirbridgeAttribute.TRANSACTION_ID, "cbe718c7-e44e-4707-b5cd-4a6a29f29649" },
        { AirbridgeAttribute.PERIOD, "P1M" },
        { AirbridgeAttribute.IS_RENEWAL, true },
        {
            AirbridgeAttribute.PRODUCTS, new List<object>()
            {
                new Dictionary<string, object>()
                {
                    { AirbridgeAttribute.PRODUCT_ID, "306a57cb-f653-4220-a208-8405d8e4d506" },
                    { AirbridgeAttribute.PRODUCT_NAME, "MusicStreamingMembership" },
                    { AirbridgeAttribute.PRODUCT_PRICE, 15 },
                    { AirbridgeAttribute.PRODUCT_CURRENCY, "USD" },
                },
            }
        }
    }
);

Unsubscribe

Airbridge.TrackEvent(
    category: AirbridgeCategory.UNSUBSCRIBE,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.VALUE, 15 },
        { AirbridgeAttribute.CURRENCY, "USD" },
        { AirbridgeAttribute.TRANSACTION_ID, "cbe718c7-e44e-4707-b5cd-4a6a29f29649" },
        { AirbridgeAttribute.IS_RENEWAL, true },
        {
            AirbridgeAttribute.PRODUCTS, new List<object>()
            {
                new Dictionary<string, object>()
                {
                    { AirbridgeAttribute.PRODUCT_ID, "306a57cb-f653-4220-a208-8405d8e4d506" },
                    { AirbridgeAttribute.PRODUCT_NAME, "MusicStreamingMembership" },
                    { AirbridgeAttribute.PRODUCT_PRICE, 15 },
                    { AirbridgeAttribute.PRODUCT_CURRENCY, "USD" },
                },
            }
        }
    }
);

Add impression, Ad click, Complete tutorial, Achieve level, Unlock achievement

Add impression

Airbridge.TrackEvent(
    category: AirbridgeCategory.AD_IMPRESSION,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.VALUE, 0.01 },
        {
            AirbridgeAttribute.AD_PARTNERS, new Dictionary<string, object>()
            {
                {
                    "mopub", new Dictionary<string, object>()
                    {
                        { "app_version", "5.18.0" },
                        { "adunit_id", "12345" },
                        { "adunit_name", "12345" },
                        { "adunit_format", "Banner" },
                        { "id", "12345" },
                        { "currency", "USD" },
                        { "publisher_revenue", 12345.123 },
                        { "adgroup_id", "12345" },
                        { "adgroup_name", "12345" },
                        { "adgroup_type", "12345" },
                        { "adgroup_priority", "12345" },
                        { "country", "kr" },
                        { "precision", "publisher_defined" },
                        { "network_name", "12345" },
                        { "network_placement_id", "12345" },
                        { "demand_partner_data", "12345" },
                    }
                }
            }
        },
    }
);

Ad click

Airbridge.TrackEvent(
    category: AirbridgeCategory.AD_CLICK,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.VALUE, 0.01 },
        {
            AirbridgeAttribute.AD_PARTNERS, new Dictionary<string, object>()
            {
                {
                    "mopub", new Dictionary<string, object>()
                    {
                        { "app_version", "5.18.0" },
                        { "adunit_id", "12345" },
                        { "adunit_name", "12345" },
                        { "adunit_format", "Banner" },
                        { "id", "12345" },
                        { "currency", "USD" },
                        { "publisher_revenue", 12345.123 },
                        { "adgroup_id", "12345" },
                        { "adgroup_name", "12345" },
                        { "adgroup_type", "12345" },
                        { "adgroup_priority", "12345" },
                        { "country", "kr" },
                        { "precision", "publisher_defined" },
                        { "network_name", "12345" },
                        { "network_placement_id", "12345" },
                        { "demand_partner_data", "12345" },
                    }
                }
            }
        },
    }
);

Complete tutorial

Airbridge.TrackEvent(
    category: AirbridgeCategory.COMPLETE_TUTORIAL,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.DESCRIPTION, "Finish Initial Tutorial" },
    }
);

Achieve level

Airbridge.TrackEvent(
    category: AirbridgeCategory.ACHIEVE_LEVEL,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.LEVEL, 13 },
    }
);

Unlock achievement

Airbridge.TrackEvent(
    category: AirbridgeCategory.UNLOCK_ACHIEVEMENT,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.ACHIEVEMENT_ID, "36a0f0bb-b153-4be1-a3e0-3cb5b2b076c1" },
        { AirbridgeAttribute.DESCRIPTION, "Get Score Over 50" },
        { AirbridgeAttribute.SCORE, 80 },
    }
);

Rate

Airbridge.TrackEvent(
    category: AirbridgeCategory.RATE,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.RATE_ID, "531c64b3-4704-4780-a306-89014ec18daf" },
        { AirbridgeAttribute.RATE, 4.5 },
        { AirbridgeAttribute.MAX_RATE, 5 },
        { AirbridgeAttribute.CURRENCY, "USD" },
        {
            AirbridgeAttribute.PRODUCTS, new List<object>()
            {
                new Dictionary<string, object>()
                {
                    { AirbridgeAttribute.PRODUCT_ID, "0117b32a-5a6c-4d4c-b64c-7858e07dba78" },
                    { AirbridgeAttribute.PRODUCT_NAME, "PlasticHammer" },
                    { AirbridgeAttribute.PRODUCT_PRICE, 10 },
                    { AirbridgeAttribute.PRODUCT_QUANTITY, 1 },
                    { AirbridgeAttribute.PRODUCT_CURRENCY, "USD" }
                },
            }
        }
    }
);

Airbridge.TrackEvent(
    category: AirbridgeCategory.SHARE,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.DESCRIPTION, "Share Promotion" },
        { AirbridgeAttribute.SHARED_CHANNEL, "CopyLink" },
    }
);

Schedule

Airbridge.TrackEvent(
    category: AirbridgeCategory.SCHEDULE,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.SCHEDULE_ID, "75712915-2cd9-4e42-a85e-8d42f356f4c6" },
        { AirbridgeAttribute.DATE_TIME, "2024-01-01T00:00:00+00:00" },
        { AirbridgeAttribute.PLACE, "ConferenceRoom" },
        {
            AirbridgeAttribute.PRODUCTS, new List<object>()
            {
                new Dictionary<string, object>()
                {
                    { AirbridgeAttribute.PRODUCT_ID, "abb3e65d-17bc-4b28-89e3-5e356c0ea697" },
                    { AirbridgeAttribute.PRODUCT_NAME, "ConferenceRoom" },
                },
            }
        }
    }
);

Spend credits

Airbridge.TrackEvent(
    category: AirbridgeCategory.SPEND_CREDITS,
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.TRANSACTION_ID, "22eb193d-be11-4fe4-95da-c91a196faf1c" },
        { AirbridgeAttribute.CURRENCY, "USD" },
        {
            AirbridgeAttribute.PRODUCTS, new List<object>()
            {
                new Dictionary<string, object>()
                {
                    { AirbridgeAttribute.PRODUCT_ID, "0117b32a-5a6c-4d4c-b64c-7858e07dba78" },
                    { AirbridgeAttribute.PRODUCT_NAME, "PlasticHammer" },
                    { AirbridgeAttribute.PRODUCT_PRICE, 10 },
                    { AirbridgeAttribute.PRODUCT_CURRENCY, "USD" }
                },
            }
        }
    }
);

Custom Events are events defined by Airbridge users to track user actions that are unique to their services. Refer to the example code below.

Airbridge.TrackEvent(
    category: "event",
    semanticAttributes: new Dictionary<string, object>()
    {
        { AirbridgeAttribute.VALUE, 10 },
    },
    customAttributes: new Dictionary<string, object>()
    {
        { "string", "string" },
        { "number", 1000 },
        { "boolean", true },
        {
            "object", new Dictionary<string, object>()
            {
                { "key", "value" }
            }
        },
        { "array", new List<object>() { "value" } },
    }
);

User Data

Airbridge sends user data along with events. User data allows for a more accurate ad performance measurement.

Set User ID

User IDs refer to the user identifier used in a service. User IDs should be unique IDs that can identify unique users across websites and apps.

Function	Description
`Airbridge.SetUserID`	Inputs the user ID.
`Airbridge.ClearUserID`	Deletes the user ID.
`Airbridge.SetUserAlias`	Adds additional user identifiers. Up to 10 items can be added. - key: Up to 128 characters. Must follow the regular expression `^[a-zA-Z_][a-zA-Z0-9_]*$`. - value: Up to 1024 characters.
`Airbridge.RemoveUserAlias`	Deletes only specified identifiers.
`Airbridge.ClearUserAlias`	Deletes all additional user identifiers.

Refer to the example below.

// ID
Airbridge.SetUserID("testID");

// Alias
Airbridge.SetUserAlias("ADD_YOUR_KEY", "ADD_YOUR_VALUE");
Airbridge.RemoveUserAlias("DELETE_THIS_KEY");
Airbridge.ClearUserAlias();

Send additional user information

AttentionSensitive user information may be included. Send after a thorough review with a legal advisor.

Refer to the functions below to send additional user information.

Function	Description
`Airbridge.SetUserEmail`	Inputs user’s email. The data is hashed using SHA256.
`Airbridge.ClearUserEmail`	Deletes the user email.
`Airbridge.SetUserPhone`	Inputs user’s phone number. The data is hashed using SHA256.
`Airbridge.ClearUserPhone`	Deletes the user’s phone number.
`Airbridge.SetUserAttribute`	Adds additional user attributes. Up to 100 items can be added. - key: Up to 128 characters. Must satisfy the regular expression: `^[a-zA-Z_][a-zA-Z0-9_]*$`. - value: Only supports string, number, and Boolean types. Up to 1024 characters.
`Airbridge.RemoveUserAttribute`	Deletes only specified attributes from the additional attributes.
`Airbridge.ClearUserAttributes`	Deletes all additional user attributes.

Refer to the example below.

// Automatically hashed on client side using SHA256
// Can turn off hashing feature with special flag
Airbridge.SetUserEmail("testID@ab180.co");
Airbridge.SetUserPhone("821012341234");

// Attributes
Airbridge.SetUserAttribute("ADD_YOUR_KEY", 1);
Airbridge.SetUserAttribute("ADD_YOUR_KEY", 1L);
Airbridge.SetUserAttribute("ADD_YOUR_KEY", 1f);
Airbridge.SetUserAttribute("ADD_YOUR_KEY", 1.0);
Airbridge.SetUserAttribute("ADD_YOUR_KEY", "1");
Airbridge.SetUserAttribute("ADD_YOUR_KEY", true);
Airbridge.RemoveUserAttribute("DELETE_THIS_KEY");
Airbridge.ClearUserAttributes();

Hash user information

When User Info Hash Enabled is set to false in the SDK settings, user emails and phone numbers are passed without being hashed. The default setting is true.

Clear user data

You can reset user information with the Airbridge.clearUser function.

Airbridge.ClearUser();

Include User Information in Install/Open Events

The SDK automatically sends install and open events immediately after the app launches. Therefore, if you call user information functions right after the app launches, the user information may not be included in the install/open events depending on the event transmission timing. To ensure user information is included in install/open events, control the timing of event transmission through Opt-In setup. Implement in the following order:

Set the Auto Start Tracking Enabled option to false when Configure SDK settings.
Call user information functions to set user information.
Call the startTracking() function to start event collection.

Additional SDK Settings

Follow the instructions below for additional setup.

AttentionOptional settings. Configure only if necessary.

Calculating SKAdNetwork Conversion Value on the Server

By default, the ConversionValue in SKAdNetwork is calculated using the values from the SDK. If you want to measure events collected server-side through SKAN instead of the SDK, set the calculateSKAdNetworkByServerEnabled option to true.

AttentionIf you are currently using conversion values calculated by the SDK via SKAdNetwork, please exercise caution when making changes. Altering the conversion value calculation method may cause inconsistencies between existing and new data.

Restricting Identifier Tracking

Restricting identifiers during SDK initialization

NoteAirbridge Unity SDK v.4.7.0 or later is required.

In SDK Settings, set the Tracking Blocklist to specify which identifiers should be blocked. Events collected after this configuration will exclude the specified identifiers.Check the restricted data in the identifier restriction list.

Restrict identifiers during SDK runtime

AttentionAirbridge Unity SDK v.4.9.0 or later is required.

While the SDK is running, you can use the AllowTrackingItem and BlockTrackingItem functions to set the data to be restricted. The specified identifier items will be excluded or included. This does not affect events that have already been stored.

public static void AllowTrackingItem(AirbridgeTrackingBlocklist item);

public static void BlockTrackingItem(AirbridgeTrackingBlocklist item);

Check the restricted data in the identifier restriction list.

Identifier Restriction List

An identifier restriction list is provided through AirbridgeTrackingBlocklist.

Identifier	Platform	Description
IDFA	iOS	Restricts the collection of IDFA.
IDFV	iOS	Restricts the collection of IDFV.
SKAdNetwork	iOS	Even if SKAdNetwork calculation is performed, the SKAdNetwork value will not be updated.
GAID	Android	Restricts the collection of GAID(Google Advertising ID).
OAID	Android	Restricts the collection of OAID(Huawei Advertising ID).
FAID	Android	Restricts the collection of FAID(FireOS Advertising ID).
AppSetID	Android	Restricts the collection of Google Play App Set ID.

SDK settings by build settings

NoteAirbridge Unity SDK v.4.5.0 or later is required.

You can apply different SDK settings per build setting. Activate the Use Development Airbridge Settings or Use Production Airbridge Settings option depending on your build setting to configure the SDK accordingly. If the Use Development Airbridge Settings or Use Production Airbridge Settings option is inactive, the SDK settings are set to the Default settings.

When the Use Development Airbridge Settings is activated and your app is on development build setting, the SDK settings are set to the Development settings.

When the Use Production Airbridge Settings is activated and your app is on productino build setting, the SDK settings are set to the Production settings.

Integrate Google’s ICM attribution data

AttentionUnity SDK v.4.4.0 or later is required.

Integrated Conversion Measurement (ICM) is Google’s privacy-driven solution for filling in conversion tracking gaps caused by stricter tracking limitations. Google provides the ICM attribution data, which is the non-deterministic attribution data provided by Google’s privacy-preserving conversion modeling. To integrate the ICM attribution data, the Google’s On-Device Conversion Measurement (ODM) SDK must be installed. For detailed information, refer to this article. or contact Google.

Create tracking links within the app

Airbridge Unity SDK v.4.3.0 or later is required.

Tracking links are links that are embedded to ads for data collection. When users click on the ad, the tracking link is used to pass the touchpoint data to Airbridge, allowing for ad attribution. Also, users who click on the ad with a tracking link can be redirected to a specific destination. Use the CreateTrackingLink function to create tracking links. Refer to the code examples and the parameter details below.

public static void CreateTrackingLink(
    string channel, 
    Dictionary<string, object> option, 
    Action<AirbridgeTrackingLink> onSuccess,
    Action<Exception> onFailure = null
)

Name	Required or Optional	Type	Description
channel	Required	string	The ad channel the tracking link is used
option	Required	Dictionary<string, object>	Options for creating tracking links
onSuccess	Required	Action<AirbridgeTrackingLink>	Success callback
onFailure	Optional	Action<Exception>	Fail callback

Use the option parameter in the CreateTrackingLink function to configure tracking link options.

Create trackingLink option

Key	Type	Description
AirbridgeTrackingLinkOption.CAMPAIGN	String	The campaign credited with the winning touchpoint or conversion.
AirbridgeTrackingLinkOption.AD_GROUP	String	The ad group credited with the winning touchpoint or conversion.
AirbridgeTrackingLinkOption.AD_CREATIVE	String	The ad creative credited with the winning touchpoint or conversion.
AirbridgeTrackingLinkOption.CONTENT	String	The content credited with the winning touchpoint or conversion.
AirbridgeTrackingLinkOption.TERM	String	The search term credited with the winning touchpoint or conversion.
AirbridgeTrackingLinkOption.SUB_ID	String	The sub publisher that generated the touchpoint. Sub media values are usually provided by predefined “integrated” channels.
AirbridgeTrackingLinkOption.SUB_ID_1	String	The 1st level sub-sub publisher that generated the touchpoint. Sub media values are usually provided by predefined “integrated” channels.
AirbridgeTrackingLinkOption.SUB_ID_2	String	The 2nd level sub-sub publisher that generated the touchpoint. Sub media values are usually provided by predefined “integrated” channels.
AirbridgeTrackingLinkOption.SUB_ID_3	String	The 3rd level sub-sub publisher that generated the touchpoint. Sub media values are usually provided by predefined “integrated” channels.
AirbridgeTrackingLinkOption.DEEPLINK_URL	(Custom Scheme URL String)	Deeplink URL
AirbridgeTrackingLinkOption.DEEPLINK_STOPOVER	Boolean	Whether to enable the stopover feature of Deeplink true : enable false : disable
AirbridgeTrackingLinkOption.FALLBACK_IOS	(“store” \| Web URL String)	ios fallback when app is not installed
AirbridgeTrackingLinkOption.FALLBACK_ANDROID	(“store” \| Web URL String)	android fallback when app is not installed
AirbridgeTrackingLinkOption.FALLBACK_DESKTOP	(Web URL String)	desktop fallback when app is not installed
AirbridgeTrackingLinkOption.FALLBACK_IOS_STORE_PPID	String	The ppid for the Custom Product Page in the Apple App Store. Enable the custom product page to be shown when landing in the App Store.
AirbridgeTrackingLinkOption.FALLBACK_ANDROID_STORE_LISTING	String	The Custom Store Listing listing value for the Google Play Store. Enables the display of your custom store listing when landing on the Google Play Store.
AirbridgeTrackingLinkOption.OGTAG_TITLE	String	`og:title` for tracking link
AirbridgeTrackingLinkOption.OGTAG_DESCRIPTION	String	`og:description` for tracking link
AirbridgeTrackingLinkOption.OGTAG_IMAGE_URL	(Web URL String)	`og:image` for tracking link
AirbridgeTrackingLinkOption.OGTAG_WEBSITE_CRAWL	(“desktop”)	When the tracking link is shared, the social media platform directly crawls the Open Graph of the desktop URL specified in fallbackPaths and uses it for the social share preview. Dynamic URLs are also supported, and any change to the Open Graph is reflected automatically from the next time the link is shared. The values set for title, description, and imageUrl will be ignored.
AirbridgeTrackingLinkOption.CUSTOM_SHORT_ID	String	Configure the short ID of tracking links depending on your campaign or contents. If not passed, a random short ID will be generate, and can not be changed once generated.
AirbridgeTrackingLinkOption.IS_REENGAGEMENT	(“off” \| “on_true” \| “on_false”)	Configure the Re-engagement parameter. The Re-engagement parameter has three options. off: OFF is the default setting. The touchpoint can be attributed to both install events and post-install events (in-app events). on_true: ON-TRUE is used for re-engagement campaigns for installed users. The touchpoint generated by the tracking link is attributed only to the deeplink open and the following in-app events, not to the install event. on_false: ON-FALSE is used for user acquisition campaigns targeting uninstalled users. The touchpoint generated by the tracking link is attributed only to the install event and the following in-app events, not to the ‘deeplink open’ event.

Use the onSuccess callback in the CreateTrackingLink function to pass the AirbridgeTrackingLink.

public class AirbridgeTrackingLink
{
    public string ShortURL { get; }
    public string QrcodeURL { get; }
}

Name	Type	Description
ShortURL	string	The short URL of the tracking link
QrcodeURL	string	The QR code URL of the tracking link

Refer to the example codes below.

Create tracking links that launch the app or redirect users to the app store

Airbridge.CreateTrackingLink(
    channel: "test_channel",
    option: new Dictionary<string, object>
    {
        { AirbridgeTrackingLinkOption.CAMPAIGN, "test_campaign" },
        { AirbridgeTrackingLinkOption.DEEPLINK_URL, "YOUR_SCHEME://..." },
        { AirbridgeTrackingLinkOption.FALLBACK_IOS, "store" },
        { AirbridgeTrackingLinkOption.FALLBACK_ANDROID, "store" },
        { AirbridgeTrackingLinkOption.FALLBACK_DESKTOP, "https://example.com/" }
    },
    onSuccess: trackingLink => { },
    onFailure: exception => { }
);

Create tracking links that launch the app or redirect users to a webpage

Airbridge.CreateTrackingLink(
    channel: "test_channel",
    option: new Dictionary<string, object>
    {
        { AirbridgeTrackingLinkOption.CAMPAIGN, "test_campaign" },
        { AirbridgeTrackingLinkOption.DEEPLINK_URL, "sample://home" },
        { AirbridgeTrackingLinkOption.FALLBACK_IOS, "https://example.com/" },
        { AirbridgeTrackingLinkOption.FALLBACK_ANDROID, "https://example.com/" },
        { AirbridgeTrackingLinkOption.FALLBACK_DESKTOP, "https://example.com/" }
    },
    onSuccess: trackingLink => { },
    onFailure: exception => { }
);

Create tracking links that redirect users to the app store only

Airbridge.CreateTrackingLink(
    channel: "test_channel",
    option: new Dictionary<string, object>
    {
        { AirbridgeTrackingLinkOption.CAMPAIGN, "test_campaign" },
        { AirbridgeTrackingLinkOption.FALLBACK_IOS, "store" },
        { AirbridgeTrackingLinkOption.FALLBACK_ANDROID, "store" },
        { AirbridgeTrackingLinkOption.FALLBACK_DESKTOP, "https://example.com/" }
    },
    onSuccess: trackingLink => { },
    onFailure: exception => { }
);

Create tracking links that redirect users to a webpage only

Airbridge.CreateTrackingLink(
    channel: "test_channel",
    option: new Dictionary<string, object>
    {
        { AirbridgeTrackingLinkOption.CAMPAIGN, "test_campaign" },
        { AirbridgeTrackingLinkOption.FALLBACK_IOS, "https://example.com" },
        { AirbridgeTrackingLinkOption.FALLBACK_ANDROID, "https://example.com" },
        { AirbridgeTrackingLinkOption.FALLBACK_DESKTOP, "https://example.com" }
    },
    onSuccess: trackingLink => { },
    onFailure: exception => { }
);

Receive Airbridge Deep Links only

The deep links passed through the Airbridge.SetOnDeeplinkReceived method of the Airbridge Unity SDK include not only Airbridge Deep Links but also deep links from other solutions.

Airbridge.SetOnDeeplinkReceived((string deeplink) =>
{
    // show proper content using url
});

By setting Is Handle Airbridge Deeplink Only to true in the SDK settings, only Airbridge Deep Links will be passed to the onDeeplinkReceived callback. In this way, you can handle the deep links from other solutions separately from the Airbridge Deep Links.

Use tracking links within the app

Depending on how the link is opened, it may be difficult to properly use the tracking link of the app in-app. By using the Airbridge.Click function or the Airbridge.Impression function, you can properly use the tracking link without going through an external browser.

When the user clicks a tracking link within the app

When a user clicks on the tracking link in the app, call the Airbridge.Click function. Depending on the tracking link settings, the scheme deep link is passed, or the user is redirected to the app store or website.

Airbridge.Click(
    trackingLink: "https://abr.ge/~~~",
    onSuccess: () =>
    {
        // when url is tracking link and succeed
    },
    onFailure: (Exception e) =>
    {
        // when url is tracking link and failed
        // example: url is another app's tracking link, internet is not connected
    }
);

When the user views a tracking link within the app

When a user is impressed to the tracking link, call the Airbridge.Impression function. Calling this function collects Impression event data.

Airbridge.Impression(
    trackingLink: "https://abr.ge/~~~",
    onSuccess: () =>
    {
        // when url is tracking link and succeed
    },
    onFailure: (Exception e) =>
    {
        // when url is tracking link and failed
        // example: url is another app's tracking link, internet is not connected
    }
);

AttentionWhen you set up the Airbridge SDK to use tracking links within apps, every time a tracking link is used within the app, Deeplink Pageviews are aggregated as Target Events. The deep link performance may be affected when Deeplink Pageviews occur frequently right after Deeplink Opens.The attribution window for Deeplink Pageviews is set to 3 days by default. If you want to change the attribution window for Deeplink Pageviews, contact your Airbridge CSM. If you don’t have a designated CSM, contact the Airbridge Help Center.

Get Attribution Results

AttentionIt takes some time for the Airbridge SDK to collect attribution results. We do not recommend using attribution results for functionalities requiring real-time processing.

You can receive attribution results for installation events through the Airbridge.SetOnAttributionReceived function.

Airbridge.SetOnAttributionReceived((Dictionary<string, object> result) =>
{
    // Process attribution data
});

The value is delivered as follows, depending on the existence of attribution results.

When the attribution result exists

If the attribution result exists, a dictionary including the values below will be passed to the callback. All keys provide the attribution data. For example, attributedChannel contains information about the ad channel to which the ad performance is attributed.The attribution results are passed to the callback within 1 minute after SDK initialization. If the app is closed before the attribution result is passed, the previous attribution results will be passed to the callback within 1 minute the next time the app is launched. Depending on network conditions and other factors, there may be a delay of up to 5 minutes.

Key	Type	Description
attributedChannel	String	Channel
attributedCampaign	String	Campaign
attributedAdGroup	String	Ad Group
attributedAdCreative	String	Ad Creative
attributedContent	String	Content
attributedTerm	String	Keyword
attributedSubPublisher	String	Sub Publisher
attributedSubSubPublisher1	String	Sub Sub Publisher 1
attributedSubSubPublisher2	String	Sub Sub Publisher 2
attributedSubSubPublisher3	String	Sub Sub Publisher 3

When no attribution result exists (Organic)

If there is no attribution result, the following dictionary will be sent to the callback.

{
    "attributedChannel": "unattributed"
}

Tracking Deeplink Opens with Push Notifications

AttentionApply the code below using a custom iOS AppDelegate.

After the push notification is clicked, you need to pass the deep link information in the payload to the Airbridge SDK to collect the deep link event. Set up the Airbridge.trackDeeplink function.

iOS

Add the code below to your custom AppDelegate.

#import "UnityAppController.h"

#import <Airbridge/Airbridge.h>
#import <UserNotifications/UserNotifications.h>

@interface SomeAppController : UnityAppController<UNUserNotificationCenterDelegate>

@end

@implementation SomeAppController

- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
    UIApplicationState state = UIApplication.sharedApplication.applicationState;
    if (state == UIApplicationStateInactive) {
        NSURL *url = // Deep links in push notification payloads
        
        Airbridge.trackDeeplink(url)
    }
}

- (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void (^)(void))completionHandler {
    UIApplicationState state = UIApplication.sharedApplication.applicationState;
    if ((state == UIApplicationStateInactive || state == UIApplicationStateBackground)
        && [response.actionIdentifier isEqualToString:UNNotificationDefaultActionIdentifier]) {
        NSURL *url = // Deep links in push notification payloads
        
        Airbridge.trackDeeplink(url)
    }
}

IMPL_APP_CONTROLLER_SUBCLASS(SomeAppController)

Android

On Android, this is collected automatically, so no setup is required.

Track only Airbridge Deep Links

The Airbridge SDK collects deep link events when the app is opened through a deep link, even if the deep link is not an Airbridge Deep Link. Configure Track Airbridge Link Only in the SDK Settings to true to collect deep link events only if the app is opened through an Airbridge Deep Link and prevent unnecessary event collection.

Collect in-session lifecycle events

The Airbridge SDK collects Open and Foreground events that initiate a new session. These events are not collected during an ongoing session. By configuring the Track In Session Life Cycle Event Enabled in the SDK settings to true, the Open and Foreground events can be collected during ongoing sessions. All collected Foreground events are recorded as Open events.

Compliance with Google DMA

To comply with the Digital Markets Act (DMA), the user consent data must be sent to Airbridge. For more information about the DMA and whether it applies to your service, refer to the Airbridge user guide.

AttentionAdvertisers must collect user consent data from all existing and new users in the EEA at least once starting March 6, 2024.

If you are collecting user consent data using a consent management platform that complies with the Transparency and Consent Framework v2.2 protocol, refer to the following method to pass the user consent data to the Airbridge SDK.

NoteAirbridge Unity SDK v.4.4.0 or later is required.

In the SDK settings, set Collect TCF Data Enabled to true and Auto Start Tracking Enabled to false.

After the user consent data is stored in the consent management platform, call the StartTracking function.

Airbridge.StartTracking();

For all other cases, refer to the following method.

NoteAirbridge cannot provide guidance on storing the user consent data and implementing the prompts. For assistance, consult legal professionals.

Check the location of the users who launched the app. If their location is within the EEA, check whether the user consent data has been previously collected. If not, user consent data collection is not required.
Configure the Auto Start Tracking Enabledin the SDK settings to false.

If no user consent data has been collected previously, you may collect the data using a prompt or other means. The user consent data fields that need to be collected are adPersonalization, adUserData.

After initializing the Airbridge SDK, send the user consent data and the user location data (eea) to the Airbridge SDK using the Airbridge.SetDeviceAlias function.

// Based on actual region
Airbridge.SetDeviceAlias("eea", "0" /* or "1" */);

// Based on actual user consent
Airbridge.SetDeviceAlias("adPersonalization", "0" /* or "1" */);
Airbridge.SetDeviceAlias("adUserData", "0" /* or "1" */);

Refer to the table below for the user consent data and the user location data that need to be sent to the Airbridge SDK. Note that the Airbridge field names listed in the table below must be used to successfully send data.

Airbridge Field Name	Google Field Name	Description
`eea` <string>	`eea`	Data indicating whether the user location is within the EEA or not - `0`: Non-EEA. DMA not applicable. - `1`: EEA. DMA applicable.
`adPersonalization` <string>	`ad_personalization`	Data indicating whether the user allowed data tracking for ad personalization - `0`: User didn’t allow tracking. - `1`: User allowed tracking.
`adUserData` <string>	`ad_user_data`	Data indicating whether the user allowed data sharing with Google - `0`: User didn’t allow sharing. - `1`: User allowed sharing.

After the user consent data and the user location data are sent to the Airbridge SDK, call the StartTracking function.

Airbridge.StartTracking();

Set up Meta deferred app links

Follow the steps below to use deferred deep linking in Meta ads. The Airbridge SDK collects the Meta deferred app links before the Airbridge deferred deep links. If there are no Meta deferred app links, the Airbridge deferred deep links are collected. Note that Meta does not support Meta deferred app links for SKAdNetwork campaigns.

Install the Facebook SDK by referring to the Meta ads documentation for Unity.
Configure the Facebook Deferred App Link Enabled in the SDK settings to true.

Initialize the Airbridge SDK with all functions disabled

AttentionIf the SDK is not enabled immediately after the SDK initialization, the Install, Open, and Deeplink Openbvevents may not be collected.

Upon initialization, all functions of the SDK are enabled by default. By configuring SDK Enabled in the SDK settings to false, the SDK can be initialized with all functions disabled. You can also check the activation status of the Airbridge SDK and enable or disable all functions, as in the following example.

Airbridge.IsSDKEnabled();
Airbridge.EnableSDK();
Airbridge.DisableSDK();

Set up Meta Install Referrer collection

To collect the Meta Install Referrer, enter the Meta App ID as the key value for Meta Install Referrer (Facebook App ID) in the SDK settings. Note that the decryption key must be submitted to the Airbridge dashboard to read the decrypted Meta Install Referrer. Refer to this user guide to learn how to enter the decryption key.

Set up uninstall tracking

Airbridge sends a silent push every day between 3:00 PM and 4:00 PM (UTC) to users who performed an app event at least once in the last 6 months to check if the app has been deleted. You can check the uninstall event in the Airbridge reports and raw data export files. Refer to the article below for the detailed setup instructions.

Uninstall Tracking Setup - Unity SDK (v4)

Integrate with third-party solutions

An additional SDK setup is required to integrate with some third-party solutions. It is recommended that you complete this setup before collecting data with the Airbridge SDK. Refer to the articles listed below for integrating with third-party solutions.

Third-party platforms integrated with Airbridge

SDK logs

The logs provided by the Airbridge SDK are categorized into Debug, Info, Warning, Error, and Fault levels. The Debug level is the least critical log, while the Fault level is the most critical log. By default, the Airbridge SDK provides logs at Warning, Error, and Fault levels. By entering a specific log level as the Log Level value in the SDK settings, the logs from that specified level up to the Fault level will be available.

​Install SDK

​Initialize SDK

​Configure SDK settings

​Configure ATT prompt

​Opt-in setup

​Opt-out setup

​SDK Signature

​Deep Linking

​How Airbridge Deep Links work

​Set up deep linking

​iOS

​Android

​iOS

​Android

​iOS

​Android

​iOS

​Android

​Set up deferred deep linking

​Set up custom domain

​In-app Events

​Send in-app events

​Additional in-app event settings

​Example codes

Sign Up

Sign In

Sign Out

Home viewed

Product list viewed

Search result viewed

Product viewed

Add payment info

Add to wishlist

Add to cart

Initiate checkout

Order completed

Order canceled

Start trial

Subscribe

Unsubscribe

Add impression

Ad click

Complete tutorial

Achieve level

Unlock achievement

Rate

Share

Schedule

Spend credits

​User Data

​Set User ID

​Send additional user information

​Hash user information

​Clear user data

​Include User Information in Install/Open Events

​Additional SDK Settings

​Calculating SKAdNetwork Conversion Value on the Server

​Restricting Identifier Tracking

​SDK settings by build settings

​Integrate Google’s ICM attribution data

​Create tracking links within the app

​Receive Airbridge Deep Links only

​Use tracking links within the app

​Get Attribution Results

​Tracking Deeplink Opens with Push Notifications

​iOS

​Android

​Track only Airbridge Deep Links

​Collect in-session lifecycle events

​Compliance with Google DMA

​Set up Meta deferred app links

​Initialize the Airbridge SDK with all functions disabled

​Set up Meta Install Referrer collection

​Set up uninstall tracking

​Integrate with third-party solutions

​SDK logs

Install SDK

Initialize SDK

Configure SDK settings

Configure ATT prompt

Opt-in setup

Opt-out setup

SDK Signature

Deep Linking

How Airbridge Deep Links work

Set up deep linking

iOS

Android

iOS

Android

iOS

Android

iOS

Android

Set up deferred deep linking

Set up custom domain

In-app Events

Send in-app events

Additional in-app event settings

Example codes

User Data

Set User ID

Send additional user information

Hash user information

Clear user data

Include User Information in Install/Open Events

Additional SDK Settings

Calculating SKAdNetwork Conversion Value on the Server

Restricting Identifier Tracking

SDK settings by build settings

Integrate Google’s ICM attribution data

Create tracking links within the app

Receive Airbridge Deep Links only

Use tracking links within the app

Get Attribution Results

Tracking Deeplink Opens with Push Notifications

iOS

Android

Track only Airbridge Deep Links

Collect in-session lifecycle events

Compliance with Google DMA

Set up Meta deferred app links

Initialize the Airbridge SDK with all functions disabled

Set up Meta Install Referrer collection

Set up uninstall tracking

Integrate with third-party solutions

SDK logs