Guia de integração do SDK V6.X do iOS para desenvolvedores

Esse SDK adiciona e usa automaticamente as seguintes estruturas nativas:

AdSupport.framework

Essa estrutura é necessária para coletar o IDFA dos dispositivos.
Sem o IDFA você não consegue atribuir instalações aos anúncios do Facebook, Twitter, Google e outras redes.

iAd.framework

Essa estrutura é necessária para gravar e medir o desempenho dos anúncios da Apple Search em seu aplicativo

Se você deseja remover essas estruturas e desativar a coleção IDFA:

1. Para desativar a coleção IDFA, veja as informações  aqui.
2. Para desativar   iAd.framework, veja as informações aqui.

SDK de modo estrito

Use o SDK de modo estrito para remover completamente a funcionalidade de coleta IDFA e as dependências do framework do AdSupport (por exemplo, ao desenvolver aplicativos para crianças).

No seu Podfile, substitua a dependência AppsFlyerLibpor:

pod 'AppsFlyerFramework/Strict','6.1.1'

A AppsFlyer usa a chave do desenvolvedor para identificar exclusivamente sua conta. A chave do desenvolvedor é obrigatória porque permite que o SDK envie e recupere com segurança dados que pertencem à sua conta da AppsFlyer.

Fazer:

1. Acesse o painel do seu aplicativo.
2. No painel, em Configuration (Configuração), clique em App Settings (Definições do aplicativo)
3. Copie sua chave do desenvolvedor.
   

O seguinte código é um exemplo de implementação. Certifique-se de alterar os placeholders <AF_DEV_KEY> e <APPLE_APP_ID> conforme necessário.

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

Use esse método de inicialização somente se estiver usando SceneDelegate.

Como o applicationDidBecomeActive não é chamado ao usar o SceneDelegate, use a solução alternativa UIApplicationDidBecomeActiveNotification para inicializar o SDK, como mostrado no exemplo a seguir.

O seguinte código é um exemplo de implementação. Certifique-se de alterar os placeholders <AF_DEV_KEY> e <APPLE_APP_ID> conforme necessário.

#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];
        return YES;
  }
  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 esse método para opcionalmente configurar e anexar a `janela` UIWindow para a `cena` UIWindowScene fornecida. 
    // Se estiver usando um storyboard, a propriedade `janela` será automaticamente inicializada e anexada à cena.
    // Esse representante não significa que a cena ou sessão de conexão sejam novas (para isso, veja `application:configurationForConnectingSceneSession`).
    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.
    }
}              
            

O SkadNetwork é uma classe usada pelo iOS que valida instalações de aplicativos orientadas por anunciantes. O processo de validação de instalação do aplicativo envolve o aplicativo de origem e o aplicativo anunciado. 

Um aplicativo de fonte é um aplicativo que participa de campanhas publicitárias exibindo anúncios assinados por uma ad network. Configurar seu aplicativo para exibir anúncios não está dentro do escopo do SDK da AppsFlyer. Para configurar, siga as instruções da Apple.

Para o aplicativo anunciado (o aplicativo com o SDK da AppsFlyer), a solução de SkadNetwork da AppsFlyer usa a SkadNetwork para fornecer o postback de atribuição enquanto a AppsFlyer coleta, traduz e agrega os dados, mantendo a privacidade do usuário. Ao iniciar o aplicativo pela primeira vez, a plataforma da AppsFlyer, usando a configuração definida pelo profissional de marketing, instrui o SDK em como definir o valor de conversão de SkadNetwork.

Para usar a solução SkadNetwork:

• O desenvolvedor não faz nada.
• O SDK da AppsFlyer chama automaticamente as APIs necessárias do SkadNetwork, ou seja, registerAppForAdNetworkAttribution() e UpdateConversionValue(). O desenvolvedor não deve chamá-las. 
• Não permita que outros SDKs chamem APIs SKADnet. Isso pode atrasar o iOS no envio do postback para a AppsFlyer e alterar o valor de conversão que usamos para calcular métricas de qualidade do usuário do painel do SkadNetwork. 
• O profissional de marketing precisa configurar a métrica do SkadNetwork na AppsFlyer . 

O desenvolvedor ou profissional de marketing não precisa realizar nenhuma ação ou processo de registro na loja de aplicativos. 

Você pode querer atrasar a inicialização do SDK e o envio de dados até que o usuário dê consentimento (por exemplo, consentimento do GDPR ou COPPA).

