Set up deep linking

You can create deep links to take users to specific pages in your app. The Adjust SDK uses different logic depending on if the user already has your app installed on their device:

• Direct deep linking: occurs if the user already has your app installed. The link takes the user to the page specified in the link
• Deferred deep linking: occurs if the user doesn’t have your app installed. The link takes the user to a storefront to install your app first. After the user installs the app, it opens to the page specified in the link.

The SDK can read deep link data after a user opens your app from a link.

Configure your scheme name

If a user has your app installed, it opens when they interact with a link containing deep link information. The Adjust SDK contains tools to parse deep link information for use throughout your app. To set up deep linking, you need to choose a unique scheme name.

You can launch a specific activity when a user interacts with a deep link. To do this:

1. Assign your scheme name to an activity in your AndroidManifest.xml file.
2. Add an intent-filter node to the activity definition.
3. Add an android:scheme data node containing your scheme name inside the intent-filter node.

Example

This example shows how to set up an activity called MainActivity to open with the scheme name adjustExample.

<activity
   android:name=".MainActivity"
   android:configChanges="orientation|keyboardHidden"
   android:label="@string/app_name"
   android:screenOrientation="portrait">

   <intent-filter>
      <action android:name="android.intent.action.MAIN" />
      <category android:name="android.intent.category.LAUNCHER" />
   </intent-filter>

   <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="adjustExample" />
   </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="insights.go.link" />
    <data android:scheme="https" android:host="insights.go.link" />
   </intent-filter>

</activity>

Your app will now be able to handle URI schemes. When a user clicks a link with a deep_link parameter containing your scheme name, this activity fires.

https://app.adjust.com/abc123?deep_link=adjustExample%3A%2F%2F

Configure Android App Links

Ensure that you configure your scheme name even if you’re setting up Android App Links for deep linking.

For Android App Links, add an intent filter to your AndroidManifest.xml file to specify which URLs your app can handle. Include the data element with the android:autoVerify="true" attribute in the intent filter.

1
   <intent-filter android:autoVerify="true">
2
    <action android:name="android.intent.action.VIEW" />
3
    <category android:name="android.intent.category.DEFAULT" />
4
    <category android:name="android.intent.category.BROWSABLE" />
5
    <data android:scheme="http" android:host="insights.go.link" />
6
    <data android:scheme="https" android:host="insights.go.link" />
7
   </intent-filter>

Your app will now be able to handle Android App Links. When a user clicks on a link containing the insights.go.link domain, your app opens automatically.

1
https://insights.go.link/login?adj_t=abc123

Access deep link information

You can specify the delivery location of the deep_link parameter content. To do this, set the android:launchMode property on your activity in your AndroidManifest.xml file.

The Adjust SDK delivers deep link information within your activity’s intent object using either the onCreate or onNewIntent method. You can access deep link content once the app is launched and one of these methods has fired. You can then access this information in other parts of your app.

Extract deep link information by calling the getData() method within the onCreate or onNewIntent method.

1
override fun onCreate(savedInstanceState: Bundle?) {
2
   super.onCreate(savedInstanceState)
3
   setContentView(R.layout.activity_main)
4

5
   val intent = intent
6
   val data = intent.data
7
   // data.toString() -> This is your deep_link parameter value.
8
}

1
@Override
2
protected void onCreate(Bundle savedInstanceState) {
3
   super.onCreate(savedInstanceState);
4
   setContentView(R.layout.activity_main);
5

6
   Intent intent = getIntent();
7
   Uri data = intent.getData();
8
   // data.toString() -> This is your deep_link parameter value.
9
}

1
override fun onNewIntent(intent: Intent?) {
2
   super.onNewIntent(intent)
3
   val data = intent?.data
4
   // data.toString() -> This is your deep_link parameter value.
5
}

1
@Override
2
protected void onNewIntent(Intent intent) {
3
   super.onNewIntent(intent);
4

5
   Uri data = intent.getData();
6
   // data.toString() -> This is your deep_link parameter value.
7
}

Deferred deep linking

The Adjust SDK opens deferred deep links by default. No additional setup is required. If you want to disable this behavior, you need to set up a deferred deep link callback using the setOnDeeplinkResponseListener method.

Set up a deferred deep link callback

public void setOnDeeplinkResponseListener(OnDeeplinkResponseListener onDeeplinkResponseListener)

You can configure the Adjust SDK to call a delegate function when it receives a deferred deep link. This delegate function receives the deep link as a String argument.

If you want to open the deep link, return true in your delegate function. If you don’t want to open it, return false.

