Install the Airbridge Android SDK and implement the necessary settings following the steps below.
The Airbridge Android SDK can be installed using the method below. After installation, check whether the SDK has been properly installed through the Android SDK test.
1. Declare the Airbridge maven repository within the repositories
block of your project's build.gradle
file.
allprojects {
repositories {
maven { url "https://sdk-download.airbridge.io/maven" }
}
}
allprojects {
repositories {
maven("https://sdk-download.airbridge.io/maven")
}
}
2. Add the Airbridge Android SDK package to your app's gradle
file.
dependencies {
// Get the latest version from https://sdk-download.airbridge.io/maven
implementation "io.airbridge:sdk-android:HERE_LATEST_VERSION"
// For example
// implementation "io.airbridge:sdk-android:0.0.0"
}
dependencies {
// Get the latest version from https://sdk-download.airbridge.io/maven
implementation("io.airbridge:sdk-android:HERE_LATEST_VERSION")
// For example
// implementation("io.airbridge:sdk-android:0.0.0")
}
Note
Airbridge Android SDK requires Kotlin stdlib and Kotlinx coroutines library version 1.4 or later.
The Airbridge Android SDK uses JetBrains' Kotlin and Coroutines libraries.
If you install directly through the .aar
, you have to include the dependency library in your project. Refer to the following.
Attention
Install only one version of the SDK, either the general SDK or the restricted SDK.
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.
Install the Restricted SDK using the method below.
1. Declare the Airbridge maven repository within the repositories
block of your project's build.gradle
file.
allprojects {
repositories {
maven { url "https://sdk-download.airbridge.io/maven" }
}
}
allprojects {
repositories {
maven("https://sdk-download.airbridge.io/maven")
}
}
2. Add the Airbridge Android SDK package in your application's gradle
file.
dependencies {
// Get the latest version from https://sdk-download.airbridge.io/maven
implementation "io.airbridge:sdk-android-restricted:HERE_LATEST_VERSION"
// For example
// implementation "io.airbridge:sdk-android-restricted:0.0.0"
}
dependencies {
// Get the latest version from https://sdk-download.airbridge.io/maven
implementation("io.airbridge:sdk-android-restricted:HERE_LATEST_VERSION")
// For example
// implementation("io.airbridge:sdk-android-restricted:0.0.0")
}
Note
Airbridge Android SDK requires Kotlin stdlib and Kotlinx coroutines library version 1.4 or later.
The Airbridge Android SDK uses JetBrains' Kotlin and Coroutines libraries together.
If you install the SDK manually through the .aar
, you have to include the dependency libraries in your project. Refer to the following.
Initializing the Airbridge Android SDK in the Android Application class is recommended.
1. Create an Application class.
import android.app.Application
class AndroidApplication: Application() {
override fun onCreate() {
super.onCreate()
}
}
import android.app.Application;
public class AndroidApplication extends Application {
@Override
public void onCreate() {
super.onCreate();
}
}
2. Set the generated Application in AndroidManifest.xml
.
<application
android:name=".AndroidApplication"
...>
3. Get Airbridge
from the Application class.
import co.ab180.airbridge.Airbridge
import co.ab180.airbridge.Airbridge;
4. Add the following code snippet to the Application class file registered in AndroidManifest.xml
.
The YOUR_APP_NAME and YOUR_APP_SDK_TOKEN can be found on the [Settings]>[Tokens] page in the Airbridge dashboard.
override fun onCreate() {
super.onCreate()
// YOUR_APP_NAME: input your app name
// YOUR_APP_SDK_TOKEN: input your app token
val option = AirbridgeOptionBuilder("YOUR_APP_NAME", "YOUR_APP_SDK_TOKEN")
.build()
Airbridge.initializeSDK(this, option)
}
@Override
public void onCreate() {
super.onCreate();
// YOUR_APP_NAME: input your app name
// YOUR_APP_SDK_TOKEN: input your app token
AirbridgeOption option = new AirbridgeOptionBuilder("YOUR_APP_NAME", "YOUR_APP_SDK_TOKEN")
.build();
Airbridge.initializeSDK(this, option);
}
Attention
Make sure that the
initalizeSDK
function is called within theonCreate
method of theApplication
class for proper functionality.
5. Set the following permissions.
Airbridge Android SDK requires permission to transmit events through the network.
Add the following permissions to your application's AndroidManifest.xml
.
<manifest ...>
...
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
...
</manifest>
According to Google, apps targeting Android 13 (API 33) or above must declare the Google Play services general permissions in the AndroidManifest.xml
file to acquire the device's ADID.
From V2.13.0, the Airbridge Android SDK automatically adds the AD_ID permission that can acquire the ADID.
If you have not set LAT(LimitAdTracking) and GAID appears as 00000000-0000-0000-0000-000000000000, you will need to add AD_ID permission with the following code snippet. The issue occurs because the AD_ID permission has been excluded, for example, by other third-party libraries.
<manifest ...>
...
<uses-permission android:name="com.google.android.gms.permission.AD_ID" />
...
</manifest>
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.
When Airbridge generates a tracking link, it automatically selects and utilizes the optimal Airbridge deep link, depending on the environment. This link will be used for user redirection and is called the scheme deep link.
Airbridge Deeplink: https://YOUR_APP_NAME.airbridge.io/~~~
Scheme Deeplink: YOUR_SCHEME://product/12345
When the app is installed on a device and the user clicks the tracking link, the app opens through the Airbridge deep link. The Airbridge SDK converts the Airbridge deep link into a scheme deep link set on the tracking link. The converted scheme deep link is sent to the app.
When the app is not installed on a device and the user clicks the tracking link, the Airbridge deep link is saved. After the user moves to the app store or website and the app is installed and launched, the Airbridge SDK converts the saved Airbridge deep link into a scheme deep link. The converted scheme deep link is sent to the app.
For the deep linking setup, the deep link information entered to the Airbridge dashboard and the in-app location address for user redirection is required.
First, enter the deep link information into the Airbridge dashboard.
For the deep linking setup, the following information must be entered into the Airbridge dashboard.
Android URI scheme: The Airbridge deep link is converted to a schema 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.
Attention
To redirect users as intended, submit the Android URI scheme and the sha256_cert_fingerprints differently for the production app and the development app.
Follow the steps below to enter the above information into the Airbridge dashboard.
1. Go to [Tracking Link]>[Deep Links] in the Airbridge dashboard.
2. Enter the Android URI scheme into the Android URI Scheme field. Include ://
. For example, if the URI scheme is demo
, you must enter it as demo://
.
3. Enter the package name in the Package name field.
4. You need to find the sha256_cert_fingerprints. Run the following command from the keystore file you are deploying.
keytool -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
5. Enter the SHA256 value into the sha256_cert_fingerprints field.
After entering the deep link information into the Airbridge dashboard, additional setup is required to enable the following.
App launch with Airbridge deep links
User redirection with Airbridge deep links
For detailed instructions, refer to the information below.
Follow the steps below to enable app launch with Airbridge deep links after the user clicks on a tracking link.
1. Add an Activity that handles the deep link. Add an Activity class file to the src.
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
class DeeplinkActivity: AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
}
}
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
public class DeeplinkActivity extends AppCompatActivity {
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
}
Add the Activity to the AndroidManifest.xml
file.
<application
...>
<activity android:name=".DeeplinkActivity" />
</application>
2. To set up the scheme deep link to your app, add an intent filter to the Activity that handles the deep link in the AndroidManifest.xml
.
The intent filter you add must use the Android URI Scheme you entered into the Airbridge dashboard. Enter the Android URI scheme, excluding ://
.
<activity ...>
...
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<data android:scheme="YOUR_SCHEME" />
</intent-filter>
...
</activity>
Attention
You need to enter the Android URI scheme without
://
.
3. To set up the App Links to your app, add an intent filter under the Activity that handles the deep link in the AndroidManifest.xml
.
YOUR_APP_NAME
is the Airbridge app name.
<activity ...>
...
<intent-filter android:autoVerify="true">
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<data android:scheme="http" android:host="YOUR_APP_NAME.abr.ge" />
<data android:scheme="https" android:host="YOUR_APP_NAME.abr.ge" />
</intent-filter>
<intent-filter android:autoVerify="true">
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<data android:scheme="http" android:host="YOUR_APP_NAME.airbridge.io" />
<data android:scheme="https" android:host="YOUR_APP_NAME.airbridge.io" />
</intent-filter>
...
</activity>
When an Airbridge deep link is launched, the Activity that handles the deep link uses the Airbridge.handleDeeplink
function to convert the Airbridge deep link into a scheme deep link.
The converted scheme deep link is used to redirect users to the intended destination.
// when activity is opened with scheme deeplink or app links
override fun onResume() {
super.onResume()
// handle airbridge deeplink
val isHandled = Airbridge.handleDeeplink(intent) {
// when app is opened with airbridge deeplink
// show proper content using url (YOUR_SCHEME://...)
}
if (isHandled) return
// when app is opened with other deeplink
// use existing logic as it is
}
override fun onNewIntent(intent: Intent?) {
super.onNewIntent(intent)
setIntent(intent)
}
// when activity is opened with scheme deeplink or app links
@Override
protected void onResume() {
super.onResume();
boolean isHandled = Airbridge.handleDeeplink(
getIntent(),
uri -> {
// when app is opened with airbridge deeplink
// show proper content using url (YOUR_SCHEME://...)
}
);
if (isHandled) return;
// when app is opened with other deeplink
// use existing logic as it is
}
@Override
protected void onNewIntent(Intent intent) {
super.onNewIntent(intent);
setIntent(intent);
}
Attention
The
Airbridge.handleDeeplink
function passestrue
with the scheme deep link toonSuccess
when an Airbridge deep link is input. If a deep link from a different platform other than Airbridge is launched,false
is passed without a callback.The
Airbridge.handleDeeplink
function does not provide the screen transition that the customer wants. Customers must implement the screen transition directly through the uri provided viaAirbridge.handleDeeplink
onSuccess
.
When a user clicks on a tracking link with deferred deep linking capabilities and your app is not installed on the device, the Airbridge SDK collects the deep link as follows.
The Airbridge SDK attempts to collect a deep link after initializing the SDK when all the following conditions are met. If the app is closed during collection, the Airbridge SDK treats it as if there is no stored Airbridge deep link.
The Airbridge.startTracking
function is called with the opt-in settings in place. Or, opt-in has not been set.
The ATT tracking response has been determined. Or, the event collection delay time set in the ATT prompt has expired.
The Airbridge.handleDeferredDeeplink
function collects the saved Airbridge deep link and converts it into a scheme deep link to pass it to the app. Users are redirected to the intended destination using the converted scheme deep link.
val isHandled = Airbridge.handleDeferredDeeplink {
// when app is opened with deferred deeplink
// show proper content using url
}
boolean isHandled = Airbridge.handleDeferredDeeplink(uri -> {
// when app is opened with deferred deeplink
// show proper content using url
});
The Airbridge.handleDeferredDeeplink
function returns true
if it has been called for the first time after the install and waits for the Airbridge deep link to be retrieved, converts it to a scheme deep link to pass it to onSuccess
. You can use this scheme deep link to send users to the intended destination.
If there is no stored Airbridge deep link, null
is passed to onSuccess. If the SDK is not initialized or if the Airbridge.handleDeferredDeeplink
function has not been called for the first time, false
will be returned.
The scheme deep link is usually a URL in the form of YOUR_SCHEME://...
If you use services like Meta Deferred App Links, a different form of URL may be passed.
The SDK functionality test and deep link test allow you to check whether the SDK and deep linking work as intended.
Check whether the Airbridge Android SDK is operating properly. The Install events are collected by the Android SDK regardless of whether the additional configurations have been completed or not.
Follow the steps below to check whether the Install events are being collected by the Android SDK.
1. Prepare a test device where the app is not installed, or if the app is already installed, delete it before testing.
2. Set the SDK log level to DEBUG
.
// Default log level = Log.INFO
val option = AirbridgeOptionBuilder("YOUR_APP_NAME", "YOUR_APP_SDK_TOKEN")
.setLogLevel(AirbridgeLogLevel.DEBUG)
.build()
Airbridge.initializeSDK(this, option)
AirbridgeOption option = new AirbridgeOptionBuilder("YOUR_APP_NAME", "YOUR_APP_SDK_TOKEN")
.setLogLevel(AirbridgeLogLevel.DEBUG)
.build();
Airbridge.initializeSDK(this, option);
3. Install the app on the test device. After installing the app, launch it so that the Install event is collected.
The first Open event collected by Airbridge is recorded as an Install event. Therefore, the Open may not be recorded when the app install event is collected.
4. Use LogCat in the Android Studio or the Android Debug Bridge (ADB) to check whether the event performed on the test device with a specific GAID is logged properly. If the Install events are being collected properly, you should see logs such as the following.
Send event packets to Airbridge: categories={9161}
Send event packets to Airbridge: categories={9163}
For the LogCat messages and their meaning, refer to the following.
Event packet is stored in storage: categories={...}
: The event category is stored.
Send event packets to Airbridge: categories={...}
: Sending the event category.
Succeed to send event packets to Airbridge: categories={...}
: Sent the event category successfully through the network.
5. If you can't see the logs in LogCat even after a sufficient amount of time has passed, check whether the SDK has been initialized, the SDK configurations are completed as instructed, and the network status is stable.
If the problem persists, contact your Airbridge CSM and share your SDK logs. If you don't have a designated Airbridge CSM, contact the Airbridge Help Center.
Check whether the deep linking feature configured in the Airbridge Android SDK works as intended.
Before testing the deep link, make sure the following items have been set up.
Item |
Description |
Resources |
---|---|---|
HTTP Deep Link (App links) | Setup is required | |
Scheme Deep Link | Setup is required | |
Deferred Deep Link | The setup is completed automatically. No additional setup is required. | |
Custom Domain | Setup is optional | |
App Install | - If you don't need to test the deferred deep link, install the app on your test device in advance. - If you need to test the deferred deep link, the app should not be installed on the test device. If the app is installed, delete the app from the test device. |
Airbridge provides a website for testing deep links. If you want to test deferred deep links, you need to uninstall the app from your test device.
1. Visit the deep link testing site from your test device. You can access the website directly by using the QR code below.
2. Enter the App Name you registered with Airbridge. You can find it on the [Settings]>[Tokens] page in the Airbridge dashboard.
If you want to test a specific deep link address, enter the scheme deep link into the Deeplink URL field. The scheme deep link format is {YOUR_SCHEME}://...
If you're using a custom domain, make sure to enter your custom domain.
3. Click one of the buttons listed below. Click the button depending on the deep link type you are testing.
Note that you can only test deferred deep links if the app is not installed on your test device.
Button |
Description |
Example |
---|---|---|
Test HTTP Deeplink Type-1 | Test the HTTP deep link in the format of |
|
Test HTTP Deeplink Type-2 | Test the HTTP deep link in the format of |
|
Test Scheme Deeplink | Test the scheme deep link. |
|
Test Deferred Deeplink | Test the deferred deep link. |
|
Test Custom Domain Deeplink | Test the custom domain. This button is only available when the custom domain is entered. |
|
4. Use LogCat in the Android Studio or the Android Debug Bridge (ADB) to check whether the event performed on the test device with a specific GAID is logged properly. If the Install events are being collected properly, you should see logs as follows.
Send event packets to Airbridge: categories={9161}
Send event packets to Airbridge: categories={9163}
Send event packets to Airbridge: categories={9168}
If the SDK log level has been set to DEBUG
in the Airbridge SDK initialization process, you can check the value sent through the network.
5. The client request: method={...} message transmits the header and body values. Check the following items based on the button clicked on the deep link test site. If the deep link is working properly, all items should be confirmed.
After clicking Test HTTP Deeplink Type-1, you need to confirm the following items in the SDK log.
eventData.deeplink
is https://{YOUR_APP_NAME}.abr.ge...
{YOUR_SCHEME}://main...
is passed to the deep link callback function.
If you have entered a deeplink URL in the deeplink test site, the information passed will be changed. For example, if you have entered {YOUR_SCHEME}://path...
as the deeplink URL, ${YOUR_SCHEME}://path...
is passed.
After clicking Test HTTP Deeplink Type-2, you need to confirm the following items in the SDK log.
eventData.deeplink
is https://{YOUR_APP_NAME}.airbridge.io...
{YOUR_SCHEME}://main...
is passed to the deep link callback function.
If you have entered a deeplink URL in the deeplink test site, the information passed will be changed. For example, if you have entered {YOUR_SCHEME}://path...
as the deeplink URL, ${YOUR_SCHEME}://path...
is passed.
After clicking Test Scheme Deeplink, you need to confirm the following items in the SDK log.
eventData.deeplink
is {YOUR_SCHEME}://main...
{YOUR_SCHEME}://main...
is passed to the deeplink callback function.
If you have entered a deeplink URL in the deeplink test site, the information passed will be changed. For example, if you have entered {YOUR_SCHEME}://path...
as the deeplink URL, ${YOUR_SCHEME}://path...
is passed.
After clicking Test Deferred Deeplink, you need to confirm the following items in the SDK log.
eventData.deeplink
is ${YOUR_SCHEME}://main...
{YOUR_SCHEME}://main...
is passed to the deeplink callback function.
If you have entered a deeplink URL in the deeplink test site, the information passed will be changed. For example, if you have entered {YOUR_SCHEME}://path...
as the deeplink URL, ${YOUR_SCHEME}://path...
is passed.
After clicking Test Custom Domain Deeplink, you need to confirm the following items in the SDK log.
eventData.deeplink
is https://{YOUR_CUSTOM_DOMAIN}...
{YOUR_SCHEME}://main...
is passed to the deeplink callback function.
If you have entered a deeplink URL in the deeplink test site, the information passed will be changed. For example, if you have entered {YOUR_SCHEME}://path...
as the deeplink URL, ${YOUR_SCHEME}://path...
is passed.
6. If you can't see the logs in LogCat even after a considerable amount of time has passed, check whether the SDK has been initialized, the SDK configurations are completed as instructed, and the network status is stable.
If the problem persists, contact your Airbridge CSM and share your SDK logs. If you don't have a designated Airbridge CSM, contact the Airbridge Help Center.
Refer to the information below for troubleshooting regarding deep links.
Problem | Solution |
---|---|
You clicked a deep link, but the app was not launched. Or the SDK logs show information that is not intended as per setting. | Check whether the deep link is set up correctly. Refer to this article for the deep linking setup. |
You clicked a deep link, and the app was launched, but you didn't land on the intended app page. | You need to write code that redirects the user to the deep link path that is passed by the |
Was this page helpful?