Observação: isso não está relacionado ao ATT introduzido no iOS 14. 

Para atrasar a inicialização do SDK:

1. Impeça que a sessão seja enviada na transição em segundo plano. Em um método sendLaunch() (que é chamado em cada applicationDidBecomeActive, conforme a seção 3.3), quebre a chamada para começar com uma verificação de condição. Por exemplo:
   
   

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

2. Envie a sessão assim que o motivo do atraso não for mais relevante (logo após alterações da condição). Chame start quando tudo estiver pronto para enviar dados da primeira sessão. Por exemplo:
   
   

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

Antes de começar a testar as instalações:

• Certifique-se de que o dispositivo não tem o aplicativo instalado.
• Registre o dispositivo que você vai testar.

Instalações orgânicas são instalações não atribuídas, geralmente instalações diretas das lojas de aplicativos.

Para simular uma instalação orgânica:

1. Verifique se você tem um dispositivo móvel conectado ao seu computador
2. Em Xcode, abra o terminal de depuração.
3. No Xcode Studio, instale o aplicativo no dispositivo ou simulador.
4. Aguarde o aplicativo iniciar.
5. No terminal de depuração, procure o nome do pacote do seu aplicativo.

Você deve ver o seguinte:

Send start() no registro indica que o SDK está reportando uma instalação. Esses dados são provenientes do método onConversionDataSuccess no representante do aplicativo. Discutiremos como obter dados de conversão mais adiante neste guia.

Nota: Iniciando o SDK V5, o nome do método para obter dados de conversão é onConversionDataSuccess . Se você estiver usando uma versão do SDK abaixo de 5.0.0, o nome do método será onConversionDataReceived. Recomendamos que você atualize para o SDK 5.0.0. Clique aqui para saber mais.

Uma instalação orgânica deve aparecer na página Visão geral do painel do aplicativo.

Se você não encontrar uma instalação no painel do aplicativo, consulte o guia de solução de problemas do SDK.

Uma instalação não orgânica é uma instalação atribuída que geralmente segue um engajamento de anúncio. Você pode simular uma instalação não orgânica usando links de atribuição.

Fazer:

1. Descubra qual é o nome do ID do iTunes do seu aplicativo, por exemplo, id123456789.
2. Na URL abaixo, substitua <APP_ID> pelo ID do iTunes do seu aplicativo:
   

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

   O parâmetro pid representa o nome da fonte de mídia. O parâmetro c representa o nome da campanha.
3. Envie esta URL para o dispositivo (por exemplo, via e-mail ou WhatsApp).
4. No dispositivo, clique no URL.
   • Se o aplicativo estiver listado na loja de aplicativos, você será redirecionado para a loja de aplicativos. Não baixe e instale o aplicativo na loja de aplicativos. Prossiga para a etapa 5.
   • Se o aplicativo não estiver listado na loja de aplicativos e ainda estiver em desenvolvimento, a tela mostrará uma mensagem de que o aplicativo não está disponível na loja de aplicativos. Simplesmente prossiga para a etapa 5.
5. No Xcode Studio, abra o terminal de depuração.
6. Conecte o dispositivo ao seu computador usando um cabo USB.
7. Instale o aplicativo no dispositivo pelo Xcode.
8. No terminal de depuração, procure o ID do iTunes do seu aplicativo.

Você deve ver o seguinte:

Uma instalação não orgânica deve aparecer na página Visão geral do painel do aplicativo.

O SDK contém dois tipos de constantes que representam as informações relacionadas a eventos in-app

• Nomes de eventos - essas constantes vêm no formato AFEventEventName.
  Por exemplo, AFEventPurchase, AFEventAddToCart.
• Parâmetros do evento - essas constantes vêm no formato AFEventParameterParameterName.
  Por exemplo, AFEventParameterRevenue, AFEventParamaterContentId.

É altamente recomendável usar essas duas constantes pelos seguintes motivos:

• A nomeação padrão permite que a AppsFlyer mapeie automaticamente eventos para SRNs, como Facebook, Google, Twitter e Snapchat.
• Compatibilidade com versões anteriores — se a AppsFlyer decidir alterar o nome de qualquer evento ou parâmetro de evento, sua implementação será compatível com versões anteriores.

Para usar essas duas interfaces, importe AppsFlyerLib.h se estiver usando Objective-C, ou AppsFlyerLib, se estiver usando Swift:

#import AppsFlyerLib.h

import AppsFlyerLib

Esta é a lista de nomes de eventos e estruturas recomendados.

É possível enviar receita com qualquer evento in-app. Use o parâmetro de evento af_revenue(AFEventParameterRevenue) para incluir receita no evento in-app. Você pode preenchê-lo com qualquer valor numérico, positivo ou negativo.

af_revenue é o único parâmetro de evento que é contado na AppsFlyer como receita real nos dados brutos e painel. Para obter mais detalhes, clique aqui.

Ao enviar eventos com receita, lembre-se do seguinte:

• Se você definir o código de moeda (veja o exemplo abaixo), deverá ser um código ISO 4217 de 3 caracteres (a moeda padrão é USD).
• Você pode definir o código de moeda para todos os eventos definindo a propriedade a seguir:
  • Objective-C: [AppsFlyerLib shared].currencyCode = @"ZZZ";,
  • Swift: AppsFlyerLib.shared().currencyCode = "ZZZ"
  Para saber mais sobre definições de moeda, exibição e conversão de moeda, veja nosso guia sobre moeda de receita.
• O valor da receita não deve conter separadores de vírgula, símbolo de moeda ou texto. Um evento de receita deve ser semelhante a 1234,56, por exemplo.

Exemplo: evento de compra de eventos in-app com receita

[[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"
]);

O evento de compra acima tem $200 em receita, aparecendo como receita no painel.

Gravação de receita negativa

Pode haver situações em que você deseja registrar receita negativa.

Por exemplo, um usuário recebe um reembolso ou cancela uma assinatura.

[[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"
]);

O SDK da AppsFlyer fornece verificação do servidor para compras no aplicativo. Para validar uma compra, chame validateAndLogInAppPurchase.

Essa chamada gera automaticamente um evento in-app af_purchase, desde que a compra seja validada.

Essa chamada tem dois blocos de callback: um para "sucesso" e outro para "falha" (por qualquer motivo, incluindo falha na validação). Em caso de sucesso, um dicionário é retornado com os dados de validação do recebimento fornecidos pelos servidores da Apple. 

Exemplo de uso de validação de uma 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

A validação da compra in-app envia automaticamente um evento de compra in-app à AppsFlyer. Veja abaixo um exemplo de dados que são passados no 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
}

• Nome do evento: até 45 caracteres
• Valor do evento: não deve exceder 1000 caracteres - caso exceda, pode ser necessário restringi-lo.
• Preço e receita: use apenas dígitos e decimais, por exemplo, 5 ou 5,2
• Os valores de preço e receita podem ter até 5 dígitos após o ponto, por exemplo, 5.12345
• Os caracteres que não são em inglês são suportados em eventos in-app,  outras APIs do SDK, a partir do Android SDK V4.8.1.

É possível gravar eventos in-app chamando trackEvent com os parâmetros de nome e valor do evento. Consulte a documentação sobre Eventos in-app para obter mais detalhes.

Veja abaixo um exemplo simples de como gravar um evento de compra. Para obter uma lista abrangente de trechos de código prontos por vertical, consulte nosso guia sobre eventos avançados dentro do aplicativo por verticais.

Exemplo: 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"]);

Se um usuário iniciar um evento quando a conexão à internet estiver indisponível, a Appsflyer ainda pode realizar o registro do evento. Confira como funciona:

1. O SDK envia os eventos aos servidores da AppsFlyer e aguarda uma resposta.
2. Se o SDK não receber 200 como resposta, o evento é armazenado no cache.
3. Quando o próximo 200 como resposta for recebido, o evento armazenado é reenviado ao servidor.
4. Se houver vários eventos no cache, eles são enviados para o servidor, um imediatamente após o outro.

• Evento in-app gravado com sucesso.
• Ocorreu um erro ao gravar o 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)
             }
           })
        }
            

Se um erro ocorrer ao gravar o evento in-app, um código de erro e uma descrição de string são fornecidos, conforme indicado na tabela a seguir.

O OneLink detecta o tipo de dispositivo após o clique, e redireciona o usuário para o destino correspondente, por exemplo, Google Play, loja de aplicativos para iOS, mercados fora da loja ou páginas da web.

O guia de redirecionamentos do OneLink discute a implementação de links de atribuição multiplataforma (não é necessária codificação do SDK). Também é a base para links diretos.

