SDK v5 migration guide

Before you begin

Here’s what you need to do before updating to SDK v5:

SDK v5 supports SDK signature verification natively. If you currently use the SDK signature library, you need to uninstall this first.
If your app targets API versions lower than the following, you need to update your app before you can use SDK v5:
- iOS: 12.0
- tvOS: 12.0

Install the beta SDK

To start using SDK v5, you need to add it as a dependency in your XCode project. To do this:

Remove any older versions of the SDK you currently have in your Podfile.
Add the following line to your Podfile:
Podfile
```
pod 'Adjust', '~> 5.0.1'
```
Run pod install to install the dependencies.

Update the initialization method

Changed in v5

In SDK v4, the SDK is initialized by configuring an ADJConfig object and passing it to the [Adjust appDidLaunch] method.

Swift
Objective-C

1
let yourAppToken = "{YourAppToken}"
2
let environment = ADJEnvironmentSandbox as? String
3
let adjustConfig = ADJConfig(
4
      appToken: yourAppToken,
5
      environment: environment)
6

7
Adjust.appDidLaunch(adjustConfig)

1
#import "Adjust.h"
2

3
NSString *yourAppToken = @"{YourAppToken}";
4
NSString *environment = ADJEnvironmentSandbox;
5
*adjustConfig = [ADJConfig configWithAppToken:yourAppToken;
6
                                  environment:environment];
7

8
[Adjust appDidLaunch:adjustConfig];

In SDK v5, this method has been renamed to [Adjust initSdk].

Swift
Objective-C

1
let yourAppToken = "{YourAppToken}"
2
let environment = ADJEnvironmentSandbox as? String
3
let adjustConfig = ADJConfig(
4
      appToken: yourAppToken,
5
      environment: environment)
6

7
Adjust.initSdk(adjustConfig)

1
#import "Adjust.h"
2

3
NSString *yourAppToken = @"{YourAppToken}";
4
NSString *environment = ADJEnvironmentSandbox;
5
ADJConfig *adjustConfig = [[ADJConfig alloc] initWithAppToken:yourAppToken
6
                                                  environment:environment];
7

8
[Adjust initSdk:adjustConfig];

Configure the SDK Signature library

SDK v5 includes the SDK signature library. You can test this by following the testing steps in the Signature library integration guide.

Signature protection is inactive by default. To enable it, you need to enforce signature validation.

Changed APIs

Changed in v5

The following APIs have been changed in SDK v5.

Disable and enable the SDK

In SDK v4, you can enable and disable the SDK by calling [Adjust setEnabled] with a BOOL value.

Call [Adjust setEnabled:NO] to disable the SDK.
Call [Adjust setEnabled:YES] to enable the SDK

Swift
Objective-C

1
Adjust.setEnabled(false) //disable SDK
2
Adjust.setEnabled(true) //enable SDK

1
[Adjust setEnabled:NO]; // disable SDK
2
[Adjust setEnabled:YES]; // enable SDK

In SDK v5, this feature is split into separate commands for clarity.

Call [Adjust disable] to disable the SDK.
Call [Adjust enable] to enable the SDK.

Swift
Objective-C

1
Adjust.disable() //disable SDK
2
Adjust.enable() //enable SDK

1
[Adjust disable]; // disable SDK
2
[Adjust enable]; // enable SDK

Send information in background

In SDK v4, you can call the [ADJConfig setSendInBackground] method with a true argument to enable the SDK to send information to Adjust while your app is running in the background.

Swift
Objective-C

1
adjustConfig.setSendInBackground(true)

1
[adjustConfig setSendInBackground:YES];

In SDK v5, you need to call the [ADJConfig enableSendingInBackground] method with no arguments to enable the SDK to send information to Adjust while your app is running in the background.

Swift
Objective-C

1
adjustConfig.enableSendingInBackground()

1
[adjustConfig enableSendingInBackground];

Disable AdServices information reading

In SDK v4, you can call the [ADJConfig setAllowAdServicesInfoReading] method with a false argument to prevent the Adjust SDK from reading AdServices information.

Swift
Objective-C

1
adjustConfig.setAllowAdServicesInfoReading(false)

1
[adjustConfig setAllowAdServicesInfoReading:NO];

In SDK v5, you need to call the disableAdServices method with no arguments to prevent the Adjust SDK from reading AdServices information.

Swift
Objective-C

1
adjustConfig.disableAdServices()

1
[adjustConfig disableAdServices];

Disable IDFA reading

