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>

</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 AdjustConfig.setOnDeferredDeeplinkResponseListener method.

Set up a deferred deep link callback

public void setOnDeferredDeeplinkResponseListener(OnDeferredDeeplinkResponseListener onDeferredDeeplinkResponseListener)

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.

val config = AdjustConfig(this, appToken, environment)
//...
config.setOnDeferredDeeplinkResponseListener { deeplink ->
   Log.d("example", "Deferred deep link callback called!")
   Log.d("example", "Deep link URL: $deeplink")
   true
}
//...
Adjust.initSdk(config)

AdjustConfig config = new AdjustConfig(this, appToken, environment);
//...
// Evaluate the deeplink to be launched.
config.setOnDeferredDeeplinkResponseListener(new OnDeferredDeeplinkResponseListener() {
   @Override
   public boolean launchReceivedDeeplink(Uri deeplink) {
      Log.d("example", "Deferred deep link callback called!");
      Log.d("example", "Deep link URL: " + deeplink);

      return true;
   }
});
//...
Adjust.initSdk(config);

Example

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

config.setOnDeferredDeeplinkResponseListener { deeplink ->
   false
}

config.setOnDeferredDeeplinkResponseListener(new OnDeferredDeeplinkResponseListener() {
   @Override
   public boolean launchReceivedDeeplink(Uri deeplink) {
      return false;
   }
});

Reattribution via deep links

public static void processDeeplink(AdjustDeeplink adjustDeeplink, 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 Adjust.processDeeplink method in the opening Activity’s onCreate and onNewIntent methods. 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
   val adjustDeeplink = AdjustDeeplink(data)
8
   Adjust.processDeeplink(adjustDeeplink, applicationContext)
9
}

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
    AdjustDeeplink adjustDeeplink = new AdjustDeeplink(data);
9
    Adjust.processDeeplink(adjustDeeplink, getApplicationContext());
10
}

Get the last resolved link

public static void getLastDeeplink(final Context context, final OnLastDeeplinkReadListener onLastDeeplinkReadListener)

You can return the last deep link URL resolved by the Adjust.processDeeplink() or Adjust.processAndResolveDeepLink() method by calling the Adjust.getLastDeeplink() method. This method returns the last resolved deep link as a deep link object.

1
Adjust.getLastDeeplink(context) { deeplink ->
2
   if (deeplink != null) {
3
       Log.d("Example", deeplink.toString())
4
   }
5
}

1
Adjust.getLastDeeplink(context, new OnLastDeeplinkReadListener() {
2
   @Override
3
   public void onLastDeeplinkRead(Uri deeplink) {
4
       if (deeplink != null) {
5
           Log.d("Example", deeplink.toString());
6
       }
7
   }
8
});

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

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

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