Os links diretos permitem enviar usuários a atividades específicas e servi-los com conteúdo personalizado. Isso é especialmente útil ao realizar campanhas de redirecionamento.

Para configurar links diretos com o OneLink, um profissional de marketing com acesso ao painel da AppsFlyer e um desenvolvedor com acesso ao aplicativo devem trabalhar juntos.

Consulte o nosso guia sobre configuração de links diretos com o OneLink.

A ligação direta adiada permite fazer links diretos com novos usuários e servi-los com conteúdo personalizado após a primeira instalação do aplicativo. Isso é diferente dos links diretos regulares, em que o aplicativo já deve estar instalado no dispositivo do usuário.

Para configurar a ligação direta adiada com o OneLink, o desenvolvedor também precisa de acesso ao painel da AppsFlyer.

A configuração para ligação direta adiada é a mesma que para links diretos. A única diferença é que você precisa implementar lógica adicional no aplicativo para aplicar link direto aos usuários e servi-los com conteúdo personalizado após a instalação e a inicialização do aplicativo.

Consulte o nosso guia sobre ligação direta adiada para saber mais.

O SDK fornece os dados de conversão ou engajamento após cada evento de instalação ou links diretos. É possível usar esses dados para personalizar o conteúdo e o comportamento do aplicativo programaticamente.

Para obter dados de links diretos quando o link direto é usado e o aplicativo é aberto, implemente o método onAppOpenAttribution.

Para obter dados de links diretos de reengajamento manualmente a qualquer momento, implemente o método performOnAppAttribution. Isso permite o acesso aos dados de reengajamento sem gravar um novo reengajamento.

Consulte o nosso guia sobre dados de links diretos para saber mais.

Você pode acessar os dados de atribuição do usuário em tempo real para cada nova instalação, diretamente do SDK.

Isso permite que você possa atender aos usuários com conteúdo personalizado ou enviá-los para atividades específicas no aplicativo (consulte ligação direta adiada neste artigo), o que pode melhorar bastante o engajamento deles com o aplicativo.

Para obter dados de conversão do SDK do iOS, implemente os seguintes 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)
    }
  }

Os dois métodos mais importantes são:

• onConversionDataSuccess - fornece dados de conversão para novas instalações.
  

  Nota: Iniciando o SDK V5, o nome do método para obter dados de conversão é onConversionDataSuccess . Se você estiver usando uma versão do SDK abaixo de 5.0.0, o nome do método será onConversionDataReceived. Recomendamos que você atualize para o SDK 5.0.0. Clique aqui para saber mais.

• onAppOpenAttribution — fornece dados de conversão de redirecionamento quando um aplicativo existente é iniciado, manualmente ou por meio de links diretos.

Para saber mais sobre dados de conversão, consulte nosso guia sobre cenários de dados de conversão.

Para saber como configurar a métrica de desinstalação, leia aqui.

Se você deseja receber uma confirmação de que o SDK foi iniciado com sucesso e notificou os servidores da AppsFlyer, implemente o manipulador StartWithCompletionHandler. Em seguida, você pode aplicar lógica para lidar com o sucesso ou falha da inicialização do SDK.

Exemplo de implementação

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

Se ocorrer um erro durante o ouvinte de solicitação, um código de erro e uma descrição de string são fornecidos, conforme indicado na tabela a seguir.

É necessária a API setAdditionalData para integrar-se no nível do SDK com várias plataformas de parceiros externas, incluindo Segment, Adobe e Urban Airship.
Use esta API apenas se o artigo de integração da plataforma afirmar especificamente que a API setAdditionalData é necessária.

Exemplo de código 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

Os proprietários de aplicativos que usam links universais para links diretos (sem OneLink) e têm um domínio associado ao aplicativo podem atribuir sessões iniciadas por meio desse domínio usando o método appendParametersToDeepLinkingUrl .

Por exemplo, um usuário faz uma pesquisa no Google e clica no seu domínio, www.exemplo.com:

• Se o usuário não tiver o aplicativo instalado, ele será direcionado para o site (www.example.com).
• Se o usuário tiver o aplicativo instalado no seu dispositivo, haverá um link direto para o aplicativo associado com www.exemplo.com. A sessão é atribuída à fonte de mídia (parâmetro pid ) especificada em appendParametersToDeeplinkingUrl.

Consulte a referência do SDK do iOS para obter informações adicionais.

