iOS SDK integration for developers

AppsFlyer's SDK uses the following native frameworks:

AdSupport.framework

This framework is required to collect the IDFA from devices.
Without IDFA you cannot attribute installs to Facebook Ads, Twitter, Google ads and other networks.

iAd.framework

This framework is required to record and measure the performance of Apple Search Ads in your app.

Note: Starting SDK version 4.8.11, the SDK automatically adds AdSupport.framework and iAd.framework. There is no need to add them yourself. If you are using an SDK version lower than 4.8.11, see the following instructions.

If you want to remove these frameworks and disable IDFA collection:

1. To disable IDFA collection, see the instructions here.
2. To disable  iAd.framework, see the instructions here.

To add ad support frameworks:

1. In your Xcode project, select your project's target.
2. Select the General tab for your target.
3. Expand the Linked Frameworks and Libraries section.
4. Click + to add a framework.
5. Search for AdSupport.framework
6. Select AdSupport.framework from the list.

Repeat the process for iAd.framework.

AppsFlyer uses the dev key to uniquely identify your account. The dev key is mandatory because it allows the SDK to securely send and retrieve data that belongs to your AppsFlyer account.

To do:

1. Go to your app's dashboard.
2. In the dashboard, under Configuration click App Settings.
3. Copy your dev key.
   
   

   

1. Initialize the SDK in the didFinishLaunchingWithOptions method with your app ID taken from iTunes Connect and your AppsFlyer dev key. Also, add the API methods to handle conversion data and deep linking. The app ID is digits only, without the "id" prefix.
   Objective-CSwift

   - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
       /** APPSFLYER INIT **/
       [AppsFlyerTracker sharedTracker].appsFlyerDevKey = @"<DEV_KEY>";
       [AppsFlyerTracker sharedTracker].appleAppID = @"<APP_ID>";
       
       [AppsFlyerTracker sharedTracker].delegate = self;
       
       /* Set isDebug to true to see AppsFlyer debug logs */
       [AppsFlyerTracker sharedTracker].isDebug = true;
   
       return YES;
   }
   
   // rest of your code, methods such as applicationWillResignActive, applicationDidEnterBackground etc.
   
   //get conversion data and deep linking
   
   -(void)onConversionDataSuccess:(NSDictionary*) installData {
     //Handle Conversion Data (Deferred Deep Link)
       id status = [installData objectForKey:@"af_status"];
       if([status isEqualToString:@"Non-organic"]) {
           id sourceID = [installData objectForKey:@"media_source"];
           id campaign = [installData objectForKey:@"campaign"];
           NSLog(@"This is a none organic install. Media source: %@  Campaign: %@",sourceID,campaign);
       } else if([status isEqualToString:@"Organic"]) {
           NSLog(@"This is an organic install.");
       }
    
   }
   
   -(void)onConversionDataFail:(NSError *) error {
     
     NSLog(@"%@",error);
   }
   
   
   - (void) onAppOpenAttribution:(NSDictionary*) attributionData {
     
     //Handle Deep Link
     NSLog(@"%@",attributionData);
   }
   
   - (void) onAppOpenAttributionFailure:(NSError *)error {
     NSLog(@"%@",error);
   }
   
   // Reports app open from a Universal Link for iOS 9 or above
   - (BOOL) application:(UIApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void (^)(NSArray<id> *restorableObjects))restorationHandler {
       [[AppsFlyerTracker sharedTracker] continueUserActivity:userActivity restorationHandler:restorationHandler];
       return YES;
     }
   
     // Reports app open from deep link from apps which do not support Universal Links (Twitter) and for iOS8 and below
     - (BOOL)application:(UIApplication *)application openURL:(NSURL *)url sourceApplication:(NSString*)sourceApplication annotation:(id)annotation {
       [[AppsFlyerTracker sharedTracker] handleOpenURL:url sourceApplication:sourceApplication withAnnotation:annotation];
       return YES;
     }
     // Reports app open from deep link for iOS 10
     - (BOOL)application:(UIApplication *)application openURL:(NSURL *)url
     options:(NSDictionary *) options {
       [[AppsFlyerTracker sharedTracker] handleOpenUrl:url options:options];
       return YES;
     }
   

   
   

   

   func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
           
           AppsFlyerTracker.shared().appsFlyerDevKey = ""
           AppsFlyerTracker.shared().appleAppID = ""
           
           AppsFlyerTracker.shared().delegate = self
           
           /* Set isDebug to true to see AppsFlyer debug logs */
           AppsFlyerTracker.shared().isDebug = true
   
           return true
       }
   
   // rest of your code, methods such as applicationWillResignActive, applicationDidEnterBackground etc.
   
   //get conversion data and deep linking
   
    func onConversionDataSuccess(_ installData: [AnyHashable: Any]) {
       if let data = installData{
               print("\(data)")
               if let status = data["af_status"] as? String{
                   if(status == "Non-organic"){
                       if let sourceID = data["media_source"] , let campaign = data["campaign"]{
                           print("This is a Non-Organic install. Media source: \(sourceID)  Campaign: \(campaign)")
                       }
                   } else {
                       print("This is an organic install.")
                   }
               }
               
               if let is_first_launch = data["is_first_launch"] , let launch_code = is_first_launch as? Int {
                   if(launch_code == 1){
                       print("First Launch")
                   } else {
                       print("Not First Launch")
                   }
               }
           }
     }
     
     func onConversionDataFail(_ error: Error?) {
        print("\(error)")
     }
     
     func onAppOpenAttribution(_ attributionData: [AnyHashable: Any]) {
        if let data = attributionData {
               if let link = data["link"]{
                   print("link:  \(link)")
               }
           }
    
     }
     
     func onAppOpenAttributionFailure(_ error: Error?) {
     }
   // Reports app open from a Universal Link for iOS 9 or later
     func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([Any]?) -> Void) -> Bool {
       AppsFlyerTracker.shared().continue(userActivity, restorationHandler: restorationHandler)
       return true
     }
   
     // Reports app open from deep link from apps which do not support Universal Links (Twitter) and for iOS8 and below
     func application(_ application: UIApplication, open url: URL, sourceApplication: String?, annotation: Any) -> Bool {
       AppsFlyerTracker.shared().handleOpen(url, sourceApplication: sourceApplication, withAnnotation: annotation)
       return true
     }
   
     // Reports app open from deep link for iOS 10 or later
     func application(_ app: UIApplication, open url: URL, options: [UIApplicationOpenURLOptionsKey : Any] = [:]) -> Bool {
       AppsFlyerTracker.shared().handleOpen(url, options: options)
       return true
     }
   

   For Swift 4.2 and above, use the following code for the continue userActivity method:

   func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
   	AppsFlyerTracker.shared().continue(userActivity, restorationHandler: nil)
   	return true
   }
   

   