In SDK v4, you can call the [ADJConfig setAllowIdfaReading] method with a false argument to prevent the Adjust SDK from reading the device’s IDFA.

Swift
Objective-C

1
adjustConfig.setAllowIdfaReading(false)

1
[adjustConfig setAllowIdfaReading:NO];

In SDK v5, you need to call the disableIdfaReading method with no arguments to prevent the Adjust SDK from reading the device’s IDFA.

Swift
Objective-C

1
adjustConfig.disableIdfaReading()

1
[adjustConfig disableIdfaReading];

Enable cost data in attribution

In SDK v4, you can enable cost data in the device’s attribution information by calling the [ADJConfig setNeedsCost] method with a true argument.

Swift
Objective-C

1
adjustConfig.setNeedsCost(true)

1
[adjustConfig setNeedsCost:YES];

In SDK v5, you need to call the [ADJConfig enableCostDataInAttribution] method with no arguments.

Swift
Objective-C

1
adjustConfig.enableCostDataInAttribution()

1
[adjustConfig enableCostDataInAttribution];

Enable LinkMe

In SDK v4, you can enable Adjust LinkMe by calling the [ADJConfig setLinkMeEnabled] method with a true argument.

Swift
Objective-C

1
adjustConfig.setLinkMeEnabled(true)

1
[adjustConfig setLinkMeEnabled:YES];

In SDK v5, you need to call the [ADJConfig enableLinkMe] method with no arguments.

Swift
Objective-C

1
adjustConfig.enableLinkMe()

1
[adjustConfig enableLinkMe];

Only read device IDs once

In SDK v4, you can instruct the SDK to only read device identifiers one time upon startup by calling the [ADJConfig setReadDeviceInfoOnceEnabled] method with a true argument.

Swift
Objective-C

1
adjustConfig.setReadDeviceInfoOnceEnabled(true)

1
[adjustConfig setReadDeviceInfoOnceEnabled:YES];

In SDK v5, you need to call the [ADJConfig enableDeviceIdsReadingOnce] method with no arguments.

Swift
Objective-C

1
adjustConfig.enableDeviceIdsReadingOnce()

1
[adjustConfig enableDeviceIdsReadingOnce];

Offline mode

In SDK v4, you can enable and disable offline mode the SDK by calling [Adjust setOfflineMode] with a BOOL argument.

Swift
Objective-C

1
Adjust.setOfflineMode(true) // put the SDK in offline mode
2
Adjust.setOfflineMode(false) // put the SDK back in online mode

1
[Adjust setOfflineMode:YES]; // put the SDK in offline mode
2
[Adjust setOfflineMode:NO]; // put the SDK back in online mode

In SDK v5, this feature is split into separate commands for clarity.

Call [Adjust switchToOfflineMode] to set the SDK to offline mode.
Call [Adjust switchBackToOnlineMode] to set the SDK back to online mode.

Swift
Objective-C

1
Adjust.switchToOfflineMode() // put the SDK in offline mode
2
Adjust.switchBackToOnlineMode() // put the SDK back in online mode

1
[Adjust switchToOfflineMode]; // put the SDK in offline mode
2
[Adjust switchBackToOnlineMode]; // put the SDK back in online mode

Push tokens

In SDK v4, you can set your push tokens using the [Adjust setDeviceToken] method.

Swift
Objective-C

1
func application(_ app: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
2
    Adjust.setDeviceToken(deviceToken)
3
}

1
- (void)application:(UIApplication *)app didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
2
    [Adjust setDeviceToken:deviceToken];
3
}

This method has been renamed to [Adjust setPushToken] in SDK v5.

Swift
Objective-C

1
func application(_ app: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken pushToken: Data) {
2
    Adjust.setPushToken(pushToken)
3
}

1
- (void)application:(UIApplication *)app didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)pushToken {
2
    [Adjust setPushToken:pushToken];
3
}

Session callback parameters

In SDK v4, you can add session parameters by passing a key-value pair to the [Adjust addSessionCallbackParameter] method and remove individual parameters using the [Adjust removeSessionCallbackParameter] method.

Swift
Objective-C

1
Adjust.addSessionCallbackParameter("foo", value: "bar")
2
Adjust.removeSessionCallbackParameter("foo")
3
Adjust.resetSessionCallbackParameters()

1
[Adjust addSessionCallbackParameter:@"foo" value:@"bar"];
2
[Adjust removeSessionCallbackParameter:@"foo"];
3
[Adjust resetSessionCallbackParameters];

In SDK v5, session parameters are renamed to global parameters. Instead of assigning the key and value as positional arguments, SDK v5 uses the forKey instance method to assign values to keys.

