Guía para desarrolladores sobre la integración con el SDK V6.X para iOS

Este SDK agrega y utiliza automáticamente los siguientes marcos nativos:

AdSupport.framework

Para recolectar el identificador de anunciante (IDFA) de los dispositivos, necesitarás este marco.
Sin el IDFA, no podrás atribuir instalaciones de Facebook Ads, Twitter, Google Ads y otras redes.

iAd.framework

Mide el rendimiento de Apple Search Ads en tu aplicación.

Marco de AdServices (V6.1.3+)

Mide el rendimiento de Apple Search Ads en tu aplicación.

Puedes deshabilitar estos marcos. Para eliminar completamente los marcos de tu aplicación, usa el SDK de modo estricto.

AppsFlyer usa la clave de desarrollador para identificar tu cuenta de manera exclusiva. La clave de desarrollador es obligatoria porque permite que el SDK envíe y recupere datos que pertenecen a tu cuenta de AppsFlyer de manera segura.

Para obtener la clave de SDK:

1. En AppsFlyer, ve a Configuración > Configuración de la aplicación. 
2. Copia tu clave de desarrollador, la necesitarás en el próximo paso.
   
   

El siguiente código es una implementación de ejemplo. Asegúrate de cambiar los marcadores de posición <AF_DEV_KEY> y <APPLE_APP_ID> según sea necesario.

#import <UIKit/UIKit.h>
#import <AppsFlyerLib/AppsFlyerLib.h>

@interface AppDelegate : UIResponder <UIApplicationDelegate, AppsFlyerLibDelegate>

@end

#import "AppDelegate.h"
#import <UserNotifications/UserNotifications.h>

@interface AppDelegate ()

@end

@implementation AppDelegate
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
        // Override point for customization after application launch.
        /** APPSFLYER INIT **/
        [AppsFlyerLib shared].appsFlyerDevKey = @"<AF_DEV_KEY>";
        [AppsFlyerLib shared].appleAppID = @"<APPLE_APP_ID>";
        [AppsFlyerLib shared].delegate = self;
        /* Set isDebug to true to see AppsFlyer debug logs */
        [AppsFlyerLib shared].isDebug = true;
  if (@available(iOS 10, *)) {
        UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
        center.delegate = self;
        [center requestAuthorizationWithOptions:(UNAuthorizationOptionSound | UNAuthorizationOptionAlert | UNAuthorizationOptionBadge) completionHandler:^(BOOL granted, NSError * _Nullable error) {
        }];
  } else {
        UIUserNotificationSettings *settings = [UIUserNotificationSettings settingsForTypes: UIUserNotificationTypeAlert | UIUserNotificationTypeSound | UIUserNotificationTypeBadge categories:nil];
        [[UIApplication sharedApplication] registerUserNotificationSettings:settings];
  }
  [[UIApplication sharedApplication] registerForRemoteNotifications];
  return YES;
}
- (void)applicationDidBecomeActive:(UIApplication *)application {
    [[AppsFlyerLib shared] start];
}
// Deep linking
// Open URI-scheme for iOS 9 and above
- (BOOL)application:(UIApplication *)application openURL:(NSURL *)url options:(NSDictionary *) options {
    [[AppsFlyerLib shared] handleOpenUrl:url options:options];
    return YES;
}
// Open URI-scheme for iOS 8 and below
- (BOOL)application:(UIApplication *)application openURL:(NSURL *)url sourceApplication:(NSString*)sourceApplication annotation:(id)annotation {
    [[AppsFlyerLib shared] handleOpenURL:url sourceApplication:sourceApplication withAnnotation:annotation];
    return YES;
}
// Open Universal Links
- (BOOL)application:(UIApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void (^)(NSArray * _Nullable))restorationHandler {
    [[AppsFlyerLib shared] continueUserActivity:userActivity restorationHandler:restorationHandler];
    return YES;
}
// Report Push Notification attribution data for re-engagements
- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
    [[AppsFlyerLib shared] handlePushNotification:userInfo];
}
// AppsFlyerLib implementation
//Handle Conversion Data (Deferred Deep Link)
-(void)onConversionDataSuccess:(NSDictionary*) installData {
    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 non-organic install. Media source: %@  Campaign: %@",sourceID,campaign);
    } else if([status isEqualToString:@"Organic"]) {
        NSLog(@"This is an organic install.");
    }
}
-(void)onConversionDataFail:(NSError *) error {
    NSLog(@"%@",error);
}
//Handle Direct Deep Link
- (void) onAppOpenAttribution:(NSDictionary*) attributionData {
    NSLog(@"%@",attributionData);
}
- (void) onAppOpenAttributionFailure:(NSError *)error {
    NSLog(@"%@",error);
}
@end
              

