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.

Set up deep linking

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.

You need to set up deep linking on an app level. Follow the instructions linked below to set up deep linking on your target platform:

• iOS
• Android

Reattribution using deep links

To reattribute your user, you need to instantiate an ADJDeeplink/AdjustDeeplink object with your deep link URL and pass it to the Adjust.processDeeplink method. 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.

iOS

+ (void)processDeeplink:(ADJDeeplink *)deeplink

To enable Adjust reattribution via deep linking, make sure to call Adjust.processDeeplink method once you obtain the deep link in one of your app delegate callbacks.

1
import AdjustSdk
2

3
class AppDelegate {
4

5
   func application(application:UIApplication!, didFinishLaunchingWithOptions launchOptions:NSDictionary!) -> Bool {
6
      GeneratedPluginRegistrant.registerWithRegistry(self)
7
      // Override point for customization after application launch.
8
      return super.application(application, didFinishLaunchingWithOptions:launchOptions)
9
   }
10

11
   func application(application:UIApplication!, openURL url:NSURL!, sourceApplication:String!, annotation:AnyObject!) -> Bool {
12
     let deeplink = ADJDeeplink(deeplink: url)!
13
     Adjust.processDeeplink(deeplink)
14
      return true
15
   }
16

17
   func application(application:UIApplication!, continueUserActivity userActivity:NSUserActivity!, restorationHandler:([AnyObject]!)->Void) -> Bool {
18
         if (userActivity.activityType() == NSUserActivityTypeBrowsingWeb) {
19
            let deeplink = ADJDeeplink(deeplink: userActivity.webpageURL())!
20
            Adjust.processDeeplink(deeplink)
21
         }
22
         return true
23
   }
24
}

1
#import <AdjustSdk/AdjustSdk.h>
2

3
@implementation AppDelegate
4

5
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
6
   [GeneratedPluginRegistrant registerWithRegistry:self];
7
   // Override point for customization after application launch.
8
   return [super application:application didFinishLaunchingWithOptions:launchOptions];
9
}
10

11
- (BOOL)application:(UIApplication *)application openURL:(NSURL *)url sourceApplication:(NSString *)sourceApplication annotation:(id)annotation {
12
   [Adjust processDeeplink:[ADJDeeplink alloc] initWithDeeplink:url]];
13
   return YES;
14
}
15

16
- (BOOL)application:(UIApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void (^)(NSArray<id<UIUserActivityRestoring>> *restorableObjects))restorationHandler {
17
   if ([[userActivity activityType] isEqualToString:NSUserActivityTypeBrowsingWeb]) {
18
      [Adjust processDeeplink:[ADJDeeplink alloc] initWithDeeplink:[userActivity webpageURL]]];
19
   }
20
   return YES;
21
}
22

23
@end

Android

public static void processDeeplink(AdjustDeeplink deeplink)

To enable Adjust reattribution via deep linking, make sure to call Adjust.processDeeplink method once you obtain the deep link in your activity.

1
import com.adjust.sdk.flutter.AdjustSdk
2
import io.flutter.embedding.android.FlutterActivity
3
// Used for post flutter 1.12 Android projects
4
//import io.flutter.app.FlutterActivity
5

6
class MainActivity : FlutterActivity() {
7
   // Either call make the call in onCreate.
8
   override fun onCreate(savedInstanceState: Bundle?) {
9
      super.onCreate(savedInstanceState)
10
      // GeneratedPluginRegistrant.registerWith(this)
11
      // Used only for pre flutter 1.12 Android projects
12
      Intent intent = getIntent()
13
      Uri data = intent.getData()
14
      Adjust.processDeeplink(new AdjustDeeplink(data), this)
15
   }
16

17
   // Or make the call in onNewIntent.
18
   override fun onNewIntent(intent: Intent?) {
19
      super.onNewIntent(intent)
20
      Uri data = intent.getData()
21
      Adjust.processDeeplink(new AdjustDeeplink(data), this)
22
   }
23
}

1
import com.adjust.sdk.flutter.AdjustSdk;
2
import io.flutter.embedding.android.FlutterActivity; // Used for post flutter 1.12 Android projects
3
//import io.flutter.app.FlutterActivity; // Used for pre flutter 1.12 Android projects
4

5
public class MainActivity extends FlutterActivity {
6
   // Either call make the call in onCreate.
7
   @Override
8
   protected void onCreate(Bundle savedInstanceState) {
9
      super.onCreate(savedInstanceState);
10
      // GeneratedPluginRegistrant.registerWith(this); Used only for pre flutter 1.12 Android projects
11

12
      Intent intent = getIntent();
13
      Uri data = intent.getData();
14
      Adjust.processDeeplink(new AdjustDeeplink(data), this);
15
   }
16

17
   // Or make the cakll in onNewIntent.
18
   @Override
19
   protected void onNewIntent(Intent intent) {
20
      super.onNewIntent(intent);
21
      Uri data = intent.getData();
22
      Adjust.processDeeplink(new AdjustDeeplink(data), this);
23
   }
24
}

Deferred deep linking

bool? isDeferredDeeplinkOpeningEnabled;

The SDK opens deferred deep links by default. No additional setup is required. You can disable this by setting the isDeferredDeeplinkOpeningEnabled property on your config instance to false.

1
AdjustConfig adjustConfig = new AdjustConfig('{YourAppToken}', AdjustEnvironment.sandbox);
2
//...
3
adjustConfig.isDeferredDeeplinkOpeningEnabled = false;
4
//...
5
Adjust.initSdk(adjustConfig);

Set up a deferred deep link callback

typedef void DeferredDeeplinkCallback(String? deeplink);
DeferredDeeplinkCallback? deferredDeeplinkCallback;

You can configure the Adjust SDK to call a function when it receives a deferred deep link by adding a function to the deferredDeeplinkCallback property on your config instance. This function receives the deep link as a String argument.

1
AdjustConfig adjustConfig = new AdjustConfig('{YourAppToken}', AdjustEnvironment.sandbox);
2
adjustConfig.deferredDeeplinkCallback = (String? deeplink) {
3
   print('[Adjust]: Received deferred deeplink: ' + deeplink);
4
};
5
Adjust.initSdk(adjustConfig);

Example

This example shows how to log a deep link address when the user opens a deferred deep link.

1
import 'package:adjust_sdk/adjust.dart';
2
import 'package:adjust_sdk/adjust_config.dart';
3

4
initPlatformState() async {
5
   AdjustConfig config =
6
      new AdjustConfig('2fm9gkqubvpc', AdjustEnvironment.sandbox);
7
   config.logLevel = AdjustLogLevel.verbose;
8

9
   config.deferredDeeplinkCallback = (String? uri) {
10
      print('[Adjust]: Received deferred deeplink: ' + uri!);
11
   };
12

13
   Adjust.initSdk(config);
14
}

Enable LinkMe

bool? isLinkMeEnabled;

The Adjust SDK lets you copy deep link information from the device pasteboard. When combined with Adjust’s LinkMe solution, this feature enables deferred deep linking on devices running iOS 15 and above.

When a user clicks on a LinkMe URL they have the option to copy the link information to their system pasteboard. You can use the Adjust SDK to read the system pasteboard for deep link information. If deep link information is present, the SDK forwards the user to the correct page in your app.

To enable pasteboard checking in your app, set the isLinkMeEnabled property to true on your config object:

1
AdjustConfig adjustConfig = new AdjustConfig('{YourAppToken}', AdjustEnvironment.sandbox);
2
//...
3
adjustConfig.isLinkMeEnabled = true;
4
//...
5
Adjust.initSdk(adjustConfig);