Swift
Objective-C

1
Adjust.addGlobalCallbackParameter("bar", forKey: "foo")
2
Adjust.removeGlobalCallbackParameter(forKey: "foo")
3
Adjust.removeGlobalCallbackParameters()

1
[Adjust addGlobalCallbackParameter:@"bar" forKey:@"foo"];
2
[Adjust removeGlobalCallbackParameterForKey:@"foo"];
3
[Adjust removeGlobalCallbackParameters];

Session partner parameters

In SDK v4, you can add session partner parameters by passing a key-value pair to the [Adjust addSessionPartnerParameter] method and remove individual parameters using the [Adjust removeSessionPartnerParameter] method.

Swift
Objective-C

1
Adjust.addSessionPartnerParameter("foo", value: "bar")
2
Adjust.removeSessionPartnerParameter("foo")
3
Adjust.resetSessionPartnerParameters()

1
[Adjust addSessionPartnerParameter:@"foo" value:@"bar"];
2
[Adjust removeSessionPartnerParameter:@"foo"];
3
[Adjust resetSessionPartnerParameters];

In SDK v5, session partner parameters are renamed to global partner parameters. Instead of assigning the key and value as positional arguments, SDK v5 uses the forKey instance method to assign values to keys.

Swift
Objective-C

1
Adjust.addGlobalPartnerParameter("bar", forKey: "foo")
2
Adjust.removeGlobalPartnerParameter(forKey: "foo")
3
Adjust.removeGlobalPartnerParameters()

1
[Adjust addGlobalPartnerParameter:@"bar" forKey:@"foo"];
2
[Adjust removeGlobalPartnerParameterForKey:@"foo"];
3
[Adjust removeGlobalPartnerParameters];

Send subscription information

In SDK v4, you can use the ADJSubscription class to create a payload of subscription information to send to Adjust.

Swift
Objective-C

1
let subscription = ADJSubscription(
2
    price: price,
3
    currency: currency,
4
    transactionId: transactionId,
5
    andReceipt: receipt)

1
ADJSubscription *subscription = [[ADJSubscription alloc] initWithPrice:price
2
                                                              currency:currency
3
                                                        transactionId:transactionId];

This class has been renamed to ADJAppStoreSubscription in SDK v5 for clarity.

Swift
Objective-C

1
let subscription = ADJAppStoreSubscription(
2
    price: price,
3
    currency: currency,
4
    transactionId: transactionId)

1
ADJAppStoreSubscription *subscription = [[ADJAppStoreSubscription alloc]
2
                                             initWithPrice:price
3
                                             currency:currency
4
                                             transactionId:transactionId];

Event deduplication

In SDK v4, event deduplication is coupled with the event transaction ID and is limited to a maximum of 10 unique IDs.

Swift
Objective-C

1
let event = ADJEvent(eventToken: "eventToken")
2
event.setTransactionId("deduplication_id")
3
Adjust.trackEvent(event)

1
ADJEvent *event = [ADJEvent eventWithEventToken:@"event_token"];
2
[event setTransactionId:@"deduplication_id"];
3
[Adjust trackEvent:event];

In SDK v5, the feature is decoupled from transaction ID. A new ID field called deduplicationId has been added for event deduplication. Users can set a custom limit on the number of deduplicationId that can be added to the list for identifying duplicate events. By default, the limit is set to 10.

Swift
Objective-C

1
let yourAppToken = "{YourAppToken}"
2
let environment = ADJEnvironmentSandbox as? String
3
let adjustConfig = ADJConfig(
4
      appToken: yourAppToken,
5
      environment: environment)
6

7
adjustConfig.setEventDeduplicationIdsMaxSize(20)
8
Adjust.initSdk(adjustConfig)
9

10
guard let event = ADJEvent(eventToken: "eventToken") else { return }
11
event.setDeduplicationId("deduplication_id")
12
Adjust.trackEvent(event)

1
NSString *yourAppToken = @"{YourAppToken}";
2
NSString *environment = ADJEnvironmentSandbox;
3
ADJConfig *adjustConfig = [[ADJConfig alloc] initWithAppToken:yourAppToken
4
                                                  environment:environment];
5

6
[adjustConfig setEventDeduplicationIdsMaxSize:20];
7
[Adjust initSdk:adjustConfig];
8

9
ADJEvent *event = [[ADJEvent alloc] initWithEventToken:kEventToken3];
10
[event setDeduplicationId:@"deduplication_id"];
11
[Adjust trackEvent:event];