2. Add the following code at the applicationDidBecomeActive function:

   Objective-CSwift

   - (void)applicationDidBecomeActive:(UIApplication *)application { 
   // attribute Installs, updates & sessions(app opens) 
   // (You must include this API to enable SDK functions) 
   [[AppsFlyerTracker sharedTracker] trackAppLaunch]; 
   // your other code here.... }

   func applicationDidBecomeActive(application: UIApplication) { 
   // attribute Installs, updates & sessions(app opens) 
   // (You must include this API to enable SDK functions) 
   AppsFlyerTracker.shared().trackAppLaunch() 
   // your other code here.... }

Before you start testing installs, whitelist the device you are going to test on.

Organic installs are unattributed installs which are usually direct installs from app stores.

To simulate an organic install:

1. Make sure you have a mobile device connected to your computer.
2. In Xcode, open the debug terminal.
3. From Xcode Studio, install the app on the device or simulator.
4. Wait for the app to launch.
5. In the debug terminal, look for your app's package name.

You should see the following:

Send Track-App-Launch in the log indicates that the SDK reports an install. This data comes from the onConversionDataSuccess method in app delegate. Getting conversion data is discussed later in this guide.

Note: Starting SDK V5, onConversionDataSuccess is the name of the method for getting conversion data. If you are using an SDK version lower than 5.0.0, the name of the method is onConversionDataReceived. We recommend that you upgrade to SDK 5.0.0. To learn more, click here.

An organic install should now appear on the Overview page of the application's dashboard.

If you don't see an install in the app's dashboard, see our SDK troubleshooting guide.

A non-organic install is an attributed install that usually follows an ad engagement. You can simulate a non-organic install by using attribution links.

To do:

1. Find out what is the itunes ID name of your app e.g. id123456789.
2. In the URL below, replace <APP_ID> with your app's itunes ID:
   

   https://app.appsflyer.com/<APP_ID>?pid=sdk_test&c=sdk_test
   

   The pid parameter represents the media source name. The c parameter represents the campaign name.
3. Send this URL to the device (e.g. via email or WhatsApp).
4. On the device, click on the URL.
   • If the app is listed in the app store, you are redirected to the app store. Don't download the app from the app store. Proceed to step 5.
   • If the app is not listed in the app store and is still in development, the screen shows a message that the app is not available in the app store. Simply proceed to step 5.
5. In Xcode Studio, open the debug terminal.
6. Connect the device to your computer using a USB cable.
7. From Xcode, Install the app on the device.
8. In the debug terminal, look for your app's itunes ID.

You should see the following:

A non-organic install should now appear in the Overview page of the application's dashboard.

The SDK contains two types of constants that represent in-app event related info.

• Event names - these constants come in the format AFEventEventName.
  For example AFEventPurchase, AFEventAddToCart.
• Event parameters - These constants come in the format AFEventParameterParameterName.
  For example AFEventParameterRevenue, AFEventParamaterContentId.

We strongly recommend using these constants for the following reasons:

• The standard naming allows AppsFlyer to automatically map events to SRNs such as Facebook, Google, Twitter, and Snapchat.
• Backward compatibility - if AppsFlyer decides to change the name of any event or event parameter, your implementation is backward compatible.

To use these two interfaces, import AppsFlyerTracker.h if using Objective-C, or AppsFlyerLib if using Swift:

#import AppsFlyerTracker.h

import AppsFlyerLib

Here is the list of recommended event names and structures.

You can send revenue with any in-app event. Use the af_revenue (AFEventParameterRevenue) event parameter to include revenue in the in-app event. You can populate it with any numeric value, positive or negative.

af_revenue is the only event parameter that AppsFlyer counts as real revenue on the raw data and dashboard. For more details click here.

When sending events with revenue, keep the following in mind:

• If you set currency code (see example below), it should be a 3 character ISO 4217 code (default currency is USD).
• You can set the currency code for all events by setting the following property:
  • Objective-C: [AppsFlyerTracker sharedTracker].currencyCode = @"ZZZ";,
  • Swift: AppsFlyerTracker.shared().currencyCode = "ZZZ"
  To learn about currency settings, display, and currency conversion, see our guide on revenue currency.
• The revenue value should not contain comma separators, currency sign, or text. A revenue event should be similar to 1234.56, for example.

Example: In-app event purchase event with revenue

[[AppsFlyerTracker sharedTracker] trackEvent: @"cancel_purchase" 
withValues:@{
	AFEventParamContentId:@"1234567",
	AFEventParamContentType : @"category_a",
	AFEventParamRevenue: @200,
	AFEventParamCurrency:@"USD"
}];

AppsFlyerTracker.shared().trackEvent("cancel_purchase", 
withValues: [
	AFEventParamContentId:"1234567",
	AFEventParamContentType : "category_a",
	AFEventParamRevenue: 200,
	AFEventParamCurrency:"USD"
]);

The purchase event above has $200 in revenue, appearing as revenue in the dashboard.

Recording negative revenue

There may be situations where you want to record negative revenue.

For example, a user receives a refund or cancels a subscription.

[[AppsFlyerTracker sharedTracker] trackEvent: @"cancel_purchase" 
withValues:@{
	AFEventParamContentId:@"1234567",
	AFEventParamContentType : @"category_a",
	AFEventParamRevenue: @-1.99,
	AFEventParamCurrency:@"USD"
}];

AppsFlyerTracker.shared().trackEvent("cancel_purchase", 
withValues: [
	AFEventParamContentId:"1234567",
	AFEventParamContentType : "category_a",
	AFEventParamRevenue: -1.99,
	AFEventParamCurrency:"USD"
]);

AppsFlyer’s SDK provides server verification for in-app purchases. To validate a purchase, call validateAndTrackInAppPurchase.

This call automatically generates an af_purchase in-app event, given that the purchase is validated.

This call has two callback blocks, one for ‘success’ and one for ‘failure’ (for any reason, including validation fail). On success, a dictionary is returned with the receipt validation data provided by Apple’s servers.

Usage example of validating a purchase:

- (void) validateAndTrackInAppPurchase:(NSString *) productIdentifier
price:(NSString *) price
currency:(NSString *) currency
transactionId:(NSString *) tranactionId
additionalParameters:(NSDictionary *) params
success:(void (^)(NSDictionary *response)) successBlock
failure:(void (^)(NSError *error, id reponse)) failedBlock;

[[AppsFlyerTracker sharedTracker] validateAndTrackInAppPurchase:@"ProductIdentifier" price:@"price"
    currency:@"USD"
    transactionId:@"transactionID"
    additionalParameters:@{@"test": @"val" , @"test1" : @"val 1"}
    success:^(NSDictionary *result){
      NSLog(@"Purchase succeeded And verified!!! response: %@", result[@"receipt"]);
    } failure:^(NSError *error, id response) {
      NSLog(@"response = %@", response);
      if([response isKindOfClass:[NSDictionary class]]) {
        if([response[@"status"] isEqualToString:@"in_app_arr_empty"]){
          // retry with 'SKReceiptRefreshRequest' because
          // Apple has returned an empty response
          // <YOUR CODE HERE>
        }

      } else {
        //handle other errors
        return;
      }
  }];

AppsFlyerTracker
      .shared()?
      .validateAndTrack(inAppPurchase: "productIdentifier",
                   price: "price",
                  currency: "currency",
               transactionId: "transactionId",
            additionalParameters: [:],
                  success: {
      guard let dictionary = $0 as? [String:Any] else { return }
      dump(dictionary)
    }, failure: { error, result in
      guard let emptyInApp = result as? [String:Any],
           let status = emptyInApp["status"] as? String,
             status == "in_app_arr_empty" else {
                // Try to handle other errors
                 return
               }
         
      // retry with 'SKReceiptRefreshRequest' because
      // Apple has returned an empty response
      // <YOUR CODE HERE>
    })

Validating in-app purchase automatically sends an in-app purchase event to AppsFlyer. See the following sample data that is passed in the event_value parameter:

{
   "some_parameter":"some_value", // from additional_event_values
   "af_currency":"USD", // from currency
   "af_content_id":"test_id", // from purchase
   "af_revenue":"10", // from revenue
   "af_quantity":"1", // from purchase
   "af_validated":true // flag that AF verified the purchase
}

• The name of an in-app event can be up to 45 characters long.
• For pricing and revenue, use only digits and decimals, e.g. 5 or 5.2.
• Pricing and revenue values can have up to 5 digits after the period, e.g. 5.12345
• AppsFlyer supports non-English characters with in-app events, or with any other SDK API, starting from iOS SDK version 4.8.1.

You can record in-app events by calling trackEvent with event name and value parameters. See In-App Events documentation for more details.

Below is a simple example of how to record a purchase event. For a comprehensive list of ready-made code snippets per vertical, see our guide for rich in-app events per verticals.

Example: In-app purchase event

[[AppsFlyerTracker sharedTracker] trackEvent:AFEventPurchase
   withValues: @{
    AFEventParamRevenue: @200,
    AFEventParamCurrency: @"USD",
    AFEventParamQuantity: @2,
    AFEventParamContentId: @"092",
    AFEventParamReceiptId: @"9277"
  }];

AppsFlyerTracker.shared().trackEvent(AFEventPurchase,
  withValues: [
     AFEventParamRevenue: "200",
     AFEventParamCurrency: "USD",
     AFEventParamQuantity: @2,
     AFEventParamContent: "shoes",
     AFEventParamContentId: @"092",
     AFEventParamReceiptId: @"9277"]);

If a user initiates an event when the internet connection is unavailable, Appsflyer is still able to record it. This is how it works:

1. SDK sends the events to AppsFlyer's servers and waits for a response.
2. If the SDK doesn’t receive a 200 response, the event is stored in the cache.
3. Once the next 200 response is received, the stored event is re-sent to the server.
4. If there are multiple events in the cache, they are sent to the server one promptly after another.

OneLink detects the device type upon click and redirects the user to the matching destination, e.g. Google Play, iOS app store, out-of-store markets, or web pages.

The OneLink redirections guide discusses implementing multi-platform attribution links (no SDK coding required). It's also the basis for deep linking.

Deep linking allows you to send users to specific activities and serve them with customized content. This is especially useful when running retargeting campaigns.

To set up deep linking with OneLink, a marketer with access to AppsFlyer dashboard and a developer with access to the app must work together.

See our guide on setting up deep linking with OneLink.

Deferred deep linking allows you to deep link new users and serve them with customized content upon first launch of the app. This is unlike regular deep linking where the app needs to already be installed on the user's device.

To set up deferred deep linking with OneLink, the developer also needs access to the AppsFlyer dashboard.

The setup for deferred deep linking is the same as deep linking. The only difference is that you need to implement additional logic in the app in order to deep link the users and serve them with customized content after they install and launch the app.

See our guide on deferred deep linking to learn more.

The SDK provides you with the conversion or engagement data following every install or deep linking event. You can use this data to customize content and the app's behavior programmatically.

See our guide on deep linking data to learn more.

To learn how to setup uninstall measurement, read here.

If you want to receive a confirmation that the tracking request was successfully received by AppsFlyer servers, implement the trackAppLaunchWithCompletionHandler handler. You can then apply logic to handle success or failure of tracking app launch.

Implementation example

[[AppsFlyerTracker sharedTracker] trackAppLaunchWithCompletionHandler:^(NSDictionary<NSString *,id> *dictionary, NSError *error) {
        if (error) {
            NSLog(@"%@", error);
            return;
        }
        if (dictionary) {
            NSLog(@"%@", dictionary);
            return;
        }
    }];

 AppsFlyerTracker.shared()?.trackAppLaunch(completionHandler: { (dictionnary, error) in
            if (error != nil){
                print(error ?? "")
                return
            } else {
                print(dictionnary ?? "")
                return
            }
        })

The setAdditionalData API is required to integrate on the SDK level with several external partner platforms, including Segment, Adobe and Urban Airship.
Use this API only if the integration article of the platform specifically states setAdditionalData API is needed.

setAdditionalData code example:

NSDictionary* CustomDataMap = [[NSDictionary alloc] initWithObjectsAndKeys:@"value_of_param_1", @"custom_param_1", nil];
[[AppsFlyerTracker sharedTracker] setAdditionalData:CustomDataMap];

let CustomDataMap: [AnyHashable: Any] = [
  "custom_param_1" : "value_of_param_1"
]
AppsFlyerTracker.shared().customData = CustomDataMap

By default, at least 5 seconds must pass between two app launches to count as two separate sessions (more about counting sessions).

Use the following API to set the minimum time between sessions:

[AppsFlyerTracker sharedTracker].minTimeBetweenSessions = <your_custom_time_in_seconds>;

AppsFlyerTracker.shared().minTimeBetweenSessions = <your_custom_time_in_seconds>

Setting a high value to the custom time between launches may badly impact APIs relying on sessions data, such as deep linking.

Unavailable in iOS.

Some 3rd party services such as email service providers wrap links in emails with their own click recording domains. Some even allow you to set your own click recording domains. If OneLink is wrapped in such domains, it might limit its functionality.

To overcome this issue you can use the setResolveDeepLinkURLs API. Use this API to get the OneLink from click domains that launch the app. Make sure to call this API before SDK initialization.

For example, you have three click domains that redirect to your OneLink which is https://mysubdomain.onelink.me/abCD. Use this API to get the OneLink that your click domains redirect toThis API method receives a list of domains that the SDK resolves.

[AppsFlyerTracker sharedTracker].resolveDeepLinkURLs = @[@"example.com",@"click.example.com"];

AppsFlyerTracker.shared().resolveDeepLinkURLs = ["example.com", "click.example.com"]

The code above allows you to use your click domain while preserving OneLink functionality. The click domains are responsible for launching the app. The API, in turn, gets the OneLink from these click domains and then you can use the data from this OneLink to deep link and customize user content.

With AppsFlyer, you can record push notifications as part of retargeting campaigns.

To enable this feature, call the handlePushNotificationData method inside the onCreate method of every activity that is launched after clicking the notification:

-(void) application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo {
	[[AppsFlyerTracker sharedTracker] handlePushNotification:userInfo];
  }

func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any]) {
	AppsFlyerTracker.shared().handlePushNotification(userInfo)
}

