Integration guide

This is a step-by-step guide to help you integrate and configure the Adjust Extension in your Adobe Experience app for iOS. With this extension, you can seamlessly integrate Adjust with the Adobe Experience SDK to capture and send attribution data and in-app event information.

This extension enables you to send installs, sessions, custom in-app events, and other types of data to Adjust. Follow this guide to set up and configure the Adjust Extension and verify that you can send install information to Adjust.

Set up your project

Follow these steps to set up your project to support the Adjust Extension for Adobe Experience SDK.

Install the Adjust Extension

To use the Adjust Extension for Adobe Experience SDK, you need to add it to your project as a dependency.

If you're using Swift Package Manager, enter the following URL:

1
https://github.com/adjust/ios_adobe_extension.git

If you're using CocoaPods, add the following line to your Podfile:

pod 'AdjustAdobeExtension'

Add iOS frameworks

The Adjust Extension requires additional iOS frameworks to access information about a device. Add the following frameworks and mark them as optional to enable these features.

AdSupport.framework

Used to access the ID for Advertisers (IDFA) and Limited Ad Tracking (LAT) information. LAT is available only on devices running iOS 14 or earlier.

AppTrackingTransparency.framework

Used to enable the Adjust Extension to wrap the user AppTrackingTransparency (ATT) consent dialog and access a user's ATT consent data. ATT is avaliable only on devices running iOS 14 or later.

AdServices.framework

Used to enable the Adjust Extension to automatically handle attribution for Apple Search Ads (ASA) campaigns on devices running iOS 14.3 or later. Required when using the Apple Ads Attribution API.

StoreKit.framework

Used to enable the Adjust Extension to communicate with theSKAdNetworkframework on devices running iOS 14 or later.

Integration guide

Once you've completed the project setup steps, you can integrate the Adjust SDK. The following guide shows you how to:

1. Add the Adjust Extension to your Adobe Experience app.
2. Set your logging level to verbose to retrieve as much detail as possible from the extension.
3. Test the Extension in sandbox mode to ensure it sends data to Adjust.
4. Enable your app to open deep links.
5. Register with the Adobe Experience SDK.

To do this, you need to create the following files:

1
#import <UIKit/UIKit.h>
2

3
@interface AppDelegate : UIResponder <UIApplicationDelegate>
4
@end

1
#import <UIKit/UIKit.h>
2

3
@interface ViewController : UIViewController
4
@end

Import classes

First, you need to import some classes into your application files. Import the following classes into your App Delegate:

AEPCore

Contains the implementation of the Event Hub.

AEPServices

Provides implementations for platform support such as networking, disk access, and database management.

AdjustAdobeExtension

The Adjust Extension for Adobe Experience SDK.

1
import AEPCore
2
import AEPServices
3
import AdjustAdobeExtension

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

Next, import the following classes into your View Controller:

AEPCore

Contains the implementation of the Event Hub.

AdjustAdobeExtension

The Adjust Extension for Adobe Experience SDK.

1
import AEPCore
2
import AdjustAdobeExtension

1
#import "ViewController.h"
2
@import AEPCore;
3
#import <AdjustAdobeExtension/AdjustAdobeExtension.h>

Create an App Delegate

To register the Adjust iOS Extension for Adobe Experience SDK, you need to create an App Delegate. If you've not yet created an App Delegate, follow these steps:

1. Create a new AppDelegate implementation.

   • Swift
   • Objective-C

   1
   import AEPCore
   2
   import AEPServices
   3
   import AdjustAdobeExtension
   4
   
   5
   @main
   6
   class AppDelegate: UIResponder, UIApplicationDelegate {}

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

2. Within your AppDelegate implementation, create a new function called application that returns a boolean. This function takes the following arguments:

   application: UIApplication

   The singleton app object.

   launchOptions: [UIApplication.LaunchOptionsKey : Any]

   A dictionary indicating the reason the app was launched.

   • Swift
   • Objective-C

   5
   @main
   6
   class AppDelegate: UIResponder, UIApplicationDelegate {
   7
      func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {}
   8
   }

   6
   @implementation AppDelegate
   7
   
   8
   - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {}

Configure the Adjust Extension

Once you've created the App Delegate, follow these steps to configure the Adjust iOS Extension for Adobe Experience SDK:

1. Inside your application function, set your logging level by calling the setLogLevel method of the AEPMobileCore class with the following argument:

   logLevel

   The level of logging you want to enable.

   • Trace: enable all logging.
   • Debug: disable verbose logging.
   • Warning: log only errors and warnings.
   • Error: log only errors.

   • Swift
   • Objective-C

   7
   func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
   8
      MobileCore.setLogLevel(LogLevel.trace)
   9
   }

   8
   - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
   9
      [AEPMobileCore setLogLevel: AEPLogLevelTrace];
   10
   }

2. Create a new UIApplicationState variable called appState. You'll use this to communicate the app state with the Adobe Experience SDK.

   • Swift
   • Objective-C

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

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

3. Create a new AdjustAdobeExtensionConfig instance named config with the following argument:

   environment: NSString

   The environment in which your device is running.

   • Pass ADJEnvironmentSandbox when testing.
   • Pass ADJEnvironmentProduction when running the app in production.

   • Swift
   • Objective-C

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

   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
   }

4. Call the setConfiguration method of the AdjustAdobeExtension class with your configuration instance as an argument to register the configuration.

   • Swift
   • Objective-C

   7
   func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
   8
      MobileCore.setLogLevel(LogLevel.trace)
   9
      let appState = application.applicationState
   10
   
   11
      if let config = AdjustAdobeExtensionConfig(environment: ADJEnvironmentSandbox) {
   12
         AdjustAdobeExtension.setConfiguration(config)
   13
      }
   14
   }

   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
      [AdjustAdobeExtension setConfiguration:config];
   14
   }

Register the Adjust Extension

Once you've configured the Adjust Extension, you need to register it with the Adobe Experience SDK. To do this:

1. Inside your application function, call the registerExtensions method of the AEPMobileCore class with the following arguments:

   extensions: NSArray<Class*>* _Nonnull

   A list of extensions.

   completion: (^ _Nullable)(void))

   A completion handler.

   For the purposes of this guide, pass the AdjustAdobeExtension class for extensions. You'll set your completion handler in the next step.

   • Swift
   • Objective-C

   7
   func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
   8
      MobileCore.setLogLevel(LogLevel.trace)
   9
      let appState = application.applicationState
   10
   
   11
      if let config = AdjustAdobeExtensionConfig(environment: ADJEnvironmentSandbox) {
   12
         AdjustAdobeExtension.setConfiguration(config)
   13
      }
   14
   
   15
      MobileCore.registerExtensions([AdjustAdobeExtension.self]) {}
   16
   }

   9
   - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
   10
      [AEPMobileCore setLogLevel: AEPLogLevelTrace];
   11
      const UIApplicationState appState = application.applicationState;
   12
   
   13
      AdjustAdobeExtensionConfig *config = [AdjustAdobeExtensionConfig configWithEnvironment:ADJEnvironmentSandbox];
   14
      [AdjustAdobeExtension setConfiguration:config];
   15
   
   16
      [AEPMobileCore registerExtensions:@[AdjustAdobeExtension.class]
   17
                              completion: ^{}];
   18
   }

2. Within the completion handler, call the configureWithAppId method of the AEPMobileCore class with your Adobe App ID.

   • Swift
   • Objective-C

   7
   func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
   8
      MobileCore.setLogLevel(LogLevel.trace)
   9
      let appState = application.applicationState
   10
   
   11
      if let config = AdjustAdobeExtensionConfig(environment: ADJEnvironmentSandbox) {
   12
         AdjustAdobeExtension.setConfiguration(config)
   13
      }
   14
   
   15
      MobileCore.registerExtensions([AdjustAdobeExtension.self]) {
   16
         MobileCore.configureWith(appId: "{your_adobe_app_id}")
   17
      }
   18
   }

   9
   - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
   10
      [AEPMobileCore setLogLevel: AEPLogLevelTrace];
   11
      const UIApplicationState appState = application.applicationState;
   12
   
   13
      AdjustAdobeExtensionConfig *config = [AdjustAdobeExtensionConfig configWithEnvironment:ADJEnvironmentSandbox];
   14
      [AdjustAdobeExtension setConfiguration:config];
   15
   
   16
      [AEPMobileCore registerExtensions:@[AdjustAdobeExtension.class]
   17
                              completion: ^{
   18
         [AEPMobileCore configureWithAppId: @"{your_adobe_app_id}"];
   19
      }];
   20
   }