Observação: Smart Banners ajudam os proprietários de aplicativos a converter visitantes do site em usuários do aplicativo.

Por padrão, deve haver um intervalo mínimo de 5 segundos entre duas inicializações de aplicativos para que essas duas sessões sejam contabilizadas separadamente (saiba mais sobre contabilização de sessões).

Use a seguinte API para definir o tempo mínimo entre sessões:

[AppsFlyerLib shared].minTimeBetweenSessions = <your_custom_time_in_seconds>;

AppsFlyerLib.shared().minTimeBetweenSessions = <your_custom_time_in_seconds>

Definir um valor alto para o tempo personalizado entre inicializações pode gerar um impacto negativo nas APIs que dependem dos dados das sessões, como links diretos.

Indisponível no iOS. 

Alguns serviços de terceiros, como provedores de serviços de e-mail, envolvem links em e-mails com seus próprios domínios de gravação de links. Alguns até permitem que você defina seus próprios domínios de gravação de links. Se o OneLink estiver agrupado nesses domínios, poderá limitar sua funcionalidade.

Para superar esse problema, você pode usar a API setResolveDeepLinkURLs. Use esta API para obter o OneLink de domínios de clique que iniciam o aplicativo.  Certifique-se de chamar essa API antes da inicialização do SDK.

Por exemplo, você tem três domínios de clique que redirecionam para o OneLink, que é https://mysubdomain.onelink.me/abCD. Use esta API para obter o OneLink ao qual seus domínios de clique redirecionam.  Este método de API recebe uma lista de domínios que o SDK resolve.

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

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

O código acima permite usar seu domínio de clique, preservando a funcionalidade do OneLink. Os domínios de clique são responsáveis pela inicialização do aplicativo. A API, por sua vez, recebe o Onelink destes domínios de clique e, depois, é possível usar os dados deste Onelink para aplicar links diretos e personalizar o conteúdo do usuário.

Com a AppsFlyer, você pode medir as notificações push como parte de campanhas de redirecionamento.

Para ativar esse recurso, chame o 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 mais informações sobre medição de notificações por push, leia aqui.

Permitir que os usuários existentes convidem seus amigos e contatos como novos usuários para seu aplicativo pode ser um fator de crescimento importante para seu aplicativo. Com a AppsFlyer, você pode atribuir e registrar instalações originadas de convites do usuário em seu aplicativo.

Para obter detalhes, consulte o artigo de atribuição de convite do usuário.

Uma ID exclusiva da AppsFlyer é criada para cada nova instalação de um aplicativo. Você pode usar esse ID para vários fins:

• Enviar eventos in-app de servidor para servidor.
• Combine-a com os registros de usuário em seus sistemas de back-end.
• Mapear entradas ao mesclar dados das APIs pull e push .

Use a seguinte API para obter a ID exclusiva:

NSString *appsflyerId = [AppsFlyerLib shared].getAppsFlyerUID;

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

Para definir sua identificação de usuário cliente:

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

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

No iOS, o ID de usuário cliente precisa ser definido a cada inicialização do aplicativo. Recomendamos definir o ID de usuário cliente no início do fluxo do aplicativo, pois ele está associado apenas aos eventos relatados após sua configuração:

• Se setCustomerUserID for chamado antes de chamar start, a ID de usuário cliente aparecerá nos relatórios de dados brutos para instalações e eventos.
• Se for definido depois, o ID de usuário cliente será associado apenas a eventos registrados após a configuração do ID de usuário cliente.

Obtenção de ID de usuário cliente:

Para evitar definir o valor do ID de usuário cliente novamente após a primeira inicialização e reduzir as chamadas para o servidor a fim de obter o ID de usuário cliente, você pode verificar se o valor está vazio ou não, usando:

NSString *customerUserID = [AppsFlyerLib shared].customerUserID;

let customerUserID = AppsFlyerLib.shared().customerUserID

Para mais informações sobre ID de usuário cliente, clique aqui .

Atrasar init do SDK para customerUserID

É possível atrasar a inicialização do SDK até que o Customer User ID esteja definido. Isso é útil se para você for importante que os dados de instalação e evento contenham seu ID de usuário do cliente.

Implemente o seguinte 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 saber mais sobre como adiar a inicialização do SDK até que o ID de usuário cliente esteja disponível, acesse aqui.