AdjustAttribution class

In SDK v4, the AdjustAttribution calls has a property called adid. In SDK v5, the adid property has been removed from the AdjustAttribution class. You can retrieve the device’s ADID using the [Adjust adidWithCompletionHandler] getter method.

Reattribution using deep links

In SDK v4, you can pass your deep link information to the [Adjust appWillOpenUrl] method.

Swift
Objective-C

1
func application(
2
    _ app: UIApplication,
3
    open incomingURL: URL,
4
    options: [UIApplication.OpenURLOptionsKey: Any] = [:]
5
    ) -> Bool {
6

7
    // add your code below to handle deep link
8
    // (for example, open deep link content)
9
    // incomingURL object contains the deep link
10

11
    // call the below method to send deep link to Adjust's servers
12
    Adjust.appWillOpen(incomingURL)
13

14
    return true
15
}

1
- (BOOL)application:(UIApplication *)app
2
    openURL:(NSURL *)incomingURL
3
    options:(NSDictionary *)options {
4

5
    // add your code below to handle deep link
6
    // (for example, open deep link content)
7
    // incomingURL object contains the deep link
8

9
    // call the below method to send deep link to Adjust's servers
10
    [Adjust appWillOpenUrl:incomingURL];
11

12
    return YES;
13
}

In SDK v5, this has been renamed to [Adjust processDeeplink] for clarity.

Swift
Objective-C

1
func application(
2
    _ app: UIApplication,
3
    open incomingURL: URL,
4
    options: [UIApplication.OpenURLOptionsKey: Any] = [:]
5
    ) -> Bool {
6

7
    // add your code below to handle deep link
8
    // (for example, open deep link content)
9
    // incomingURL object contains the deep link
10

11
    // call the below method to send deep link to Adjust's servers
12
   if let deeplink = ADJDeeplink(deeplink: incomingURL) {
13
      Adjust.processDeeplink(deeplink)
14
   }
15
    return true
16
}

1
- (BOOL)application:(UIApplication *)app
2
    openURL:(NSURL *)incomingURL
3
    options:(NSDictionary *)options {
4

5
    // add your code below to handle deep link
6
    // (for example, open deep link content)
7
    // incomingURL object contains the deep link
8

9
    // call the below method to send deep link to Adjust's servers
10
    [Adjust processDeeplink:[[ADJDeeplink alloc] initWithDeeplink:incomingURL]];
11

12
    return YES;
13
}

Deferred deep linking callback

In SDK v4, you can call the adjustDeepLinkResponse method to handle deferred deep link callbacks.

Swift
Objective-C

1
func adjustDeeplinkResponse(_ deeplink: URL?) -> Bool {
2
   print("Deferred deep link callback called!")
3
   print(String(format: "Deferred deep link URL: %@", deeplink.absoluteString))
4

5
   // Allow Adjust SDK to open received deferred deep link.
6
   // If you don't want it to open it, return false instead.
7
   return true
8
}

1
- (BOOL)adjustDeeplinkResponse:(NSURL *)deeplink {
2
    NSLog(@"Deferred deep link callback called!");
3
    NSLog(@"Deferred deep link URL: %@", [deeplink absoluteString]);
4

5
    // Allow Adjust SDK to open received deferred deep link.
6
    // If you don't want it to open it, return NO; instead.
7
    return YES;
8
}

In SDK v5, this method is has been renamed to adjustDeferredDeeplinkReceived for clarity. All arguments are the same.

Swift
Objective-C

1
func adjustDeferredDeeplinkReceived(_ deeplink: URL?) -> Bool {
2
   print("Deferred deep link callback called!")
3
   print(String(format: "Deferred deep link URL: %@", deeplink.absoluteString))
4

5
   // Allow Adjust SDK to open received deferred deep link.
6
   // If you don't want it to open it, return false instead.
7
   return true
8
}

1
- (BOOL)adjustDeferredDeeplinkReceived:(NSURL *)deeplink {
2
    NSLog(@"Deferred deep link callback called!");
3
    NSLog(@"Deferred deep link URL: %@", [deeplink absoluteString]);
4

5
    // Allow Adjust SDK to open received deferred deep link.
6
    // If you don't want it to open it, return NO; instead.
7
    return YES;
8
}

COPPA compliance

In SDK v4, you can mark your app as COPPA compliant by calling the setCoppaCompliantEnabled method on your ADJConfig instance with a boolean value.

Swift
Objective-C

1
adjustConfig.setCoppaCompliantEnabled(true)