import UIKit
import AppsFlyerLib

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
    var window: UIWindow?
    let defaults = UserDefaults.standard
    //MARK: LifeCycle
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        AppsFlyerLib.shared().appsFlyerDevKey = "<AF_DEV_KEY>"
        AppsFlyerLib.shared().appleAppID = "<APPLE_APP_ID>"
        AppsFlyerLib.shared().delegate = self
        AppsFlyerLib.shared().isDebug = true
        // iOS 10 or later
        if #available(iOS 10, *) {
            UNUserNotificationCenter.current().requestAuthorization(options: [.badge, .alert, .sound]) { _, _ in }
            application.registerForRemoteNotifications()
        }
        // iOS 9 support - Given for reference. This demo app supports iOS 13 and above
        else {
            application.registerUserNotificationSettings(UIUserNotificationSettings(types: [.badge, .sound, .alert], categories: nil))
            application.registerForRemoteNotifications()
        }
        return true
    }
    func applicationDidBecomeActive(_ application: UIApplication) {
        // Start the SDK (start the IDFA timeout set above, for iOS 14 or later)
        AppsFlyerLib.shared().start()
    }
    // Open Univerasal Links
    // For Swift version < 4.2 replace function signature with the commented out code:
    // func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([Any]?) -> Void) -> Bool {
    func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any]) {
        print(" user info \(userInfo)")
        AppsFlyerLib.shared().handlePushNotification(userInfo)
    }
    // Open Deeplinks
    // Open URI-scheme for iOS 8 and below
    private func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([Any]?) -> Void) -> Bool {
        AppsFlyerLib.shared().continue(userActivity, restorationHandler: restorationHandler)
        return true
    }
    // Open URI-scheme for iOS 9 and above
    func application(_ application: UIApplication, open url: URL, sourceApplication: String?, annotation: Any) -> Bool {
        AppsFlyerLib.shared().handleOpen(url, sourceApplication: sourceApplication, withAnnotation: annotation)
        return true
    }
    // Report Push Notification attribution data for re-engagements
    func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
        AppsFlyerLib.shared().handleOpen(url, options: options)
        return true
    }
    func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
        AppsFlyerLib.shared().handlePushNotification(userInfo)
    }
    // Reports app open from deep link for iOS 10 or later
    func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
        AppsFlyerLib.shared().continue(userActivity, restorationHandler: nil)
        return true
    }
}
//MARK: AppsFlyerLibDelegate
extension AppDelegate: AppsFlyerLibDelegate{
    // Handle Organic/Non-organic installation
    func onConversionDataSuccess(_ installData: [AnyHashable: Any]) {
        print("onConversionDataSuccess data:")
        for (key, value) in installData {
            print(key, ":", value)
        }
        if let status = installData["af_status"] as? String {
            if (status == "Non-organic") {
                if let sourceID = installData["media_source"],
                    let campaign = installData["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 = installData["is_first_launch"] as? Bool,
                is_first_launch {
                print("First Launch")
            } else {
                print("Not First Launch")
            }
        }
    }
    func onConversionDataFail(_ error: Error) {
        print(error)
    }
    //Handle Deep Link
    func onAppOpenAttribution(_ attributionData: [AnyHashable : Any]) {
        //Handle Deep Link Data
        print("onAppOpenAttribution data:")
        for (key, value) in attributionData {
            print(key, ":",value)
        }
    }
    func onAppOpenAttributionFailure(_ error: Error) {
        print(error)
    }
}

Usa este método de inicialización solo si utilizas SceneDelegate.

Dado que no se llama a applicationDidBecomeActive cuando se utiliza SceneDelegate, usa la solución alternativa UIApplicationDidBecomeActiveNotification para inicializar el SDK, tal como se muestra en el siguiente ejemplo.

El siguiente código es una implementación de ejemplo. Asegúrate de cambiar los marcadores de posición <AF_DEV_KEY> y <APPLE_APP_ID> según sea necesario.

#import <AppsFlyerLib/AppsFlyerLib.h>

@interface AppDelegate : UIResponder <UIApplicationDelegate, AppsFlyerLibDelegate>

@end
            

#import "AppDelegate.h"
#import <AppsFlyerLib/AppsFlyerLib.h>
#import <UserNotifications/UserNotifications.h>
@interface AppDelegate ()
@end
@implementation AppDelegate
// Start the AppsFlyer SDK
- (void)sendLaunch:(UIApplication *)application {
        [[AppsFlyerLib shared] start];
    }
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
        // Override point for customization after application launch.
        /** APPSFLYER INIT **/
        [AppsFlyerLib shared].appsFlyerDevKey = @"<AF_DEV_KEY>";
        [AppsFlyerLib shared].appleAppID = @"<APPLE_APP_ID>";
        [AppsFlyerLib shared].delegate = self;
        /* Set isDebug to true to see AppsFlyer debug logs */
        [AppsFlyerLib shared].isDebug = true;
        // Use UIApplicationDidBecomeActiveNotification to start the SDK
        [[NSNotificationCenter defaultCenter] addObserver:self
            selector:@selector(sendLaunch:)
            name:UIApplicationDidBecomeActiveNotification
            object:nil];

  if (@available(iOS 10, *)) {
        UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
        center.delegate = self;
        [center requestAuthorizationWithOptions:(UNAuthorizationOptionSound | UNAuthorizationOptionAlert | UNAuthorizationOptionBadge) completionHandler:^(BOOL granted, NSError * _Nullable error) {
        }];
  } else {
        UIUserNotificationSettings *settings = [UIUserNotificationSettings settingsForTypes: UIUserNotificationTypeAlert | UIUserNotificationTypeSound | UIUserNotificationTypeBadge categories:nil];
        [[UIApplication sharedApplication] registerUserNotificationSettings:settings];
  }
  [[UIApplication sharedApplication] registerForRemoteNotifications];
  return YES;
}

// Report Push Notification attribution data for re-engagements
- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
    [[AppsFlyerLib shared] handlePushNotification:userInfo];
}

// AppsFlyerLib implementation
//Handle Conversion Data (Deferred Deep Link)
-(void)onConversionDataSuccess:(NSDictionary*) installData {
    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);
}

//Handle Direct Deep Link
- (void) onAppOpenAttribution:(NSDictionary*) attributionData {
    NSLog(@"%@",attributionData);
}

- (void) onAppOpenAttributionFailure:(NSError *)error {
    NSLog(@"%@",error);
}

// support for scene delegate
#pragma mark - UISceneSession lifecycle
- (UISceneConfiguration *)application:(UIApplication *)application configurationForConnectingSceneSession:(UISceneSession *)connectingSceneSession options:(UISceneConnectionOptions *)options API_AVAILABLE(ios(13)){
    // Called when a new scene session is being created.
    // Use this method to select a configuration to create the new scene with.
    return [[UISceneConfiguration alloc] initWithName:@"Default Configuration" sessionRole:connectingSceneSession.role];
}

- (void)application:(UIApplication *)application didDiscardSceneSessions:(NSSet *)sceneSessions  API_AVAILABLE(ios(13.0)){
    // Called when the user discards a scene session.
    // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
    // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
}
@end    
            

#import "SceneDelegate.h"

@interface SceneDelegate ()

@end

@implementation SceneDelegate 

- (void)scene:(UIScene *)scene openURLContexts:(NSSet<UIOpenURLContext *> *)URLContexts API_AVAILABLE(ios(13.0)){
    NSURL* url = [[URLContexts allObjects] objectAtIndex:0].URL;
    if(url){
        [[AppsFlyerLib shared] handleOpenUrl:url options:nil];
    }
}

- (void)scene:(UIScene *)scene continueUserActivity:(NSUserActivity *)userActivity  API_AVAILABLE(ios(13.0)){
    [[AppsFlyerLib shared]continueUserActivity:userActivity restorationHandler:nil];
}

- (void)scene:(UIScene *)scene willConnectToSession:(UISceneSession *)session options:(UISceneConnectionOptions *)connectionOptions {
    // Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`.
    // If using a storyboard, the `window` property will automatically be initialized and attached to the scene.
    // This delegate does not imply the connecting scene or session are new (see `application:configurationForConnectingSceneSession` instead).
    NSUserActivity *activity = [[connectionOptions userActivities] allObjects].firstObject;
    if (activity) {
        [self scene:scene continueUserActivity:activity];
    }
    [self scene:scene openURLContexts: [connectionOptions URLContexts]];
}


- (void)sceneDidDisconnect:(UIScene *)scene  API_AVAILABLE(ios(13.0)){
    // Called as the scene is being released by the system.
    // This occurs shortly after the scene enters the background, or when its session is discarded.
    // Release any resources associated with this scene that can be re-created the next time the scene connects.
    // The scene may re-connect later, as its session was not neccessarily discarded (see `application:didDiscardSceneSessions` instead).
}


- (void)sceneDidBecomeActive:(UIScene *)scene  API_AVAILABLE(ios(13.0)){
    // Called when the scene has moved from an inactive state to an active state.
    // Use this method to restart any tasks that were paused (or not yet started) when the scene was inactive.
}


- (void)sceneWillResignActive:(UIScene *)scene  API_AVAILABLE(ios(13.0)){
    // Called when the scene will move from an active state to an inactive state.
    // This may occur due to temporary interruptions (ex. an incoming phone call).
}


- (void)sceneWillEnterForeground:(UIScene *)scene  API_AVAILABLE(ios(13.0)){
    // Called as the scene transitions from the background to the foreground.
    // Use this method to undo the changes made on entering the background.
}


- (void)sceneDidEnterBackground:(UIScene *)scene  API_AVAILABLE(ios(13.0)){
    // Called as the scene transitions from the foreground to the background.
    // Use this method to save data, release shared resources, and store enough scene-specific state information
    // to restore the scene back to its current state.
}


@end
            