Em alguns casos extremos, talvez seja necessário encerrar todos os registros de dados do SDK devido à conformidade legal e de privacidade. Isso pode ser alcançado com a propriedade isStopped. Depois que essa API é definida como verdadeira, o SDK para de funcionar e não se comunica mais com os servidores da AppsFlyer.

Há vários cenários diferentes para a exclusão (opt-out) de usuários. É altamente recomendado seguir as instruções exatas do cenário relevante para seu aplicativo.

[AppsFlyerLib shared].isStopped = true;

AppsFlyerLib.shared().isStopped = true

Em qualquer evento, o SDK pode ser reativado chamando a mesma API passando o valor "false".

Use esta API durante a inicialização do SDK para anonimizar explicitamente as instalações, eventos e sessões de um usuário:

[AppsFlyer shared].disableAdvertisingIdentifier = YES;

AppsFlyerLib.shared().disableAdvertisingIdentifier = true

O registro de dados pode ser reiniciado definindo AnonymizeUser como false.

A mensagem da Apple indica que no futuro, o iOS 14 exigirá autorização do usuário para coletar IDFA.

Atualmente, o IDFA é coletado automaticamente. No entanto, para o iOS 14 e posterior, você tem a opção de solicitar autorização do usuário para coletar IDFA por meio de uma caixa de diálogo de consentimento. Se o usuário optar por não participar, o IDFA não será coletado. O intervalo de tempo limite atrasa o envio de uma solicitação aos servidores da AppsFlyer. Quando o temporizador expira, a solicitação é enviada.

Para solicitar autorização do usuário para coletar IDFA, adicione o seguinte 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 o texto apresentado ao usuário no pop-up:

1. Selecione o arquivo Info.plist do projeto no Xcode Project Navigator.
2. Adicione uma entrada à lista: Pressione+ ao lado de Lista de Propriedade de Informação.

   

3. Role para baixo e selecione Privacidade - Descrição do uso do Acompanhamento.
4. Adicione como valor o texto que você deseja apresentar ao usuário ao solicitar permissão para coletar o IDFA.

   

As possíveis ações do usuário no pop-up ATT e resultados (com base no temporizador definido pelo desenvolvedor no método waitForAttUserAuthorization) estão listadas na tabela a seguir. 

Observação: após o término do temporizador, o SDK da AppsFlyer é iniciado, com ou sem a coleta do IDFA. 

Para disponibilizar o aplicativo na Categoria Crianças da loja de aplicativos, a Apple exige que você não "transmita informações de identificação pessoal ou informações do dispositivo a terceiros". Para estar em conformidade com isso, você deve desativar explicitamente as estruturas do AdSupport e do iAd.  

Para desativar as estruturas de anúncios:

• disableColectASA = true. Saiba mais
• disableAdvertisingIdentifier = true. Saiba mais

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

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

Em alguns casos, os anunciantes podem querer parar de compartilhar dados no nível do usuário com ad networks/parceiros para determinados usuários. Os motivos para isso incluem: 

• Políticas de privacidade como CCPA ou GDPR
• Mecanismos para o usuário optar por não participar
• Concorrência com alguns parceiros (ad networks, terceiros)

A AppsFlyer fornece dois métodos de API para interromper o compartilhamento de dados com alguns ou todos os parceiros:

• setSharingFilter: usado por anunciantes para impedir o compartilhamento de dados com algumas (uma ou mais) redes/parceiros integrados .
• SetSharingFilterForAllPartners: usado por anunciantes para impedir o compartilhamento de dados com todas as rede/parceiros integrados.

Esses métodos de filtragem são suportados a partir do SDK V5.4.1.

O método de filtragem deve ser chamado sempre que o SDK é inicializado e afeta a sessão toda. Se demorar para determinar se você precisa definir os filtros de compartilhamento, atrase a inicialização do SDK. 

Quando o método for ativado antes do primeiro start chame:

• Os usuários de SRNs são atribuídos como orgânicos e seus dados não são compartilhados com parceiros integrados.
• Os usuários de ad networks de cliques (não-SRNs) são atribuídos corretamente na AppsFlyer, mas não são compartilhados com as ad networks por meio de postbacks, APIs, relatórios de dados brutos ou por qualquer outro método.

Atualmente, os dados de desinstalação não podem ser filtrados usando esses métodos. No entanto, você pode parar de enviar eventos de desinstalação para parceiros usando suas páginas de configuraçãona AppsFlyer.