3. Inside your completion handler, add an if block to call the lifecycleStart method of the AEPMobileCore if the app isn't in the background.

   • Swift
   • Objective-C

   7
   func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
   8
      MobileCore.setLogLevel(LogLevel.trace)
   9
      let appState = application.applicationState
   10
   
   11
      if let config = AdjustAdobeExtensionConfig(environment: ADJEnvironmentSandbox) {
   12
         AdjustAdobeExtension.setConfiguration(config)
   13
      }
   14
   
   15
      MobileCore.registerExtensions([AdjustAdobeExtension.self]) {
   16
         MobileCore.configureWith(appId: "{your_adobe_app_id}")
   17
         if appState != .background {
   18
            MobileCore.lifecycleStart(additionalContextData: nil)
   19
         }
   20
      }
   21
   }

   9
   - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
   10
      [AEPMobileCore setLogLevel: AEPLogLevelTrace];
   11
      const UIApplicationState appState = application.applicationState;
   12
   
   13
      AdjustAdobeExtensionConfig *config = [AdjustAdobeExtensionConfig configWithEnvironment:ADJEnvironmentSandbox];
   14
      [AdjustAdobeExtension setConfiguration:config];
   15
   
   16
      [AEPMobileCore registerExtensions:@[AdjustAdobeExtension.class]
   17
                              completion: ^{
   18
         [AEPMobileCore configureWithAppId: @"{your_adobe_app_id}"];
   19
         if (appState != UIApplicationStateBackground) {
   20
            [AEPMobileCore lifecycleStart:nil];
   21
         }
   22
      }];
   23
   }

4. Finally, return a true value at the top level of your application function.

   • Swift
   • Objective-C

   7
   func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
   8
      MobileCore.setLogLevel(LogLevel.trace)
   9
      let appState = application.applicationState
   10
   
   11
      if let config = AdjustAdobeExtensionConfig(environment: ADJEnvironmentSandbox) {
   12
         AdjustAdobeExtension.setConfiguration(config)
   13
      }
   14
   
   15
      MobileCore.registerExtensions([AdjustAdobeExtension.self]) {
   16
         MobileCore.configureWith(appId: "{your_adobe_app_id}")
   17
         if appState != .background {
   18
            MobileCore.lifecycleStart(additionalContextData: nil)
   19
         }
   20
      }
   21
   
   22
      return true
   23
   }

   9
   - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
   10
      [AEPMobileCore setLogLevel: AEPLogLevelTrace];
   11
      const UIApplicationState appState = application.applicationState;
   12
   
   13
      AdjustAdobeExtensionConfig *config = [AdjustAdobeExtensionConfig configWithEnvironment:ADJEnvironmentSandbox];
   14
      [AdjustAdobeExtension setConfiguration:config];
   15
   
   16
      [AEPMobileCore registerExtensions:@[AdjustAdobeExtension.class]
   17
                              completion: ^{
   18
         [AEPMobileCore configureWithAppId: @"{your_adobe_app_id}"];
   19
         if (appState != UIApplicationStateBackground) {
   20
            [AEPMobileCore lifecycleStart:nil];
   21
         }
   22
      }];
   23
   
   24
      return YES;
   25
   }

Set up deep link handling

To configure the Adjust iOS Extension for Adobe Experience SDK to open deep links, follow these steps:

1. Within your AppDelegate implementation, create a new boolean function called application to handle opening deep links. Thie function takes the following arguments:

   app: UIApplication

   The singleton app object.

   url: NSURL

   The URL resource to open in the app.

   options: [UIApplicationOpenURLOptionsKey : id]

   A dictionary of options for handling the URL, containing keys that specify options related to the URL.

   • Swift
   • Objective-C

   25
   func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {}

   27
   - (BOOL)application:(UIApplication *)app openURL:(NSURL *)url options:(NSDictionary<UIApplicationOpenURLOptionsKey,id> *)options {}