import UIKit
import AppsFlyerLib

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate, AppsFlyerLibDelegate {
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
         AppsFlyerLib.shared().appsFlyerDevKey = "<AF_DEV_KEY>"
         AppsFlyerLib.shared().appleAppID = "<APPLE_APP_ID>"
         AppsFlyerLib.shared().delegate = self
         AppsFlyerLib.shared().isDebug = true
                NotificationCenter.default.addObserver(self, selector: NSSelectorFromString("sendLaunch"), name: UIApplication.didBecomeActiveNotification, object: nil)
        return true
    }
    @objc func sendLaunch() {
       AppsFlyerLib.shared().start()
    }
    // MARK: UISceneSession Lifecycle
    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        // Called when a new scene session is being created.
        // Use this method to select a configuration to create the new scene with.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }
    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
        // Called when the user discards a scene session.
        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
    }
    //MARK: -GCD
       func onConversionDataSuccess(_ installData: [AnyHashable: Any]) {
          print("onConversionDataSuccess data:")
               for (key, value) in installData {
                   print(key, ":", value)
               }
               if let status = installData["af_status"] as? String {
                   if (status == "Non-organic") {
                       if let sourceID = installData["media_source"],
                           let campaign = installData["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 = installData["is_first_launch"] as? Bool,
                       is_first_launch {
                       print("First Launch")
                   } else {
                       print("Not First Launch")
                   }
               }
          }
       func onConversionDataFail(_ error: Error!) {
          if let err = error{
            print(err)
          }
        }
        func onAppOpenAttribution(_ attributionData: [AnyHashable : Any]!) {
          if let data = attributionData{
            print("\(data)")
          }
        }
        func onAppOpenAttributionFailure(_ error: Error!) {
          if let err = error{
            print(err)
          }
        }
}
            

import UIKit
import AppsFlyerLib

@available(iOS 13.0, *)
class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?
 
 func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        // Processing Universal Link from the killed state
        if let userActivity = connectionOptions.userActivities.first {
          self.scene(scene, continue: userActivity)
        }
     // Processing URI-scheme from the killed state
          self.scene(scene, openURLContexts: connectionOptions.urlContexts)
          
          guard let _ = (scene as? UIWindowScene) else { return }
    }
    
    func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
        AppsFlyerLib.shared().continue(userActivity, restorationHandler: nil)
    }
    
    func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
        if let url = URLContexts.first?.url {
            AppsFlyerLib.shared().handleOpen(url, options: nil) 
        }
    }


    func sceneDidDisconnect(_ scene: UIScene) {
        // Called as the scene is being released by the system.
        // This occurs shortly after the scene enters the background, or when its session is discarded.
        // Release any resources associated with this scene that can be re-created the next time the scene connects.
        // The scene may re-connect later, as its session was not neccessarily discarded (see `application:didDiscardSceneSessions` instead).
    }

    func sceneDidBecomeActive(_ scene: UIScene) {
        // Called when the scene has moved from an inactive state to an active state.
        // Use this method to restart any tasks that were paused (or not yet started) when the scene was inactive.
        
    }

    func sceneWillResignActive(_ scene: UIScene) {
        // Called when the scene will move from an active state to an inactive state.
        // This may occur due to temporary interruptions (ex. an incoming phone call).
    }

    func sceneWillEnterForeground(_ scene: UIScene) {
        // Called as the scene transitions from the background to the foreground.
        // Use this method to undo the changes made on entering the background.
    }

    func sceneDidEnterBackground(_ scene: UIScene) {
        // Called as the scene transitions from the foreground to the background.
        // Use this method to save data, release shared resources, and store enough scene-specific state information
        // to restore the scene back to its current state.
    }
}              
            

Fondo

A partir del iOS 14.5, la recolección del identificador de anunciante (IDFA) requiere el consentimiento del usuario. En la práctica, significa que el acceso al IDFA se regirá por el marco de la App Tracking Transparency (ATT). En dispositivos con iOS 14+, el SDK utiliza el marco de la ATT para obtener acceso al IDFA del dispositivo. 

Para informarte sobre la ATT, consulta Principios de la ATT.

Cuando la atribución se produce utilizando el IDFA, es importante que el IDFA se envíe con el evento del primer inicio. Por esta razón, el SDK proporciona la utilidad waitForATTUserAuthorization.

Descripción general de waitForATTUserAuthorization

waitForATTUserAuthorization te permite configurar cuánto tiempo debe diferir el SDK en el envío de datos a los servidores de AppsFlyer y esperar el estado del ATT.

Cuando un usuario inicia la aplicación, el estado de ATT es notDetermined. Durante el intervalo de tiempo de espera waitForATTUserAuthorization:

• El SDK pone en cola el evento de inicio y los eventos in-app consecutivos en la memoria, de forma similar a cómo se registran los eventos fuera de línea
• Si el usuario da su consentimiento al aviso de la ATT (recopilación del IDFA):
  • El SDK agrega el IDFA a los eventos almacenados en caché.
  • El SDK inicia y envía los eventos almacenados en caché con el IDFA (sin esperar a que finalice el tiempo de espera).
• Si el usuario rechaza el aviso de la ATT:
  • El SDK inicia y envía los eventos almacenados en caché sin el IDFA (sin esperar a que finalice el tiempo de espera).
• Si el tiempo de espera termina y el estado de la ATT permanece como notDetermined:
  • El SDK inicia y envía eventos almacenados en caché sin IDFA

Descripción general de la implementación del soporte de la ATT

Una implementación completa del soporte de ATT consiste en:

• Configurar waitForATTUserAuthorization en la fase de inicialización de la aplicación, por lo general en didFinishLaunchingWithOptions.
• Llama a requestTrackingAuthorization, siempre que muestres el aviso de la ATT.

Para configurar la compatibilidad con la ATT en el SDK para iOS:

1. En didFinishLaunchingWithOptions, configura waitForATTUserAuthorization:
   • Configura el temporizador waitForATTUserAuthorization para que tus usuarios tengan tiempo suficiente para ver e interactuar con el aviso de la ATT. Algunos ejemplos:
     • Si aparece el aviso de la ATT en el inicio de la aplicación, un intervalo de 60 segundos debería ser suficiente.
     • Si aparece el aviso de la ATT después de un tutorial que tarda aproximadamente 2 minutos en completarse, un intervalo de 120 segundos debería ser suficiente.
   Objective-C Swift

   - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
       [[AppsFlyerLib shared] setAppsFlyerDevKey:@"<AF_DEV_KEY>"];
       [[AppsFlyerLib shared] setAppleAppID:@"<APPLE_APP_ID>"];
       ...
       [[AppsFlyerLib shared] waitForATTUserAuthorizationWithTimeoutInterval:60];
       ...
       return YES;
   }

   class AppDelegate: UIResponder, UIApplicationDelegate, AppsFlyerLibDelegate {
           func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        AppsFlyerLib.shared().appsFlyerDevKey = "<AF_DEV_KEY>"
        AppsFlyerLib.shared().appleAppID = "<APPLE_APP_ID>"
        ...
        AppsFlyerLib.shared().waitForATTUserAuthorization(timeoutInterval: 60)
        ...
     }
      ...
   }

