Integração do SDK do iOS para desenvolvedores

O SDK da AppsFlyer utiliza 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

Observação: A partir do SDK versão 4.8.11, o SDK adiciona automaticamente o AdSupport.framework. O iAd.framework é adicionado automaticamente do SDK versão 4.10.0 e superior.
Se você estiver usando versões anteriores do SDK, consulte as seguintes instruções.

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.

Para adicionar estruturas de suporte a anúncios:

1. No seu projeto do Xcode, selecione o direcionamento do seu projeto.
2. Selecione a guia Geral para o seu direcionamento.
3. Expanda a seção Estruturas e Bibliotecas Vinculadas.
4. Clique em + para adicionar uma estrutura.
5. Pesquise por AdSupport.framework
6. Selecione AdSupport.framework na lista.

Repita o processo para iAd.framework.

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
   
   

   

Para oferecer suporte para links diretos, adicione o seguinte código ao SceneDelegate para todas as cenas nas quais seu aplicativo suporta links diretos.

1. Importando a biblioteca

#import <AppsFlyerLib/AppsFlyerTracker.h>

import AppsFlyerLib

2. Adicionando implementação

#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){
        [[AppsFlyerTracker sharedTracker] handleOpenUrl:url options:nil];
    }
}

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

- (void)scene:(UIScene *)scene willConnectToSession:(UISceneSession *)session options:(UISceneConnectionOptions *)connectionOptions  API_AVAILABLE(ios(13.0)){
    // 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).
}


- (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, continue userActivity: NSUserActivity) {
        AppsFlyerTracker.shared().continue(userActivity, restorationHandler: nil)
    }
    
    func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
        if let url = URLContexts.first?.url {
            AppsFlyerTracker.shared().handleOpen(url, options: nil) 
        }
    }


    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.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).
        guard let _ = (scene as? UIWindowScene) else { return }
    }

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

Antes de começar a testar instalações, inclua na lista branca o dispositivo em que os testes serão realizados.

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:

Enviar Track-App-Launch no registro indica que o SDK relata 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 agora deve aparecer na página Overview (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 agora deve aparecer na página Overview (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 AppsFlyerTracker.h, se estiver usando Objective-C, ou AppsFlyerLib, se estiver usando Swift:

#import AppsFlyerTracker.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: [AppsFlyerTracker sharedTracker].currencyCode = @"ZZZ";,
  • Swift: AppsFlyerTracker.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

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

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

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.

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

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

O SDK da AppsFlyer fornece verificação do servidor para compras in-app. Para validar uma compra, chame o validateAndTrackInAppPurchase.

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

Essa chamada tem dois blocos 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) validateAndTrackInAppPurchase:(NSString *) productIdentifier
price:(NSString *) price
currency:(NSString *) currency
transactionId:(NSString *) tranactionId
additionalParameters:(NSDictionary *) params
success:(void (^)(NSDictionary *response)) successBlock
failure:(void (^)(NSError *error, id reponse)) failedBlock;

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

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

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

[AppsFlyerTracker sharedTracker].useReceiptValidationSandbox = YES;

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

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

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

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.

 [[AppsFlyerTracker sharedTracker] trackEventWithEventName: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);
            }
    }];
    

AppsFlyerTracker.shared().trackEvent(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)
             }
           })
        }
            

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 link direto, implemente o método onAppOpenAttribution.

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

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

Se você deseja receber uma confirmação de que a solicitação de acompanhamento foi recebida com sucesso pelos servidores da AppsFlyer, implemente o manipulador trackAppLaunchWithCompletionHandler. Em seguida, você pode aplicar a lógica para lidar com sucessos ou falhas no acompanhamento de inicializações do aplicativo.

Exemplo de implementação

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

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

É 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];
    
[[AppsFlyerTracker sharedTracker] setAdditionalData:CustomDataMap];

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

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:

[AppsFlyerTracker sharedTracker].minTimeBetweenSessions = <your_custom_time_in_seconds>;

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

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

AppsFlyerTracker.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 {
	[[AppsFlyerTracker sharedTracker] handlePushNotification:userInfo];
  }

func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any]) {
	AppsFlyerTracker.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.

Um ID único da AppsFlyer é criado 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 identificação única da AppsFlyer:

NSString *appsflyerId = [AppsFlyerTracker sharedTracker].getAppsFlyerUID;

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

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

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

AppsFlyerTracker.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 trackAppLaunch, o 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 = [AppsFlyerTracker sharedTracker].customerUserID;

let customerUserID = AppsFlyerTracker.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: @""]) {
        [AppsFlyerTracker sharedTracker].customerUserID = customUserId; // Set CUID in AppsFlyer SDK for this session
        [[AppsFlyerTracker sharedTracker] trackAppLaunch]; // Track App Launch
    }
}

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

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, você pode querer encerrar todos os acompanhamentos de SDK devido às conformidades legais e de privacidade. Isso pode ser obtido com a propriedade isStopTracking . 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.

[AppsFlyerTracker sharedTracker].isStopTracking = true;

AppsFlyerTracker.shared().isStopTracking = 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:

[AppsFlyerTracker sharedTracker].deviceTrackingDisabled = YES;

AppsFlyerTracker.shared().deviceTrackingDisabled = true

O acompanhamento pode ser reiniciado ao definir deviceTrackingDisabled como falso.