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.

allprojects {
    repositories {
        maven { url "https://sdk-download.airbridge.io/maven" }
    }
}

allprojects {
    repositories {
        maven("https://sdk-download.airbridge.io/maven")
    }
}

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")
}

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.

allprojects {
    repositories {
        maven { url "https://sdk-download.airbridge.io/maven" }
    }
}

allprojects {
    repositories {
        maven("https://sdk-download.airbridge.io/maven")
    }
}

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")
}

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

注意

为确保正常运行，请确保在 Application 类的 onCreate 时调用 init 函数。

5. Set the following permissions.

<manifest ...>
  ...
  <uses-permission android:name="android.permission.INTERNET" />
  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
  ...
</manifest>

<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.

keytool -list -v -keystore YOUR_KEYSTORE.keystore

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

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.

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

<application
    ...>

    <activity android:name=".DeeplinkActivity" />

</application>

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

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

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 retrieves the deep link as follows.

The Airbridge.handleDeferredDeeplink function retrieves 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 returnstrue 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.

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.

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.

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.

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.