2. En applicationDidBecomeActive, llama a start como se describe en Inicializar el SDK.
3. En el código de tu aplicación, llama a requestTrackingAuthorization para mostrar el aviso de la ATT. Por ejemplo, si quieres presentarle al usuario el diálogo de consentimiento cuando una determinada vista termine de cargarse:
   Objective-C Swift

   - (void)viewDidLoad {
       [super viewDidLoad];
       
       if #available(iOS 14, *) {
         [ATTrackingManager requestTrackingAuthorizationWithCompletionHandler:^(ATTrackingManagerAuthorizationStatus status) {
           NSLog(@"Status: %lu", (unsigned long)status);
         }];
       }
   }

   override func viewDidLoad() {
     super.viewDidLoad()
     
     if #available(iOS 14, *) {
       ATTrackingManager.requestTrackingAuthorization { (status) in }
     }
   }

   Esta llamada activa el aviso de la ATT.
   
   

consideraciones

• Si se llama a requestTrackingAuthorization sin configurar waitForATTUserAuthorization, los inicios y eventos se enviarán sin IDFA para dispositivos con iOS 14+.
• Si el usuario mueve la aplicación al fondo durante el tiempo de espera:
  • El temporizador se pone en pausa hasta que la aplicación vuelva al primer plano.
  • Los eventos se almacenan en caché en la memoria.
• Si el usuario cierra o se finaliza la aplicación durante el tiempo de espera:
  • El temporizador se reinicia en el próximo inicio de la aplicación.
  • Los eventos almacenados en caché se pierden.

1. Selecciona el archivo Info.plist del proyecto en el navegador de proyectos de Xcode.
2. Agregar una entrada a la lista: presiona + junto a Lista de propiedades de información.

   

3. Desplázate hacia abajo y selecciona Privacidad: Descripción de seguimiento de uso.
4. Agrega como valor el texto que quieras presentarle al usuario al solicitar permiso para recopilar el IDFA.

   

SKAdNetwork es una clase que iOS utiliza y que valida las instalaciones de aplicaciones impulsadas por los anunciantes. El proceso de validación de la instalación de la aplicación involucra a la aplicación fuente y a la aplicación anunciada. 

Una aplicación fuente es una aplicación que participa en campañas publicitarias mostrando los anuncios firmados por una red de publicidad. La configuración de tu aplicación para mostrar anuncios no está dentro del alcance del SDK de AppsFlyer. Para configurarla, sigue las instrucciones de Apple.

Para la aplicación anunciada (la aplicación con el SDK de AppsFlyer), la Solución SKAdNetwork de AppsFlyer utiliza SKAdNetwork para proporcionar el postback de atribución mientras AppsFlyer recopila, traduce y agrega los datos, manteniendo la privacidad del usuario. Al iniciar la aplicación por primera vez, la plataforma AppsFlyer, utilizando la configuración establecida por el marketer, instruye al SDK sobre cómo establecer el valor de conversión de SKAdNetwork.

Para usar la Solución SKAdNetwork:

• El desarrollador no hace nada.
• El SDK de AppsFlyer llama automáticamente a las API necesarias de SKAdNetwork, es decir, registerAppForAdNetworkAttribution() y updateConversionValue(). El desarrollador no debe llamarlas. 
• No permitas que otros SDK llamen a las API de SKAdNet. Si esto ocurre, es posible que se retrase el envío del postback por parte de iOS a AppsFlyer y que cambie el valor de conversión que usamos para calcular las métricas de calidad del usuario del panel de control de SKAdNetwork. 
• El marketer debe configurar la medición de SKAdNetwork en AppsFlyer. 

No se requiere ninguna acción o proceso de registro en la tienda de aplicaciones por parte del desarrollador o del marketer. 

Para desactivar la atribución de SKAdNetwork, usa la API disableSKAdNetwork.

Antes de empezar a probar las instalaciones:

• Asegúrate de que tu dispositivo no tenga la aplicación instalada.
• Registra el dispositivo en el que realizarás la prueba.

Las instalaciones orgánicas son instalaciones sin atribuir que, por lo general, son instalaciones directas desde tiendas de aplicaciones.

Para simular una instalación orgánica

1. Asegúrate de tener un dispositivo móvil conectado a tu computadora.
2. En Xcode, abre la terminal de depuración.
3. Desde Xcode Studio, instala la aplicación en el dispositivo o emulador.
4. Espera a que se inicie la aplicación.
5. En la terminal de depuración, busca el nombre del paquete de la aplicación.

Deberías ver lo siguiente:

Enviar start() en el registro indica que el SDK informa una instalación. Estos datos provienen del método onConversionDataSuccess en el delegado de aplicación. Más adelante en esta guía, se explica cómo obtener datos de conversión.

Nota: A partir del SDK V5, onConversionDataSuccess es el nombre del método para obtener datos de conversión. Si estás utilizando una versión del SDK inferior a 5.0.0, el nombre del método es onConversionDataReceived. Recomendamos que actualices al SDK 5.0.0. Para aprender más, haz clic aquí.

Ahora debería aparecer una instalación orgánica en la página de Información general del panel de control de la aplicación.

Si no ves ninguna instalación en el panel de control de la aplicación, consulta la guía de resolución de problemas del SDK.

Una instalación no orgánica es una instalación atribuida que, por lo general, tiene lugar después de una instancia de captación (engagement) de un anuncio. Para simular una instalación no orgánica, puedes usar enlaces de atribución.

Para hacer esto:

1. Averigua cuál es el nombre de ID de iTunes de tu aplicación, por ejemplo id123456789.
2. En la siguiente URL, reemplaza <APP_ID> por el ID de itunes de tu aplicación:
   

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

   Por ejemplo:

   https://app.appsflyer.com/id0123456789?pid=sdk_test&c=sdk_test
   

   El parámetro pid representa el nombre de la fuente de medios. El parámetro c representa el nombre de la campaña.
3. Envía esta URL al dispositivo (p. ej., por correo electrónico o WhatsApp).
4. En el dispositivo, haz clic en la URL.
   • Si la aplicación figura en la tienda de aplicaciones, se te redirigirá a la tienda de aplicaciones. No descargues la aplicación desde la tienda de aplicaciones. Sigue con el paso 5.
   • Si la aplicación no figura en la tienda de aplicaciones y aún se encuentra en desarrollo, la pantalla muestra un mensaje de que la aplicación no se encuentra disponible en la tienda de aplicaciones. Simplemente sigue con el paso 5.
5. En Xcode Studio, abre la terminal de depuración.
6. Conecta el dispositivo a tu computadora con un cable USB.
7. Desde Xcode, instala la aplicación en el dispositivo.
8. En la terminal de depuración, busca el ID de iTunes de tu aplicación.

Deberías ver lo siguiente:

Ahora debería aparecer una instalación no orgánica en la página de Información general del panel de control de la aplicación.

El SDK contiene dos tipos de constantes que representan información relacionada con los IAE.

• Nombres de eventos: estas constantes tienen el formato AFEventEventName.
  Por ejemplo AFEventPurchase, AFEventAddToCart.
• Parámetros de eventos: estas constantes tienen el formato AFEventParameterParameterName.
  Por ejemplo AFEventParameterRevenue, AFEventParamaterContentId.

Es muy recomendable que uses estas constantes por los siguientes motivos:

• La nomenclatura estándar permite que AppsFlyer asigne automáticamente eventos a redes de autorreporte (SRN) como Facebook, Google, Twitter y Snapchat.
• Compatibilidad con versiones anteriores: si AppsFlyer decide cambiar el nombre de cualquier evento o parámetro de evento, tu implementación será compatible con las versiones anteriores.

