Set up deep linking

Deep links are URIs (Uniform Resource Identifiers) that direct users to specific pages within your app. They enhance user experience by guiding them directly to relevant content after they interact with a link.

The Adjust iOS Extension for the Adobe Experience SDK supports two types of deep linking, based on whether the user has already installed your app:

• Direct deep links: If the user already has your app installed, the link opens the specified page.
• Deferred deep links: If the user doesn’t have your app installed, the link directs them to the app store to install it. After installation, the app opens the specified page.

Reattribute users with direct deep links

You can reattribute your users by sending deep link information to Adjust. When a user engages with a deep link, you can send this data to Adjust to update their attribution information.

1. First, create an ADJDeeplink instance with your deep link URI. The ADJDeeplink class validates this URI and checks the formatted string to ensure successful processing.

2. Then, call the processDeeplink function to handle the deep link and pass the information to Adjust.

The ADJDeeplink class constructor requires the following argument:

deeplink: NSURL

The deep link URI that opens your app.

The processDeeplink function requires the following argument:

adjustDeeplink: ADJDeeplink

TheADJDeeplinkinstance you created.

Deferred deep link callbacks

The Adjust iOS Extension for Adobe Experience SDK opens deferred deep links by default. To control this behavior, or perform validation before the deep link is opened, configure the extension to call a function when the app opens via a deferred deep link.

1. Call setDeferredDeeplinkReceivedBlock on your AdjustAdobeExtensionConfig instance.
2. Call AdjustAdobeExtension.setConfiguration to set your configuration.

The setDeferredDeeplinkReceivedBlock function requires the following argument:

deeplinkResponseBlock: CallbackDeeplinkResponseBlock

A function that returns abooleanvalue. If it returnsfalse, the extension won't open the deferred deep link.

Tutorial: Create a deferred deep link function

If you followed the integration guide, you've already configured the Adjust Extension to process and open deep links. If you haven't done this, refer to set up deep link handling for instructions.

In this tutorial, you'll learn how to create a callback function that controls deep linking functionality using the setDeferredDeeplinkReceivedBlock method. The function will open the link depending on the following condition:

"If the deep link contains "no_open", the app won't open it."

The result looks like this:

1
import UIKit
2
import AEPCore
3
import AEPServices
4
import AdjustAdobeExtension
5

6
@main
7
class AppDelegate: UIResponder, UIApplicationDelegate {
8

9
   func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
10
      MobileCore.setLogLevel(LogLevel.trace)
11
      let appState = application.applicationState
12

13
      if let config = AdjustAdobeExtensionConfig(environment: ADJEnvironmentSandbox) {
14
        config.setDeferredDeeplinkReceivedBlock { (deeplink: URL?) -> Bool in
15
            if let deeplinkString = deeplink?.absoluteString.lowercased(),
16
            deeplinkString.contains("no_open") {
17
                return false
18
            }
19
            return true
20
        }
21
         AdjustAdobeExtension.setConfiguration(config)
22
      }
23

24
      MobileCore.registerExtensions([AdjustAdobeExtension.self]) {
25
         MobileCore.configureWith(appId: "{your_adobe_app_id}")
26
         if appState != .background {
27
               MobileCore.lifecycleStart(additionalContextData: nil)
28
         }
29
      }
30
      return true
31
   }
32

33
    func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
34
        if let deeplink = ADJDeeplink(deeplink: url) {
35
            Adjust.processDeeplink(deeplink)
36
        }
37
        return true
38
    }
39

40
    func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
41
        if userActivity.activityType == NSUserActivityTypeBrowsingWeb {
42
            if let incomingUrl = userActivity.webpageUrl {
43
                if let deeplink = ADJDeeplink(deeplink: incomingUrl) {
44
                    Adjust.processDeeplink(deeplink)
45
                }
46
            }
47
        }
48
        return true
49
    }
50
}

1
#import "AppDelegate.h"
2
@import AEPCore;
3
@import AEPServices;
4
#import <AdjustAdobeExtension/AdjustAdobeExtension.h>
5

6
@implementation AppDelegate
7

8
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
9
    [AEPMobileCore setLogLevel: AEPLogLevelTrace];
10
    const UIApplicationState appState = application.applicationState;
11

12
    AdjustAdobeExtensionConfig *config = [AdjustAdobeExtensionConfig configWithEnvironment:ADJEnvironmentSandbox];
13
    [config setDeferredDeeplinkReceivedBlock:^BOOL(NSURL * _Nullable deeplink) {
14
        if (deeplink && [[deeplink.absoluteString lowercaseString] containsString:@"no_open"]) {
15
            return NO;
16
        }
17
        return YES;
18
    }];