1
[adjustConfig setCoppaCompliantEnabled:YES];

In SDK v5, this method has been renamed to enableCoppaCompliance for clarity. This method takes no arguments.

Swift
Objective-C

1
adjustConfig?.enableCoppaCompliance()

1
[adjustConfig enableCoppaCompliance];

Send ad revenue from a specific source

In SDK v4, ad revenue sources are defined as constants in the ADJConfig class. In SDK v5, ad revenue sources need to be passed as a string.

Swift
Objective-C

let adRevenue = ADJAdRevenue(source: ADJAdRevenueSourceAppLovinMAX); //v4
let adRevenue = ADJAdRevenue(source: "applovin_max_sdk") //v5

ADJAdRevenue *revenue = [[ADJAdRevenue alloc]
                            initWithSource:ADJAdRevenueSourceAppLovinMAX]; // v4
ADJAdRevenue *adRevenue = [[ADJAdRevenue alloc]
                              initWithSource:@"applovin_max_sdk"]; // v5

v4	v5
`ADJAdRevenueSourceAppLovinMAX`	`"applovin_max_sdk"`
`ADJAdRevenueSourceAdMob`	`"admob_sdk"`
`ADJAdRevenueSourceIronSource`	`"ironsource_sdk"`
`ADJAdRevenueSourceAdMost`	`"admost_sdk"`
`ADJAdRevenueSourceUnity`	`"unity_sdk"`
`ADJAdRevenueSourceHeliumChartboost`	`"helium_chartboost_sdk"`
`ADJAdRevenueSourceADX`	`"adx_sdk"`
`ADJAdRevenueSourcePublisher`	`"publisher_sdk"`
`ADJAdRevenueSourceTradplus`	`"tradplus_sdk"`
`ADJAdRevenueSourceTopOn`	`"topon_sdk"`
`ADJAdRevenueSourceMopub`	`"mopub"`

Set data residency and URL strategy

In SDK v4, URL strategy and data residency domains are defined as constants in the ADJConfig class.

1
[adjustConfig setUrlStrategy:ADJDataResidencyEU];

In SDK v5, you need to pass your chosen domain or domains as an array. You can also set the following:

useSubdomains (BOOL): Whether the domain should be treated as an Adjust domain. If true, the SDK will prefix the domains with Adjust-specific subdomains. If false, the SDK will use the provided domain as-is, without adding any prefixes.
isDataResidency (BOOL): Whether the domain should be used for data residency.

1
NSArray *domain = [];
2
[adjustConfig setUrlStrategy:domain useSubdomains:YES
3
                     isDataResidency:YES];

Check the table below to see how to configure your URL strategy in SDK v5.

v4	v5 - main and fallback domain	v5 - use sub domains	v5 - is Data Residency
`ADJDataResidencyEU`	`"eu.adjust.com"`	`true`	`true`
`ADJDataResidencyTR`	`"tr.adjust.com"`	`true`	`true`
`ADJDataResidencyUS`	`"us.adjust.com"`	`true`	`true`
`ADJUrlStrategyChina`	`"adjust.world"`, `"adjust.com"`	`true`	`false`
`ADJUrlStrategyCn`	`"adjust.cn"`, `"adjust.com"`	`true`	`false`
`ADJUrlStrategyCnOnly`	`"adjust.cn"`	`true`	`false`
`ADJUrlStrategyIndia`	`"adjust.net.in"`, `"adjust.com"`	`true`	`false`

let domain = ["adjust.net.in", "adjust.com"]
adjustConfig.setUrlStrategy(domain, useSubdomains: true, isDataResidency: false)

let domain = ["adjust.world", "adjust.com"]
adjustConfig.setUrlStrategy(domain, useSubdomains: true, isDataResidency: false)

let domain = ["adjust.cn"]
adjustConfig.setUrlStrategy(domain, useSubdomains: true, isDataResidency: false)

let domain = ["eu.adjust.com"]
adjustConfig.setUrlStrategy(domain, useSubdomains: true, isDataResidency: true)

let domain = ["tr.adjust.com"]
adjustConfig.setUrlStrategy(domain, useSubdomains: true, isDataResidency: true)

let domain = ["us.adjust.com"]
adjustConfig.setUrlStrategy(domain, useSubdomains: true, isDataResidency: true)

NSArray *domain = [[NSArray alloc]
                       initWithObjects:@"adjust.net.in", @"adjust.com", nil];
[adjustConfig setUrlStrategy:domain useSubdomains:YES isDataResidency:NO];