Para usar estas dos interfaces, importa AppsFlyerLib.h si usas Objective-C, o AppsFlyerLib si usas Swift:

#import AppsFlyerLib.h

import AppsFlyerLib

Aquí encontrarás la lista de estructuras y nombres de eventos recomendados.

Puedes enviar los ingresos con cualquier evento in-app. Usa el parámetro del evento af_revenue (AFEventParameterRevenue) para incluir los ingresos en el evento in-app. Puedes rellenarlo con cualquier valor numérico, positivo o negativo.

af_revenue es el único parámetro de evento que AppsFlyer cuenta como ingreso real en los raw data (datos sin procesar) y en el panel de control. Para más detalles, haz clic aquí.

Cuando envíes eventos con ingresos, ten en cuenta lo siguiente:

• Si estableces el código de divisa (mira el ejemplo a continuación), debe ser un código ISO 4217 de 3 caracteres (la opción predeterminada es USD).
• Puedes establecer el código de divisa para todos los eventos configurando la siguiente propiedad:
  • Objective-C: [AppsFlyerLib shared].currencyCode = @"ZZZ";,
  • Swift: AppsFlyerLib.shared().currencyCode = "ZZZ"
  Para obtener información sobre la configuración, visualización y conversión de divisas, consulta nuestra guía sobre las divisas de los ingresos..
• El valor de los ingresos no debe contener comas separadoras, signos de divisas ni texto. Por ejemplo, un evento generador de ingresos debería ser similar a 1234.56.

Ejemplo: evento de compra in-app con ingresos

[[AppsFlyerLib shared] logEvent: @"purchase" 
withValues:@{
	AFEventParamContentId:@"1234567",
	AFEventParamContentType : @"category_a",
	AFEventParamRevenue: @200,
	AFEventParamCurrency:@"USD"
}];

AppsFlyerLib.shared().logEvent("purchase", 
withValues: [
	AFEventParamContentId:"1234567",
	AFEventParamContentType : "category_a",
	AFEventParamRevenue: 200,
	AFEventParamCurrency:"USD"
]);

El evento de compra anterior contiene un ingreso de $200 que aparece como ingreso en el panel de control.

Registro de ingresos negativos

Puede haber situaciones en las que quieras registrar ingresos negativos.

Ejemplo: un usuario recibe un reembolso o cancela una suscripción.

[[AppsFlyerLib shared] logEvent: @"cancel_purchase" 
withValues:@{
	AFEventParamContentId:@"1234567",
	AFEventParamContentType : @"category_a",
	AFEventParamRevenue: @-1.99,
	AFEventParamCurrency:@"USD"
}];

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

El SDK de AppsFlyer proporciona verificación de servidor para las compras in-app. Para validar una compra, llama a validateAndLogInAppPurchase.

Esta llamada genera automáticamente un evento in-app de tipo af_purchase, dado que la compra está validada.

Esta llamada tiene dos bloques de callback: uno para "éxito" y otro para "falla" (por cualquier motivo, incluyendo falla de validación). Tras un éxito, se devuelve un diccionario con los datos de validación de compra (receipt validation).  

Ejemplo de uso de la validación de compra:

- (void) validateAndLogInAppPurchase:(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;

[[AppsFlyerLib shared] validateAndLogInAppPurchase:@"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;
      }
  }];

AppsFlyerLib
      .shared()?
      .validateAndLogInAppPurchase ("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>
    })

Al probar la validación de compra en el entorno Sandbox, agrega el siguiente código:

[AppsFlyerLib shared].useReceiptValidationSandbox = YES;

AppsFlyerLib.shared().useReceiptValidationSandbox = true

Ten en cuenta que este código debe eliminarse de tus compilaciones de producción.

Al validar una compra in-app, se envía automáticamente un evento de compra in-app a AppsFlyer. Mira a continuación una muestra de los datos que se pasan en el parámetro event_value:

{
   "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
}

• Nombre del evento: hasta 45 caracteres
• Valor del evento: no debe superar los 1000 caracteres; si es más largo, es probable que lo trunquemos.
• Precios e ingresos: usa solo dígitos y decimales, p. ej. 5 o 5.2.
• Los valores de precios e ingresos pueden tener hasta 5 dígitos después del punto, p. ej., 5.12345.
• Se admiten caracteres no ingleses, en eventos in-app, otras API de SDK, a partir de Android SDK V4.8.1.

Puedes registrar eventos in-app al llamar a trackEvent con el nombre de evento y los parámetros de valor. Consulta la documentación sobre eventos in-app para conocer más detalles.

A continuación, te mostramos un ejemplo de cómo registrar un evento de compra. Para ver una lista completa de fragmentos de código listos por segmento vertical, consulta nuestra guía de eventos in-app enriquecidos por segmento vertical.

Ejemplo: evento de compra in-app

[[AppsFlyerLib shared] logEvent:AFEventPurchase
   withValues: @{
    AFEventParamRevenue: @200,
    AFEventParamCurrency: @"USD",
    AFEventParamQuantity: @2,
    AFEventParamContentId: @"092",
    AFEventParamReceiptId: @"9277"
  }];

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

Si un usuario inicia un evento cuando no tiene conexión a Internet, AppsFlyer igualmente podrá registrarlo. Así es como funciona:

1. El SDK envía los eventos a los servidores de AppsFlyer y espera una respuesta.
2. Si el SDK no recibe una respuesta 200, el evento se almacena en el caché.
3. Una vez recibida la respuesta 200, el evento almacenado se vuelve a enviar al servidor.
4. Si hay múltiples eventos en el caché, se envían al servidor uno tras otro.

• Un evento in-app registrado con éxito.
• Se produjo un error en el registro de un evento in-app.

 [[AppsFlyerLib shared] logEventWithEventName:AFEventPurchase
        eventValues: @{
          AFEventParamRevenue: @200,
          AFEventParamCurrency: @"USD",
          AFEventParamQuantity: @2,
          AFEventParamContentId: @"092",
          AFEventParamReceiptId: @"9277"
        }
        completionHandler:^(NSDictionary<NSString *,id> * _Nullable dictionary, NSError * _Nullable error){
            if(dictionary != nil) {
                NSLog(@"In app callback success:");
                for(id key in dictionary){
                    NSLog(@"Callback response: key=%@ value=%@", key, [dictionary objectForKey:key]);
                }
            }
            if(error != nil) {
                NSLog(@"In app callback error:", error);
            }
    }];
    

AppsFlyerLib.shared().logEvent(name: "In app event name", values: ["id": 12345, "name": "John doe"], completionHandler: { (response: [String : Any]?, error: Error?) in
             if let response = response {
               print("In app event callback Success: ", response)
             }
             if let error = error {
               print("In app event callback ERROR:", error)
             }
           })
        }
            

En caso de que se produzca un error durante la grabación del evento in-app, se proporciona un código de error y una descripción de la cadena, como se indica en la tabla que figura a continuación.

OneLink detecta el tipo de dispositivo al hacer clic y redirige al usuario al destino correspondiente, p. ej., Google Play, App Store de iOS, mercados fuera de la tienda o páginas web.

