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

Este SDK usa 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

Este marco es necesario para registrar y medir el rendimiento de Apple Search Ads en tu aplicación.

Si deseas eliminar estos marcos y deshabilitar la recopilación del identificador de anunciante (IDFA):

1. Para deshabilitar la recolección del identificador de anunciante (IDFA), consulta las instrucciones aquí.
2. Para desactivar iAd.framework, consulta las instrucciones aquí.

Para agregar marcos de soporte de anuncios:

1. En tu proyecto de Xcode, selecciona el objetivo del proyecto.
2. Selecciona la pestaña General para tu objetivo.
3. Expande la sección Marcos y librerías enlazados.
4. Haz clic en + para agregar un marco.
5. Buscar AdSupport.framework
6. Selecciona AdSupport.framework en la lista.

Repite el proceso para iAd.framework.

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 hacer esto:

1. Ve al panel de control de tu aplicación.
2. En el panel de control, en Configuración, haz clic en Configuración de la aplicación.
3. Copia tu clave de desarrollador.
   
   

   

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 admitir enlaces profundos, lo cual comienza con la dirección de los usuarios a la escena predeterminada de la aplicación, agrega el siguiente código a SceneDelegate para la escena predeterminada a la que quieres que los usuarios establezcan un enlace profundo.

1. Importar la biblioteca

#import <AppsFlyerLib/AppsFlyerLib.h>

import AppsFlyerLib

2. Agregar la implementación

#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

@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.
    }
}

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 ya no sea 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
   ...

Antes de empezar a probar las instalaciones:

• Asegúrate de que tu dispositivo no tenga la aplicación instalada.
• Permite la inclusión del dispositivo que vas a probar.

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
   

   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 eventos in-app.

• 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>
    })

[AppsFlyerLib shared].useReceiptValidationSandbox = YES;

AppsFlyerLib.shared().useReceiptValidationSandbox = true

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.

• Evento in-app registrado con éxito.
• Error en el registro del 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, tienda de aplicaciones 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.

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. 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

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 del 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.

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í.

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].disableAdvertisingIdentifier = YES;

AppsFlyerLib.shared().disableAdvertisingIdentifier = true

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

Los mensajes de Apple indican que, en el futuro, iOS 14 requerirá la autorización del usuario para recolectar el Identificador de anunciante (IDFA).

Actualmente, el IDFA se recopila por defecto. Sin embargo, para el iOS 14 beta 7 y versiones posteriores, tienes la opción de solicitar la autorización del usuario para recopilar el IDFA a través de un diálogo de consentimiento. Si el usuario no lo autoriza, el IDFA no se recopila. El intervalo de tiempo de espera retrasa el envío de una solicitud a los servidores de AppsFlyer. Después de que el temporizador expira, se envía la solicitud.

Para solicitar la autorización del usuario para recopilar el IDFA, agrega el siguiente código antes de start(): 

// The following block is for applications wishing to give users the option to block IDFA collection.
 // for iOS 14 and above - The user can be prompted to block IDFA collection.
 //                        If user opts-out, the IDFA will not be collected by the SDK.
 // for iOS 13 and below - The IDFA will be collected by the SDK. The user will NOT be prompted to block collection.
 if #available(iOS 14, *) { 
    // Set a timeout for the SDK to wait for the IDFA collection before handling app launch
    // If timeout expires before user asks to block IDFA collection, the IDFA will be collected.
    [[AppsFlyerLib shared] waitForATTUserAuthorizationWithTimeoutInterval:60];
    // Show the user the Apple IDFA consent dialog 
    (AppTrackingTransparency)
    // MUST be called here before start() in order to prevent IDFA collection by the SDK

    [ATTrackingManager requestTrackingAuthorizationWithCompletionHandler:^(ATTrackingManagerAuthorizationStatus status) {
    //....
    }];
}

// The following block is for applications wishing to give users the option to block IDFA collection.
 // for iOS 14 and above - The user can be prompted to block IDFA collection.
 //                        If user opts-out, the IDFA will not be collected by the SDK.
 // for iOS 13 and below - The IDFA will be collected by the SDK. The user will NOT be prompted to block collection.
 if #available(iOS 14, *) {
    // Set a timeout for the SDK to wait for the IDFA collection before handling app launch
    // If timeout expires before user asks to block IDFA collection, the IDFA will be collected.
    AppsFlyerLib.shared().waitForATTUserAuthorization(timeoutInterval: 60)
    // Show the user the Apple IDFA consent dialog (AppTrackingTransparency)
    // MUST be called here before start() in order to prevent IDFA collection by the SDK
    ATTrackingManager.requestTrackingAuthorization { (status) in
    }
 }

Para configurar el texto que se le mostrará al usuario en el mensaje emergente:

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.

   

Las posibles acciones del usuario en la ventana emergente de ATT y los resultados (en función del temporizador establecido por el desarrollador en el método waitForATTUserAuthorization) se enumeran en la tabla a continuación. 

Nota: Después de que el temporizador expira, se inicia el SDK de AppsFlyer, ya sea recopilando el IDFA o no. 

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.