2. Inside this function, call the processDeeplink method of the Adjust class to open the deep link and return a true value.

   • Swift
   • Objective-C

   25
   func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
   26
      if let deeplink = ADJDeeplink(deeplink: url) {
   27
         Adjust.processDeeplink(deeplink)
   28
      }
   29
      return true
   30
   }

   27
   - (BOOL)application:(UIApplication *)app openURL:(NSURL *)url options:(NSDictionary<UIApplicationOpenURLOptionsKey,id> *)options {
   28
      [Adjust processDeeplink: [[ADJDeeplink alloc] initWithDeeplink:url]];
   29
      return YES;
   30
   }

3. Next, create another boolean function called application to handle resuming user activity. This function takes the following arguments:

   application: UIApplication

   The singleton app object.

   userActivity: NSUserActivity

   The user activity object that represents the activity to continue.

   restorationHandler: void (^)(NSArray<id<UIUserActivityRestoring>> * _Nullable)

   A handler block to use for restoring the app’s state if needed.

   • Swift
   • Objective-C

   32
   func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {}

   32
   - (BOOL)application:(UIApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void (^)(NSArray<id<UIUserActivityRestoring>> * _Nullable))restorationHandler {}

4. Inside this function, add a check to see if the app was opened by a link and call processDeeplink if it is.

   • Swift
   • Objective-C

   32
   func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
   33
      if userActivity.activityType == NSUserActivityTypeBrowsingWeb {
   34
         if let incomingUrl = userActivity.webpageUrl {
   35
            if let deeplink = ADJDeeplink(deeplink: incomingUrl) {
   36
               Adjust.processDeeplink(deeplink)
   37
            }
   38
         }
   39
      }
   40
      return true
   41
   }

   32
   - (BOOL)application:(UIApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void (^)(NSArray<id<UIUserActivityRestoring>> * _Nullable))restorationHandler {
   33
      if ([[userActivity activityType] isEqualToString:NSUserActivityTypeBrowsingWeb]) {
   34
        [Adjust proceessDeeplink:[[ADJDeeplink alloc] initWithDeeplink:[userActivity webpageURL]]];
   35
      }
   36
      return YES;
   37
   }

   If you use short branded links, you can alternatively use the Adjust.processAndResolveDeeplink method to resolve your shortened link and return it to a callback function.

   • Swift
   • Objective-C

   32
   func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
   33
      if userActivity.activityType == NSUserActivityTypeBrowsingWeb {
   34
         if let incomingUrl = userActivity.webpageUrl {
   35
            if let deeplink = ADJDeeplink(deeplink: incomingUrl) {
   36
               Adjust.processAndResolveDeeplink(deeplink) { resolveDeeplink in
   37
                  print("[\(resolveDeeplink)]")
   38
               }
   39
            }
   40
         }
   41
      }
   42
      return true
   43
   }

   32
   - (BOOL)application:(UIApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void (^)(NSArray<id<UIUserActivityRestoring>> * _Nullable))restorationHandler {
   33
      if ([[userActivity activityType] isEqualToString:NSUserActivityTypeBrowsingWeb]) {
   34
         ADJDeeplink *deeplink = [[ADJDeeplink alloc] initWithDeeplink:[userActivity webpageURL]];
   35
         [Adjust processAndResolveDeeplink:deeplink
   36
                  withCompletionHandler:^(NSString * _Nullable resolvedLink) {
   37
                     NSLog(@"[%@]", resolvedLink);
   38
         }];
   39
      }
   40
      return YES;
   41
   }

Set up your View Controller

Next, you need to set up your View Controller. You'll use this file to set up your Adjust features later. For the purposes of this guide, you're only going to set up the viewDidLoad function to handle application startup.

1. Inside your View Controller file, createa a new ViewController class implementation.

   • Swift
   • Objective-C

   4
   class ViewController: UIViewController {}

   5
   @implementation ViewController
   6
   @end

2. Inside your ViewController class, create a void function that calls super.viewDidLoad to initialize your view.

   • Swift
   • Objective-C

   4
   class ViewController: UIViewController {
   5
   
   6
      override func viewDidLoad() {
   7
         super.viewDidLoad()
   8
      }
   9
   }

   5
   @implementation ViewController
   6
   
   7
   - (void)viewDidLoad {
   8
      [super viewDidLoad];
   9
   }
   10
   
   11
   @end

Once you've completed these steps, build and run your app. After you launch your app, you should see the message Install tracked in your Xcode logs.