En la guía sobre redireccionamiento de OneLink, analizamos la implementación de enlaces de atribución multiplataforma (sin necesidad de codificación del SDK). También es la base para los enlaces profundos.

Los enlaces profundos te permiten enviar a usuarios hacia actividades específicas y ofrecerles contenido personalizado. Esto resulta particularmente útil cuando se ejecutan campañas de retargeting.

Para configurar enlaces profundos con OneLink, un marketer con acceso al panel de control de AppsFlyer y un desarrollador con acceso a la aplicación deben trabajar juntos.

Consulta nuestra guía sobre configuración de enlaces profundos con OneLink.

Los enlaces profundos diferidos te permiten establecer enlaces profundos con usuarios nuevos y ofrecerles contenido personalizado después de que inician la aplicación por primera vez. Esto es diferente con respecto a los enlaces profundos normales, en los que la aplicación ya debe estar instalada en el dispositivo del usuario.

Para configurar enlaces profundos diferidos con OneLink, el desarrollador también necesita acceso al panel de control de AppsFlyer.

La configuración de enlaces profundos diferidos es prácticamente igual a la de los enlaces profundos regulares. La única diferencia es que necesitas implementar una lógica adicional en la aplicación a fin de establecer enlaces profundos con los usuarios y ofrecerles contenido personalizado después de que instalen e inicien la aplicación.

Consulta nuestra guía sobre enlaces profundos diferidos para aprender más.

El SDK te proporciona los datos de conversión o captación (engagement) después de cada instalación o evento de enlaces profundos. Puedes usar estos datos para personalizar el contenido y el comportamiento de la aplicación de manera programática.

Para obtener datos de enlaces profundos cuando se usa el enlace profundo directo y se abre la aplicación, implementa el método onAppOpenAttribution.

Para obtener datos de re-engagement de enlaces profundos manualmente en cualquier momento, implementa el método performOnAppAttribution. Esto permite el acceso a los datos de re-engagement sin registrar un re-engagement nuevo.

Consulta nuestra guía sobre datos de enlaces profundos para aprender más.

El método addPushNotificationDeepLinkPath proporciona a los propietarios de aplicaciones una interfaz flexible para configurar cómo se extraen los enlaces profundos de las cargas útiles de notificaciones push.

De forma predeterminada, el SDK busca un valor de enlace profundo en la clave af de la carga útil JSON de una notificación push. Muchos proveedores de push usan esquemas propios de JSON que el SDK no puede resolver sin una configuración adicional.

addPushNotificationDeepLinkPath permite configurar qué clave de la carga útil JSON de la notificación push debe utilizar el SDK para el valor de enlace profundo.

Usa este método si estás integrando tu aplicación con proveedores push que no usan el esquema JSON de notificación push predeterminado que el SDK espera.

Al llamar a addPushNotificationDeepLinkPath, el SDK verifica lo siguiente:

• La clave requerida existe en la carga útil.
• La clave contiene una URL válida de OneLink.

Configuración básica

Considera la siguiente llamada a addPushNotificationDeepLinkPath

[AppsFlyerLib shared] addPushNotificationDeepLinkPath:@[@"deeply", @"nested", @"deep_link"]]

AppsFlyerLib.shared().addPushNotificationDeepLinkPath(["deeply", "nested", "deep_link"])

y estas situaciones:

Situación 1

Tu aplicación se invoca a través de notificación push. Contiene una carga útil estructurada de la siguiente manera.

{
    ...
    "deeply": {
        "nested": {
            "deep_link": "https://yourdeeplink2.onelink.me"
        }
    }
    ...
}

En este escenario, el SDK extrae el valor de deep_link y procede con el flujo de enlaces profundos.

Situación 2

Tu aplicación se invoca a través de notificación push. Contiene una carga útil estructurada de la siguiente manera.

{
    ...
    "deeply": {
        "nested": {
            "banana": "https://yourdeeplink2.onelink.me"
        }
    },
    ...
}

En este escenario, cuando la llamada se ejecuta, el SDK no puede encontrar la clave deep_link en la carga útil. Por lo tanto, no pasa nada.

Situación 3

Tu aplicación se invoca a través de notificación push. Contiene una carga útil estructurada de la siguiente manera.

{
    ...
    "deeply": {
        "nested": {
            "deep_link": "Corrupted url or regular string"
        }
    },
    ...
}

En este escenario, aunque el SDK encuentra la clave deep_link, su valor de enlace profundo no es válido. Por lo tanto, cuando la llamada anterior se ejecuta, no ocurre nada.

Configuración avanzada

Para configurar varias estructuras de carga útil posibles, llama a addPushNotificationDeepLinkPath varias veces:

• Se utiliza la primera llamada que produce un valor de enlace profundo válido
• Se ignoran las otras llamadas

Si ninguna de las estructuras de la carga útil coincide o no se encuentra una URL de OneLink válida en la carga útil, no ocurre nada.

Por ejemplo, considera la siguiente carga útil

{
    ...
    "deeply": {
        "nested": {
            “deep_link”: “https://yourdeeplink2.onelink.me”
        }
    },
    “this”: {
        “is”: {
            "banana": "phone"
        }
    }
    ...
}

y las siguientes llamadas a addPushNotificationDeepLinkPath.

// this.is.deep_link key isn’t found - nothing happens
[AppsFlyerLib shared] addPushNotificationDeepLinkPath:@[@"this", @"is", @"deep_link"]]

// this.is.banana key found, but contains invalid OneLink URL - nothing happens
[AppsFlyerLib shared] addPushNotificationDeepLinkPath:@[@"this", @"is", @"banana"]]

// deeply.nested.deep_link key found and contains valid OneLink URL - proceed deep linking flow
[AppsFlyerLib shared] addPushNotificationDeepLinkPath:@[@"deeply", @"nested", @"deep_link"]]

// this.is.deep_link key isn’t found - nothing happens
AppsFlyerLib.shared().addPushNotificationDeepLinkPath(["this", "is", "deep_link"]);

// this.is.banana key found, but contains invalid OneLink URL - nothing happens
AppsFlyerLib.shared().addPushNotificationDeepLinkPath(["this", "is", "banana"])

// deeply.nested.deep_link key found and contains valid OneLink URL - proceed deep linking flow
AppsFlyerLib.shared().addPushNotificationDeepLinkPath(["deeply", "nested", "deep_link"])

Puedes acceder a los datos de atribución de los usuarios en tiempo real para cada instalación nueva, directamente desde el SDK.

Al hacer esto, puedes ofrecerles a los usuarios contenido personalizado o enviarlos a actividades específicas dentro de la aplicación (consulta la sección sobre enlaces profundos diferidos de este artículo), lo que puede optimizar en gran medida su interacción (engagement) con tu aplicación.

Para obtener los datos de conversión del SDK para iOS, implementa los siguientes métodos:

- (void) onAppOpenAttribution:(NSDictionary*) attributionData {
    NSLog(@"onAppOpenAttribution");
    for(id key in attributionData){
        NSLog(@"onAppOpenAttribution: key=%@ value=%@", key, [attributionData objectForKey:key]);
    }
}

- (void)onAppOpenAttributionFailure:(NSError *)error {
     NSLog(@"%@", [error description]);
}