19
    [AdjustAdobeExtension setConfiguration:config];
20

21
    [AEPMobileCore registerExtensions:@[AdjustAdobeExtension.class]
22
                           completion:^{
23
        [AEPMobileCore configureWithAppId: @"{your_adobe_app_id}"];
24

25
        if (appState != UIApplicationStateBackground) {
26
            [AEPMobileCore lifecycleStart:nil];
27
        }
28
    }];
29

30
    return YES;
31
}
32

33
- (BOOL)application:(UIApplication *)app openURL:(NSURL *)url options:(NSDictionary<UIApplicationOpenURLOptionsKey,id> *)options {
34
   [Adjust processDeeplink: [[ADJDeeplink alloc] initWithDeeplink:url]];
35
   return YES;
36
}
37

38
- (BOOL)application:(UIApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void (^)(NSArray<id<UIUserActivityRestoring>> * _Nullable))restorationHandler {
39
   if ([[userActivity activityType] isEqualToString:NSUserActivityTypeBrowsingWeb]) {
40
     [Adjust proceessDeeplink:[[ADJDeeplink alloc] initWithDeeplink:[userActivity webpageURL]]];
41
   }
42
   return YES;
43
}
44
@end

Here's what you need to do:

1. Inside your App Delegate, find your AdjustAdobeExtensionConfig instantiation. On the next line, call the setDeferredDeeplinkReceivedBlock method with a function block as an argument. This function block receives the deep link as an argument.

   • Swift
   • Objective-C

   13
   if let config = AdjustAdobeExtensionConfig(environment: ADJEnvironmentSandbox) {
   14
       config.setDeferredDeeplinkReceivedBlock { (deeplink: URL?) -> Bool in }
   15
       AdjustAdobeExtension.setConfiguration(config)
   16
   }

   12
   AdjustAdobeExtensionConfig *config = [AdjustAdobeExtensionConfig configWithEnvironment:ADJEnvironmentSandbox];
   13
   [config setDeferredDeeplinkReceivedBlock:^BOOL(NSURL * _Nullable deeplink) {}];
   14
   [AdjustAdobeExtension setConfiguration:config];

2. Inside the setDeferredDeeplinkReceivedBlock function block, add an if block to check whether the deep link contains the string "no_open". If it does, return false.

   • Swift
   • Objective-C

   13
   if let config = AdjustAdobeExtensionConfig(environment: ADJEnvironmentSandbox) {
   14
       config.setDeferredDeeplinkReceivedBlock { (deeplink: URL?) -> Bool in
   15
            if let deeplinkString = deeplink?.absoluteString.lowercased(),
   16
            deeplinkString.contains("no_open") {
   17
                return false
   18
            }
   19
       }
   20
       AdjustAdobeExtension.setConfiguration(config)
   21
   }

   12
   AdjustAdobeExtensionConfig *config = [AdjustAdobeExtensionConfig configWithEnvironment:ADJEnvironmentSandbox];
   13
   [config setDeferredDeeplinkReceivedBlock:^BOOL(NSURL * _Nullable deeplink) {
   14
        if (deeplink && [[deeplink.absoluteString lowercaseString] containsString:@"no_open"]) {
   15
            return NO;
   16
        }
   17
   }];
   18
   [AdjustAdobeExtension setConfiguration:config];

3. Finally, return true to open all deep links that don't contain "no_open".

   • Swift
   • Objective-C

   13
   if let config = AdjustAdobeExtensionConfig(environment: ADJEnvironmentSandbox) {
   14
       config.setDeferredDeeplinkReceivedBlock { (deeplink: URL?) -> Bool in
   15
            if let deeplinkString = deeplink?.absoluteString.lowercased(),
   16
            deeplinkString.contains("no_open") {
   17
                return false
   18
            }
   19
            return true
   20
       }
   21
       AdjustAdobeExtension.setConfiguration(config)
   22
   }

   12
   AdjustAdobeExtensionConfig *config = [AdjustAdobeExtensionConfig configWithEnvironment:ADJEnvironmentSandbox];
   13
   [config setDeferredDeeplinkReceivedBlock:^BOOL(NSURL * _Nullable deeplink) {
   14
        if (deeplink && [[deeplink.absoluteString lowercaseString] containsString:@"no_open"]) {
   15
            return NO;
   16
        }
   17
        return YES;
   18
   }];
   19
   [AdjustAdobeExtension setConfiguration:config];

That's it! When a user opens your app with a deferred deep link, the Adjust Extension will check if the link contains the string "no_open". If it does, the app won't open the deep link.