Set up deferred deep linking

Deferred deep linking allows users who don’t have your app installed to click an Adjust link, install your app from the app store, and then be directed to their intended content when they first open the app.

How it works

This is the basic flow of deferred deep linking:

The user clicks on an Adjust deep link.
Adjust’s servers redirect the user to the app store.
The user installs or reinstalls your app and opens it.
The Adjust SDK sends a /session request and an /attribution request to Adjust’s servers.
Adjust’s servers match the click to the install or reinstall and return the deferred deep link to the SDK in one of the following responses:
- /session response (Optimized Deferred Deep Linking)
- /attribution response (legacy behavior)
The Adjust SDK delivers the deferred deep link to your app via the deferred deep link listener.
If applicable, your app displays its initial screens, such as onboarding screens and user login.
Your app handles the deep link and navigates to the appropriate screen.

Deferred deep link format

When a user clicks an Adjust branded link (brandname.go.link) and the link is deferred, Adjust’s servers convert it to app scheme format (example://), using the app scheme configured in the Android platform settings in the Adjust dashboard, before passing it to the Adjust SDK.

Setup

Set up a deferred deep link listener

Create an AdjustConfig object.
Set a deferred deep link listener on the AdjustConfig object. The Adjust SDK calls this listener after receiving a deferred deep link.
Initialize the SDK.

Kotlin
Java

1
val appToken = "{YourAppToken}"
2
val environment = AdjustConfig.ENVIRONMENT_SANDBOX
3
val config = AdjustConfig(this, appToken, environment)
4

5
config.setOnDeferredDeeplinkResponseListener { deeplink: Uri? ->
6
    /*
7
     * deep link format:
8
     *
9
     * example://summer-clothes?promo=beach&adj_t=def456
10
     *
11
     * TODO: Handle the deep link
12
     * (for example, store it or handle it immediately)
13
     */
14

15
    false // or true based on your use case (see below)
16
}
17

18
Adjust.initSdk(config)

1
String appToken = "{YourAppToken}";
2
String environment = AdjustConfig.ENVIRONMENT_SANDBOX;
3
AdjustConfig config = new AdjustConfig(this, appToken, environment);
4

5
config.setOnDeferredDeeplinkResponseListener(new OnDeferredDeeplinkResponseListener() {
6
    @Override
7
    public boolean launchReceivedDeeplink(Uri deeplink) {
8
        /*
9
         * deep link format:
10
         *
11
         * example://summer-clothes?promo=beach&adj_t=def456
12
         *
13
         * TODO: Handle the deep link
14
         * (for example, store it or handle it immediately)
15
         */
16

17
        return false; // or true based on your use case (see below)
18
    }
19
});
20

21
Adjust.initSdk(config);

Return Value Options

The return value of the deferred deep link listener determines what happens after your listener code executes:

Return `false` (most common)

Use this approach if you want your app to have complete control over when and how to process the deferred deep link. By returning false, the Adjust SDK will not attempt to open the deferred deep link. For example, this approach is appropriate if your app needs to show and move past initial screens (like onboarding or login) before handling the deferred deep link.

Return `true`

Use this approach if you want the Adjust SDK to attempt to open the deferred deep link immediately after the listener code runs. For example, this approach is appropriate if your app does not have any initial screens.

When the Adjust SDK receives the deferred deep link, your listener code runs, and then the Adjust SDK calls startActivity(Intent) with the deferred deep link.

Full code example

This example shows how an app with an onboarding process handles deferred deep links. Here is a summary of the app’s internal flow:

The user opens the app, and deferred deep linking is applicable.
The app begins its onboarding process.
The app’s listener receives the deferred deep link from the Adjust SDK and then checks if onboarding is complete:
- If complete, it handles the deep link immediately.
- If not complete, it stores the deep link.
Once onboarding finishes, the app checks for and handles any stored deferred deep link.
The app navigates the user to the deep link screen.

Kotlin
Java

1
class MainActivity : AppCompatActivity() {
2

3
    private lateinit var sharedPreferences: SharedPreferences
4

5
    override fun onCreate(savedInstanceState: Bundle?) {
6
        super.onCreate(savedInstanceState)
7

8
        sharedPreferences = getSharedPreferences("adjust_prefs", Context.MODE_PRIVATE)
9

10
        // Configure Adjust SDK
11
        val appToken = "{YourAppToken}"
12
        val environment = if (BuildConfig.DEBUG) AdjustConfig.ENVIRONMENT_SANDBOX else AdjustConfig.ENVIRONMENT_PRODUCTION
13
        val config = AdjustConfig(this, appToken, environment)
14

15
        config.setLogLevel(if (BuildConfig.DEBUG) LogLevel.VERBOSE else LogLevel.SUPPRESS)
16

17
        // Receive deferred deep link via listener
18
        config.setOnDeferredDeeplinkResponseListener { deeplink: Uri? ->
19
            if (deeplink == null) {
20
                return@setOnDeferredDeeplinkResponseListener false
21
            }
22

23
            val hasCompletedOnboarding = sharedPreferences.getBoolean("has_completed_onboarding", false)
24

25
            if (hasCompletedOnboarding) {
26
                // If onboarding is complete, handle deferred deep link immediately
27

28
                /*
29
                 * deep link format:
30
                 *
31
                 * example://summer-clothes?promo=beach&adj_t=def456
32
                 *
33
                 * TODO: Handle the deep link and navigate to the appropriate screen.
34
                 */
35
            } else {
36
                // Store deferred deep link to invoke after onboarding screens and login
37
                sharedPreferences.edit()
38
                    .putString("deferred_link", deeplink.toString())
39
                    .apply()
40
            }
41

42
            // The app controls when and how it handles the deferred deep link, so return false.
43
            false
44
        }
45

46
        // Initialize SDK
47
        Adjust.initSdk(config)
48

49
        val hasCompletedOnboarding = sharedPreferences.getBoolean("has_completed_onboarding", false)
50

51
        if (hasCompletedOnboarding) {
52
            // Show main content
53
        } else {
54
            // Show onboarding screens and login prompt
55
        }
56
    }
57

58
    // This logic runs when the user finishes the onboarding flow
59
    fun onOnboardingFinished() {
60
        // Set hasCompletedOnboarding to true
61
        sharedPreferences.edit().putBoolean("has_completed_onboarding", true).apply()
62

63
        // Check for deferred deep link received before or during onboarding
64
        // Exit if no deferred deep link was stored
65
        val deferredLinkString = sharedPreferences.getString("deferred_link", null) ?: return
66

67
        // Remove the stored deep link to prevent it from being handled again
68
        sharedPreferences.edit().remove("deferred_link").apply()
69

70
        // Convert the stored string back to a Uri object
71
        val deeplink = Uri.parse(deferredLinkString)
72

73
        /*
74
         * deep link format:
75
         *
76
         * example://summer-clothes?promo=beach&adj_t=def456
77
         *
78
         * TODO: Handle the deep link and navigate to the appropriate screen.
79
         */
80
    }
81
}

1
public class MainActivity extends AppCompatActivity {
2

3
    private SharedPreferences sharedPreferences;
4

5
    @Override
6
    protected void onCreate(Bundle savedInstanceState) {
7
        super.onCreate(savedInstanceState);
8

9
        sharedPreferences = getSharedPreferences("adjust_prefs", Context.MODE_PRIVATE);
10

11
        // Configure Adjust SDK
12
        String appToken = "{YourAppToken}";
13
        String environment = BuildConfig.DEBUG ? AdjustConfig.ENVIRONMENT_SANDBOX : AdjustConfig.ENVIRONMENT_PRODUCTION;
14
        AdjustConfig config = new AdjustConfig(this, appToken, environment);
15

16
        config.setLogLevel(BuildConfig.DEBUG ? LogLevel.VERBOSE : LogLevel.SUPPRESS);
17

18
        // Receive deferred deep link via listener
19
        config.setOnDeferredDeeplinkResponseListener(new OnDeferredDeeplinkResponseListener() {
20
            @Override
21
            public boolean launchReceivedDeeplink(Uri deeplink) {
22
                if (deeplink == null) {
23
                    return false;
24
                }
25

26
                boolean hasCompletedOnboarding = sharedPreferences.getBoolean("has_completed_onboarding", false);
27

28
                if (hasCompletedOnboarding) {
29
                    // If onboarding is complete, handle deferred deep link immediately
30

31
                    /*
32
                     * deep link format:
33
                     *
34
                     * example://summer-clothes?promo=beach&adj_t=def456
35
                     *
36
                     * TODO: Handle the deep link and navigate to the appropriate screen.
37
                     */
38
                } else {
39
                    // Store deferred deep link to invoke after onboarding screens and login
40
                    sharedPreferences.edit()
41
                            .putString("deferred_link", deeplink.toString())
42
                            .apply();
43
                }
44

45
                // The app controls when and how it handles the deferred deep link, so return false.
46
                return false;
47
            }
48
        });
49

50
        // Initialize SDK
51
        Adjust.initSdk(config);
52

53
        boolean hasCompletedOnboarding = sharedPreferences.getBoolean("has_completed_onboarding", false);
54

55
        if (hasCompletedOnboarding) {
56
            // Show main content
57
        } else {
58
            // Show onboarding screens and login prompt
59
        }
60
    }
61

62
    // This logic runs when the user finishes the onboarding flow
63
    private void onOnboardingFinished() {
64
        // Set hasCompletedOnboarding to true
65
        sharedPreferences.edit().putBoolean("has_completed_onboarding", true).apply();
66

67
        // Check for deferred deep link received before or during onboarding
68
        // Exit if no deferred deep link was stored
69
        String deferredLinkString = sharedPreferences.getString("deferred_link", null);
70
        if (deferredLinkString == null) {
71
            return;
72
        }
73

74
        // Remove the stored deep link to prevent it from being handled again
75
        sharedPreferences.edit().remove("deferred_link").apply();
76

77
        // Convert the stored string back to a Uri object
78
        Uri deeplink = Uri.parse(deferredLinkString);
79

80
        /*
81
         * deep link format:
82
         *
83
         * example://summer-clothes?promo=beach&adj_t=def456
84
         *
85
         * TODO: Handle the deep link and navigate to the appropriate screen.
86
         */
87
    }
88
}