NSArray *domain = [[NSArray alloc]
                       initWithObjects:@"adjust.world", @"adjust.com", nil];
[adjustConfig setUrlStrategy:domain useSubdomains:YES isDataResidency:NO];

NSArray *domain = [[NSArray alloc]
                       initWithObjects:@"adjust.cn", nil];
[adjustConfig setUrlStrategy:domain useSubdomains:YES isDataResidency:NO];

NSArray *domain = [[NSArray alloc]
                       initWithObjects:@"eu.adjust.com", nil];
[adjustConfig setUrlStrategy:domain useSubdomains:YES isDataResidency:YES];

NSArray *domain = [[NSArray alloc]
                       initWithObjects:@"tr.adjust.com", nil];
[adjustConfig setUrlStrategy:domain useSubdomains:YES isDataResidency:YES];

NSArray *domain = [[NSArray alloc]
                       initWithObjects:@"us.adjust.com", nil];
[adjustConfig setUrlStrategy:domain useSubdomains:YES isDataResidency:YES];

Disable SKAdNetwork communication

In SDK v4, you can prevent the SDK from communicating with SKAdNetwork by calling the [ADJConfig deactivateSKAdNetworkHandling] method.

Swift
Objective-C

1
let yourAppToken = "{YourAppToken}"
2
let environment = ADJEnvironmentSandbox as? String
3
let adjustConfig = ADJConfig(
4
      appToken: yourAppToken,
5
      environment: environment)
6

7
adjustConfig.deactivateSKAdNetworkHandling()

1
ADJConfig *adjustConfig = [[ADJConfig alloc]
2
                               initWithAppToken:@"{YourAppToken}"
3
                               environment:ADJEnvironmentSandbox];
4

5
[adjustConfig deactivateSKAdNetworkHandling];

In SDK v5, this method has been renamed to [ADJConfig disableSkanAttribution] for clarity.

Swift
Objective-C

1
let yourAppToken = "{YourAppToken}"
2
let environment = ADJEnvironmentSandbox as? String
3
let adjustConfig = ADJConfig(
4
      appToken: yourAppToken,
5
      environment: environment)
6

7
adjustConfig?.disableSkanAttribution()

1
ADJConfig *adjustConfig = [[ADJConfig alloc]
2
                               initWithAppToken:@"{YourAppToken}"
3
                               environment:ADJEnvironmentSandbox];
4

5
[adjustConfig disableSkanAttribution];

Update conversion values

In SDK v4, you can use the updateConversionValue method to send updated conversion values to Adjust. This method wraps Apple’s deprecated updateConversionValue method and has been removed in SDK v5.

To update conversion values in SDK v5, use the [Adjust updateSkanConversionValue] method with the following arguments:

conversionValue (NSInteger): The updated conversion value
coarseValue (NSString): The updated coarse conversion value
lockWindow (BOOL): Whether to send the postback before the conversion window ends

Swift
Objective-C

1
Adjust.updateSkanConversionValue(
2
    1,
3
    coarseValue: SKAdNetwork.CoarseConversionValue.low.rawValue,
4
    lockWindow: false) { error in
5
    if let error {
6
        print(String(format:"An error occurred during completion: %@", error))
7
    }
8
}

1
[Adjust updateSkanConversionValue:1
2
                        coarseValue:SKAdNetworkCoarseConversionValueLow
3
                        lockWindow:NO
4
               withCompletionHandler:^(NSError *_Nullable error) {
5
      NSLog(@"An error occurred during completion: %@", error);
6
}];

App Tracking Transparency authorization wrapper

In SDK v4, you can handle changes to a user’s ATT authorization status using the [Adjust requestTrackingAuthorizationWithCompletionHandler] method.

Swift
Objective-C

1
Adjust.requestTrackingAuthorization { status in
2
   switch status {
3
   case 0:
4
      // ATTrackingManagerAuthorizationStatusNotDetermined case
5
      break
6
   case 1:
7
      // ATTrackingManagerAuthorizationStatusRestricted case
8
      break
9
   case 2:
10
      // ATTrackingManagerAuthorizationStatusDenied case
11
      break
12
   case 3:
13
      // ATTrackingManagerAuthorizationStatusAuthorized case
14
      break
15
   default:
16
      break
17
   }
18
}

1
[Adjust requestTrackingAuthorizationWithCompletionHandler:^(NSUInteger status) {
2
   switch (status) {
3
      case 0:
4
         // ATTrackingManagerAuthorizationStatusNotDetermined case
5
         break;
6
      case 1:
7
         // ATTrackingManagerAuthorizationStatusRestricted case
8
         break;
9
      case 2:
10
         // ATTrackingManagerAuthorizationStatusDenied case
11
         break;
12
      case 3:
13
         // ATTrackingManagerAuthorizationStatusAuthorized case
14
         break;
15
   }
16
}];