For more information on push notification measurement, read here.

Allowing your existing users to invite their friends and contacts as new users to your app, can be a key growth factor for your app. With AppsFlyer, you can attribute and record installs that originate from user invites within your app.

For details, see the User Invite Attribution article.

AppsFlyer's unique ID is created for every new install of an app. You can this ID for various purposes:

• Send server-to-server in-app events.
• Match it with user records in your backend systems.
• Map entries when merging data from pull and push API.

Use the following API to obtain AppsFlyer’s Unique ID:

NSString *appsflyerId = [AppsFlyerTracker sharedTracker].getAppsFlyerUID;

let appsflyerId = AppsFlyerTracker.shared().getAppsFlyerUID()

To set your Customer User ID:

[AppsFlyerTracker sharedTracker].customerUserID = @"my user id";

AppsFlyerTracker.shared().customerUserID = "my user id"

In iOS, the Customer User ID needs to be set with every app launch. We recommend setting the Customer User ID early in the app's flow, as it is only associated with events reported after its setup:

• If setCustomerUserId is called before calling trackAppLaunch, the Customer User ID appears in the raw data reports for installs and for events.
• If it is set after, Customer User ID is only associated with events that are recorded after setting the Customer User ID.

Getting Customer User ID:

To avoid setting the Customer User ID value again beyond the first launch, and to reduce calls to your server to get the customer user ID, you can check if its value is empty or not by using:

NSString *customerUserID = [AppsFlyerTracker sharedTracker].customerUserID;

let customerUserID = AppsFlyerTracker.shared().customerUserID

For more information about the Customer User ID, click here.

Delay SDK init for customerUserID

You can delay the SDK Initialization until the Customer User ID is set. This is useful if it's important for you that install and event data contain your customer user ID.

Implement the following code:

- (void)applicationDidBecomeActive:(UIApplication *)application {
    NSString *customUserId = [[NSUserDefaults standardUserDefaults] stringForKey:@"customerUserId"]; // Your custom logic of retrieving CUID
    if (customUserId != nil && ![customUserId  isEqual: @""]) {
        [AppsFlyerTracker sharedTracker].customerUserID = customUserId; // Set CUID in AppsFlyer SDK for this session
        [[AppsFlyerTracker sharedTracker] trackAppLaunch]; // Track App Launch
    }
}

func applicationDidBecomeActive(_ application: UIApplication) {
        let customUserId = UserDefaults.standard.string(forKey: "customUserId")  //  your logic to retrieve CUID
        if(customUserId != nil && customUserId != ""){
            AppsFlyerTracker.shared().customerUserID = customUserId // Set CUID in AppsFlyer SDK for this session
            AppsFlyerTracker.shared().trackAppLaunch() // Track App Launch
        }
    }

To learn more about delaying the SDK initialization until the Customer User ID is available, go here.

In some extreme cases, you might want to shut down all SDK tracking due to legal and privacy compliance. This can be achieved with the isStopTracking property. Once this property is set to true, the SDK stops functioning and no longer communicates with AppsFlyer servers.

There are several different scenarios for user opt-out. We highly recommend following the exact instructions for the scenario that is relevant for your app.

[AppsFlyerTracker sharedTracker].isStopTracking = true;

AppsFlyerTracker.shared().isStopTracking = true

In any event, the SDK can be reactivated by calling the same API, by passing false.

Use this API during the SDK Initialization to explicitly anonymize a user's install, events and sessions:

[AppsFlyerTracker sharedTracker].deviceTrackingDisabled = YES;

AppsFlyerTracker.shared().deviceTrackingDisabled = true

Tracking can be restarted by setting deviceTrackingDisabled to false.