-(void)onConversionDataSuccess:(NSDictionary*) installData {
        
    BOOL first_launch_flag = [[installData objectForKey:@"is_first_launch"] boolValue];
    NSString *status = [installData objectForKey:@"af_status"];
    
    if(first_launch_flag) {
        if ([status isEqualToString:@"Non-organic"]){
            NSString *sourceID = [installData objectForKey:@"media_source"];
            NSString *campaign = [installData objectForKey:@"campaign"];
            NSLog(@"This is a non-organic install. Media source: %@ Campaign: %@", sourceID, campaign);
        } else {
            NSLog(@"This is an organic install");
        }
    } else {
        NSLog(@"Not first launch");
    }
}

-(void)onConversionDataFail:(NSError *) error {
    NSLog(@"%@", [error description]);
}

class AppDelegate: UIResponder, UIApplicationDelegate, AppsFlyerLibDelegate{
 
  func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
    AppsFlyerLib.shared().appsFlyerDevKey = "MY_DEV_KEY"
    AppsFlyerLib.shared().appleAppID = "123456789"
    AppsFlyerLib.shared().delegate = self
    //AppsFlyerLib.shared().isDebug = true
    //AppsFlyerLib.shared().appInviteOneLinkID = "ONELINK_ID";
    return true
  }
  
  func applicationDidBecomeActive(_ application: UIApplication) {
    AppsFlyerLib.shared().start()
  }
  
    func onConversionDataSuccess(_ installData: [AnyHashable: Any]) {
        
        guard let first_launch_flag = installData["is_first_launch"] as? Int else {
            return
        }
        
        guard let status = installData["af_status"] as? String else {
            return
        }
        
        if(first_launch_flag == 1) {
            if(status == "Non-organic") {
                if let media_source = installData["media_source"] , let campaign = installData["campaign"]{
                    print("This is a Non-Organic install. Media source: \(media_source) Campaign: \(campaign)")
                }
            } else {
                print("This is an organic install.")
            }
        } else {
            print("Not First Launch")
        }
    }
  
  func onConversionDataFail(_ error: Error!) {
    if let err = error{
      print(err)
    }
  }
  
  func onAppOpenAttribution(_ attributionData: [AnyHashable : Any]!) {
    if let data = attributionData{
      print("\(data)")
    }
  }
  
  func onAppOpenAttributionFailure(_ error: Error!) {
    if let err = error{
      print(err)
    }
  }

Los dos métodos más importantes son lo siguientes:

• onInstallConversionData: proporciona datos de conversión para instalaciones nuevas.
  

  Nota: A partir del SDK V5, onConversionDataSuccess es el nombre del método para obtener datos de conversión. Si estás utilizando una versión del SDK inferior a 5.0.0, el nombre del método es onConversionDataReceived. Recomendamos que actualices al SDK 5.0.0. Para aprender más, haz clic aquí.

• onAppOpenAttribution: proporciona datos de conversión de retargeting cuando se inicia una aplicación existente, ya sea manualmente o a través de enlaces profundos.

Por más información sobre los datos de conversión, consulta nuestra guía sobre escenarios de datos de conversión.

Para saber cómo configurar la medición de desinstalaciones, lee aquí.

Si quieres recibir una confirmación de que el SDK comenzó satisfactoriamente y notificó a los servidores de AppsFlyer, implementa el controlador startWithCompletionHandler. A continuación, puedes aplicar una lógica para manejar el éxito o el fracaso del inicio del SDK.

Ejemplo de implementación

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

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

En caso de que se produzca un error durante la escucha de la solicitud, se proporciona un código de error y una descripción de la cadena, como se indica en la tabla que figura a continuación.

La API setAdditionalData es necesaria para integrarse a nivel del SDK con varias plataformas de partners externos, como Segment, Adobe y Urban Airship.
Usa esta API solo si el artículo de integración de la plataforma indica específicamente que se necesita la API setAdditionalData.

Ejemplo de código de setAdditionalData:

NSDictionary* customDataMap = [[NSDictionary alloc] initWithObjectsAndKeys:@"value_of_param_1", @"custom_param_1", nil];
[[AppsFlyerLib shared] setAdditionalData:customDataMap];

let customDataMap: [AnyHashable: Any] = [
  "custom_param_1" : "value_of_param_1"
]
AppsFlyerLib.shared().customData = customDataMap

Los propietarios de aplicaciones que usan enlaces universales para deep linking (sin OneLink) y tienen un dominio asociado con su aplicación pueden atribuir sesiones iniciadas a través de este dominio mediante el método appendParametersToDeepLinkingURL.

Por ejemplo, un usuario busca en Google y hace clic en tu dominio, www.ejemplo.com:

• Si el usuario no tiene la aplicación instalada, será direccionado al sitio web (www.ejemplo.com).
• Si el usuario tiene la aplicación instalada en su dispositivo, tendrá enlaces profundos a la aplicación asociada con www.ejemplo.com. La sesión se atribuye a la fuente de medios (parámetro pid) especificada en appendParametersToDeepLinkingURL.

Consulta la referencia del SDK del iOS para obtener más información.

Nota: Los Smart Banners ayudan a los propietarios de aplicaciones a convertir a los visitantes del sitio web en usuarios de la aplicación.

De manera predeterminada, deben pasar por lo menos 5 segundos entre 2 instancias de inicio de la aplicación para que cuenten como 2 sesiones separadas (más información acerca del recuento de sesiones).

Usa la siguiente API para establecer el tiempo mínimo entre sesiones:

[AppsFlyerLib shared].minTimeBetweenSessions = <your_custom_time_in_seconds>;

AppsFlyerLib.shared().minTimeBetweenSessions = <your_custom_time_in_seconds>

Establecer un valor alto para el tiempo personalizado entre inicios podría afectar negativamente las API que dependen de los datos de sesión, como los enlaces profundos.

No disponible en iOS. 

Algunos servicios de terceros, como los proveedores de servicio de correo electrónico encapsulan enlaces en los mensajes de correo electrónico con sus propios dominios de registro de clics. Algunos incluso te permiten configurar tus propios dominios de registro de clics. Si OneLink está encapsulado en tales dominios, su funcionalidad podría verse limitada.

Para resolver este problema, puedes usar la API setResolveDeepLinkURLs. Usa esta API para obtener el OneLink de los dominios de clics que inician la aplicación.  Asegúrate de llamar a esta API antes de la inicialización del SDK.

Por ejemplo, tienes tres dominios de clics que redirigen a tu OneLink, que es https://mysubdomain.onelink.me/abCD. Usa esta API para obtener el OneLink al cual redirigen tus dominios de clics.  Este método de API recibe una lista de dominios que el SDK resolverá.

[AppsFlyerLib shared].resolveDeepLinkURLs = @[@"example.com",@"click.example.com"];

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

El código anterior te permite usar tu dominio de clics y, al mismo tiempo, preservar la funcionalidad de OneLink. Los dominios de clics son responsables de iniciar la aplicación. A su vez, la API obtiene el OneLink de estos dominios de clics y, a continuación, tú puedes usar los datos de este OneLink para establecer enlaces profundos y personalizar el contenido de los usuarios.

Con AppsFlyer, puedes medir notificaciones push como parte de las campañas de retargeting.

Para habilitar esta función, llama al método handlePushNotificationData dentro de AppDelegate.m.

-(void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
[[AppsFlyerLib shared] handlePushNotification:userInfo];
}