This has been renamed to [Adjust requestAppTrackingAuthorizationWithCompletionHandler] in SDK v5 for clarity.

Swift
Objective-C

1
Adjust.requestAppTrackingAuthorization { status in
2
   switch status {
3
   case 0:
4
      // ATTrackingManagerAuthorizationStatusNotDetermined case
5
      break
6
   case 1:
7
      // ATTrackingManagerAuthorizationStatusRestricted case
8
      break
9
   case 2:
10
      // ATTrackingManagerAuthorizationStatusDenied case
11
      break
12
   case 3:
13
      // ATTrackingManagerAuthorizationStatusAuthorized case
14
      break
15
   default:
16
      break
17
   }
18
}

1
[Adjust requestAppTrackingAuthorizationWithCompletionHandler:^(NSUInteger status) {
2
   switch (status) {
3
      case 0:
4
         // ATTrackingManagerAuthorizationStatusNotDetermined case
5
         break;
6
      case 1:
7
         // ATTrackingManagerAuthorizationStatusRestricted case
8
         break;
9
      case 2:
10
         // ATTrackingManagerAuthorizationStatusDenied case
11
         break;
12
      case 3:
13
         // ATTrackingManagerAuthorizationStatusAuthorized case
14
         break;
15
   }
16
}];

Get device information

In SDK v4, all device information getter methods run synchronously. In SDK v5, these methods have been changed to run asynchronously. You can add a callback function to handle the information when the asynchronous process completes

Swift
Objective-C

Adjust.adid { adid in
      // add your completion handler
};

Adjust.idfa { idfa in
      // add your completion handler
};

Adjust.idfv { idfv in
      // add your completion handler
};

Adjust.sdkVersion { sdkVersion in
      // add your completion handler
};

Adjust.isEnabled { isEnabled in
      // add your completion handler
};

Adjust.attribution { attribution in
      // add your completion handler
}

[Adjust adidWithCompletionHandler:^(NSString * _Nullable adid) {
      // add your completion handler
}];

[Adjust idfaWithCompletionHandler:^(NSString * _Nullable idfa) {
      // add your completion handler
}];

[Adjust idfvWithCompletionHandler:^(NSString * _Nullable idfv) {
      // add your completion handler
}];

[Adjust sdkVersionWithCompletionHandler:^(NSString * _Nullable sdkVersion) {
      // add your completion handler
}];

[Adjust isEnabledWithCompletionHandler:^(BOOL isEnabled) {
      // add your completion handler
}];