1
val config = AdjustConfig(this, appToken, environment)
2
//...
3
config.setOnDeeplinkResponseListener { deeplink ->
4
   Log.d("example", "Deferred deep link callback called!")
5
   Log.d("example", "Deep link URL: $deeplink")
6
   true
7
}
8
//...
9
Adjust.onCreate(config)

1
AdjustConfig config = new AdjustConfig(this, appToken, environment);
2
//...
3
// Evaluate the deeplink to be launched.
4
config.setOnDeeplinkResponseListener(new OnDeeplinkResponseListener() {
5
   @Override
6
   public boolean launchReceivedDeeplink(Uri deeplink) {
7
      Log.d("example", "Deferred deep link callback called!");
8
      Log.d("example", "Deep link URL: " + deeplink);
9

10
      return true;
11
   }
12
});
13
//...
14
Adjust.onCreate(config);

1
function deferredDeeplinkCallback(deeplink) {
2
   console.log("Deferred deep link callback called!");
3
   console.log(`Deep link URL: ${deeplink}`);
4
}
5
//...
6
let adjustConfig = new AdjustConfig(yourAppToken, environment);
7
adjustConfig.setOpenDeferredDeeplink(true);
8
adjustConfig.setDeferredDeeplinkCallback(deferredDeeplinkCallback);
9
//...
10
Adjust.start(adjustConfig);

Example

This example shows how to prevent the SDK from launching an activity by returning a false value in your callback function.

1
config.setOnDeeplinkResponseListener { deeplink ->
2
   false
3
}

1
config.setOnDeeplinkResponseListener(new OnDeeplinkResponseListener() {
2
   @Override
3
   public boolean launchReceivedDeeplink(Uri deeplink) {
4
      return false;
5
   }
6
});

Reattribution via deep links

public static void appWillOpenUrl(Uri url, Context context)

Adjust enables you to run re-engagement campaigns with usage of deep links. For more information, check out how to set up Deep links in Campaign Lab.

To reattribute your user, you need to call the appWillOpenUrl method when the app receives deep link content. The Adjust SDK then looks for new attribution data within the deep link. If the SDK finds new information, it forwards the information to Adjust’s servers for reattribution.

1
override fun onCreate(savedInstanceState: Bundle?) {
2
   super.onCreate(savedInstanceState)
3
   setContentView(R.layout.activity_main)
4

5
   val intent = intent
6
   val data = intent.data
7
   Adjust.appWillOpenUrl(data, getApplicationContext())
8
}

1
@Override
2
protected void onCreate(Bundle savedInstanceState) {
3
    super.onCreate(savedInstanceState);
4
    setContentView(R.layout.activity_main);
5

6
    Intent intent = getIntent();
7
    Uri data = intent.getData();
8
    Adjust.appWillOpenUrl(data, getApplicationContext());
9
}

1
Adjust.appWillOpenUrl(deeplinkUrl);

Link resolution

public static void resolveLink(final String url,
                               final String[] resolveUrlSuffixArray,
                               final AdjustLinkResolutionCallback adjustLinkResolutionCallback)

Some Email Service Providers (ESPs) use their own custom domains for marketing campaigns. If you need to measure clicks through a custom domain, you need to set the SDK up to resolve the link. To do this, call the resolveLink method of the AdjustLinkResolution class. The Adjust SDK will then follow the custom link and resolve it when opening the deep link. This ensures that you record the interaction with your email measurement campaign.

The resolveLinkWithUrl method takes the following arguments:

• url (String): the deep link that opened the application.
• resolveUrlSuffixArray (String[]): the custom domains of the configured campaigns that need to be resolved.
• adjustLinkResolutionCallback (AdjustLinkResolutionCallback): the callback that returns the final URL.

The method checks the deep link against the domains in the resolveUrlSuffixArray. If it doesn’t find any matches, it forwards the deep link URL as is. If it does find a match, it attempts to resolve the link and return the resulting deep link. It then stores this in the callback parameter.

You can use the returned deep link to reattribute your user. To do this, pass the deep link to the Adjust.appWillOpenUrl method.

1
AdjustLinkResolution.resolveLink(url, arrayOf("example.com"), object : AdjustLinkResolution.AdjustLinkResolutionCallback {
2
   override fun resolvedLinkCallback(resolvedLink: Uri) {
3
         Adjust.appWillOpenUrl(resolvedLink, applicationContext)
4
   }
5
})

1
AdjustLinkResolution.resolveLink(url, new String[]{"example.com"}, new AdjustLinkResolution.AdjustLinkResolutionCallback() {
2
   @Override
3
   public void resolvedLinkCallback(Uri resolvedLink) {
4
      Adjust.appWillOpenUrl(resolvedLink, getApplicationContext());
5
   }
6
});