func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
    AppsFlyerLib.shared().handlePushNotification(userInfo)
}

Para obtener más información sobre la medición de notificaciones push, lee aquí.

Permitir que tus usuarios actuales inviten a sus amigos y contactos como nuevos usuarios de tu aplicación puede ser un factor de crecimiento clave para tu aplicación. Con AppsFlyer, puedes atribuir y registrar instalaciones que se originen a partir de invitaciones de usuarios dentro de tu aplicación.

Para conocer más detalles, consulta el artículo sobre atribución de invitaciones de usuarios.

¡Nota! La promoción cruzada por identificador de proveedor (IDFV) requiere el SDK 6.0.2+. El IDFV se recoge automáticamente y no se requiere ninguna acción adicional por parte del desarrollador.

Un ID de dispositivo exclusivo de AppsFlyer se crea para cada instalación nueva de una aplicación. Puedes usar este ID con diversos fines:

• Enviar eventos in-app de servidor a servidor.
• Vincúlala con los registros de usuarios en tus sistemas de backend.
• Asignar entradas cuando se fusionan datos de las API de extracción y envío (Pull/Push API).

Usa la siguiente API para obtener el ID único de AppsFlyer:

NSString *appsflyerId = [AppsFlyerLib shared].getAppsFlyerUID;

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

Para configurar tu ID de usuario de cliente:

[AppsFlyerLib shared].customerUserID = @"my user id";

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

En iOS, el ID de usuario de cliente debe configurarse con cada inicio de la aplicación. Te recomendamos configurar el ID de usuario de cliente lo antes posible en el flujo de tu aplicación, ya que solo se asocia con los eventos reportados después de su configuración:

• Si se llama a setCustomerUserId antes de llamar a start, el ID de usuario de cliente aparece en los reportes de raw data de instalaciones y eventos.
• Si se configura después, el ID de usuario de cliente se asocia solo con eventos registrados después de configurar dicho ID.

Cómo obtener un ID de usuario de cliente:

Para evitar configurar el valor del ID de usuario de cliente nuevamente después del primer inicio, y reducir las llamadas a tu servidor para obtener el ID de usuario de cliente, puedes verificar si su valor está vacío, o no, de la siguiente forma:

NSString *customerUserID = [AppsFlyerLib shared].customerUserID;

let customerUserID = AppsFlyerLib.shared().customerUserID

Para obtener más información sobre el ID de usuario de cliente, haz clic aquí.

Retrasar la inicialización del SDK para customerUserID

Puedes retrasar la inicialización del SDK hasta que se configure el ID de usuario de cliente. Esto es útil si deseas que los datos de instalación y eventos contengan tu ID de usuario de cliente.

Implementa el siguiente código:

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

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

Para aprender más acerca de cómo retrasar la inicialización del SDK hasta que esté disponible el ID de usuario de cliente, ve aquí.

Es posible que desees retrasar la inicialización del SDK y el envío de datos hasta que el usuario lo autorice (por ejemplo, el consentimiento del RGPD y la CCPA).

Nota: Esto no está relacionado con la incorporación de ATT en iOS 14. 

Para retrasar la inicialización del SDK:

1. Evita que la sesión se envíe en transición de fondo a primer plano. En un método sendLaunch() que se llama en cada applicationDidBecomeActive (como en la sección 3.3), encapsula la llamada en start con una comprobación de la condición. Por ejemplo:
   
   

   -(void)sendLaunch:(UIApplication *)application {
       if (consent_given) { // check the condition
           [[AppsFlyerLib shared] start]; // Start
       }
   }

2. Envía la sesión tan pronto como el motivo de la demora deje de ser relevante (justo después de que cambie la condición). Llama a start cuando estés listo para enviar los datos de la primera sesión. Por ejemplo:
   
   

   ...
   consent_given = YES; // change the condition
   [[AppsFlyerLib shared] start]; // Start
   ...

En algunos casos extremos, tal vez necesites desactivar todo el registro de datos del SDK para cumplir con la ley y las políticas de privacidad. Puedes hacer esto con la propiedad isStopped. Una vez que esta propiedad se configura como verdadera, el SDK deja de funcionar y ya no se comunica con los servidores de AppsFlyer.

Existen varios casos para que un usuario opte por la exclusión. Es muy recomendable que sigas las instrucciones exactas para la situación correspondiente a tu aplicación.

[AppsFlyerLib shared].isStopped = true;

AppsFlyerLib.shared().isStopped = true

En cualquier evento, se puede reactivar el SDK llamando a la misma API y pasando un valor falso.

Usa esta API durante la Inicialización del SDK para anonimizar explícitamente las instalaciones, los eventos y las sesiones de un usuario:

[AppsFlyer shared].anonymizeUser = YES;

AppsFlyerLib.shared().anonymizeUser = true

Para reiniciar el registro de datos, puedes configurar anonymizeUser como false (falso).

Usa el SDK de modo estricto para eliminar completamente la funcionalidad de recopilación del identificador de anunciante (IDFA) y las dependencias del marco de AdSupport (por ejemplo, al desarrollar aplicaciones para niños).

Nota: El IDFV sigue estando disponible.

En tu Podfile, reemplaza la dependencia de AppsFlyerLib con:

pod 'AppsFlyerFramework/Strict','6.2.3'

Para deshabilitar los marcos AdSupport e iAd, el SDK proporciona los siguientes configuradores:

• disableCollectASA = true. Más información
• disableAdvertisingIdentifier = true. Más información

Para desactivar los marcos de anuncios:

[AppsFlyerLib shared].disableCollectASA = YES
[AppsFlyerLib shared].disableAdvertisingIdentifier = YES;

AppsFlyerLib.shared().disableCollectASA = true
AppsFlyerLib.shared().disableAdvertisingIdentifier = true

En algunos casos, es posible que los anunciantes deseen dejar de compartir datos a nivel usuario con las redes de publicidad o los partners para usuarios específicos. Las razones para esto incluyen: 

• Políticas de privacidad como la CCPA o el RGPD
• Mecanismos de exclusión opcional de los usuarios
• Competencia con algunos partners (redes de publicidad, terceros)

AppsFlyer proporciona dos métodos de la API para dejar de compartir datos con algunos o todos los partners:

• setSharingFilter: Utilizado por los anunciantes para evitar el intercambio de datos con algunas (una o más) redes/partners integrados.
• setSharingFilterForAllPartners: Utilizado por los anunciantes para evitar el intercambio de datos con todas las redes y partners integrados.

Estos métodos de filtrado son compatibles a partir del SDK V5.4.1.

El método de filtrado debe llamarse cada vez que se inicializa el SDK y afecta a toda la sesión. Si se necesita tiempo para determinar si es necesario configurar los filtros de compartición, entonces retrasa la inicialización del SDK. 

Cuando el método se activa antes de la primera llamada a start:

• Los usuarios de SRN se atribuyen como orgánicos, y sus datos no se comparten con los partners integrados.
• Los usuarios de redes de publicidad de clic (no SRN) se atribuyen correctamente en AppsFlyer, pero no se comparten con las redes de publicidad a través de postbacks, API, reportes de raw data o por cualquier otro método.

Actualmente, los datos de desinstalación no pueden filtrarse con estos métodos. Sin embargo, puedes dejar de enviar los eventos de desinstalación a los partners usando sus páginas de configuración en AppsFlyer.