[Adjust attributionWithCompletionHandler:^(ADJAttribution * _Nullable attribution) {
      // add your completion handler
}

Removed APIs

Removed in v5

The following APIs have been removed in SDK v5.

Event buffering

SDK v4 supports event buffering. This feature stores requests event, ad revenue, push tokens, and other information on a local buffer to send at a later date.

Swift
Objective-C

1
Adjust.setEventBufferingEnabled(true)

1
[adjustConfig setEventBufferingEnabled:YES];

This setting has been removed in SDK v5.

Custom user agent string

SDK v4 supports setting a custom User Agent by calling [AdjustConfig setUserAgent] with a user agent string.

Swift
Objective-C

1
adjustConfig.setUserAgent("user_agent_value")

1
[adjustConfig setUserAgent:@"user_agent_value"];

This setting has been removed in SDK v5.

Set whether a device is known

In SDK v4, you can call the [AdjustConfig setIsDeviceKnown]; method to manually inform the SDK whether a device is known.

Swift
Objective-C

1
adjustConfig.setIsDeviceKnown(true)

1
[adjustConfig setIsDeviceKnown:YES];

This setting has been removed in SDK v5.

Delay SDK start

SDK v4 supports delaying the start of the SDK by calling [AdjustConfig setDelayStart]; with up to 10 seconds of delay.

Swift
Objective-C

1
adjustConfig.setDelayStart(10)

1
[adjustConfig setDelayStart:10];

This setting has been removed in SDK v5.

In SDK v4, you can call the Adjust.disableThirdPartySharing() method to globally disable sharing information with third parties globally.

Swift
Objective-C

1
Adjust.disableThirdPartySharing()

1
[Adjust disableThirdPartySharing];

This feature has been removed from SDK v5. In SDK v5, use the [Adjust trackThirdPartySharing] method to enable or disable third party sharing.

Swift
Objective-C

1
guard let adjustThirdPartySharing = ADJThirdPartySharing(isEnabled: 0) else { return }
2
Adjust.trackThirdPartySharing(adjustThirdPartySharing)

1
ADJThirdPartySharing *adjustThirdPartySharing = [[ADJThirdPartySharing alloc] initWithIsEnabled:@NO];
2
[Adjust trackThirdPartySharing:adjustThirdPartySharing];

Check for authorization status change

In SDK v4, you can use the [Adjust checkForNewAttStatus] method to prompt the SDK to read a user’s ATT status and forward the information to Adjust’s servers.

Swift
Objective-C

1
Adjust.checkForNewAttStatus()

1
[Adjust checkForNewAttStatus];

This method has been removed in SDK v5.

Listen for conversion value updates

In SDK v4, you can use the adjustConversionValueUpdated method to listen for SKAdNetwork updates.

Swift
Objective-C

1
func adjustConversionValueUpdated(_ conversionValue: NSNumber) {
2
    print("Conversion value updated callback called!")
3
    print(String(format: "Conversion value: %@", conversionValue))
4
}
5

6
func adjustConversionValueUpdated(_ fineValue: NSNumber, coarseValue: String, lockWindow: NSNumber) {
7
    print("Conversion value updated callback called!")
8
    print(String(format: "Conversion value: %@", fineValue))
9
    print(String(format: "Coarse value: %@", coarseValue))
10
    print(String(format: "Lock window: %@", lockWindow))
11
}

1
- (void)adjustConversionValueUpdated:(NSNumber *)conversionValue {
2
    NSLog(@"Conversion value updated callback called!");
3
    NSLog(@"Conversion value: %@", conversionValue);
4
}
5

6
- (void)adjustConversionValueUpdated:(NSNumber *)fineValue
7
                         coarseValue:(NSString *)coarseValue
8
                          lockWindow:(NSNumber *)lockWindow {
9
    NSLog(@"Conversion value updated callback called!");
10
    NSLog(@"Conversion value: %@", conversionValue);
11
    NSLog(@"Coarse value: %@", coarseValue);
12
    NSLog(@"Lock window: %@", lockWindow);
13
}

In SDK v5, these two methods have been replaced by a single adjustSkanUpdatedWithConversionData method which returns an untyped dictionary. The following keys are currently supported:

conversion_value: The updated conversion value.
coarse_value: The updated coarse conversion value
lock_window: Whether to send the postback before the conversion window ends
error: Any error message returned by the update.

Swift
Objective-C

1
func adjustSkanUpdated(withConversionData data: [String: String]) {
2
    print("Conversion value updated callback called!")
3
    print(String(format: "Conversion value dictionary: \n%@", data.description))
4
}

1
- (void)adjustSkanUpdatedWithConversionData:(NSDictionary<NSString *, NSString *> *)data {
2
    NSLog(@"Conversion value updated callback called!");
3
    NSLog(@"Conversion value dictionary: \n%@", data.description);
4
}

Set an app secret

SDK v4 supports setting an App Secret by calling setAppSecret method on your ADJConfig instance to sign the SDK traffic with.

Swift
Objective-C

1
adjustConfig.setAppSecret(secretId, info1: info1, info2: info2, info3: info3, info4: info4)

1
[adjustConfig setAppSecret:secretId info1:info1 info2:info2 info3:info3 info4:info4];

This setting has been removed in SDK v5.

Removed plugins

Removed in v5

The following plugins have been removed in SDK v5:

Criteo
Trademob
Sociomantic

SDK v5 migration guide

Before you begin

Install the beta SDK

Update the initialization method

Configure the SDK Signature library

Changed APIs

Disable and enable the SDK

Send information in background

Disable AdServices information reading

Disable IDFA reading

Enable cost data in attribution

Enable LinkMe

Only read device IDs once

Offline mode

Push tokens

Session callback parameters

Session partner parameters

Send subscription information

Event deduplication

AdjustAttribution class

Reattribution using deep links

Deferred deep linking callback

COPPA compliance

Send ad revenue from a specific source

Set data residency and URL strategy

Examples

Disable SKAdNetwork communication

Update conversion values

App Tracking Transparency authorization wrapper

Get device information

Removed APIs

Event buffering

Custom user agent string

Set whether a device is known

Delay SDK start

Disable third party sharing globally

Check for authorization status change

Listen for conversion value updates

Set an app secret

Removed plugins