Intégration SDK iOS pour les développeurs

Le SDK AppsFlyer utilise les cadres natifs suivants :

AdSupport.framework

Ce cadre est nécessaire pour collecter l’IDFA des appareils.
Sans IDFA vous ne pouvez pas attribuer d'installations à Facebook Ads, Twitter, Google Ads et aux autres réseaux.

iAd.framework

Ce cadre est nécessaire pour enregistrer et mesurer les performances des Apple Search Ads dans votre application.

Remarque : depuis la version 4.8.11 du SDK, le SDK ajoute automatiquement AdSupport.framework et iAd.framework. iAd.framework est ajouté automatiquement à partir des versions 4.10.0 et supérieures du SDK.
Si vous utilisez des versions précédentes du SDK, consultez les instructions suivantes.

Si vous souhaitez supprimer ces infrastructures et désactiver la collecte IDFA :

1. Pour désactiver la collecte IDFA, consultez les instructions ici .
2. Pour désactiver iAd.framework, consultez les instructions ici.

Pour ajouter des infrastructures de publicités :

1. Dans votre projet XCode, sélectionnez la cible de votre projet.
2. Sélectionnez l'onglet Général pour votre cible.
3. Développez la section Infrastructures et librairies associées.
4. Cliquez sur + pour ajouter un cadre.
5. Recherchez AdSupport.framework
6. Sélectionnez AdSupport.framework dans la liste.

Répétez le processus pour iAd.framework.

AppsFlyer utilise la clé dev pour identifier votre compte de manière unique. La clé dev est obligatoire car elle permet au SDK d'envoyer et de récupérer en toute sécurité des données appartenant à votre compte AppsFlyer.

Marche à suivre :

1. Allez au tableau de bord de votre app 
2. Sur le tableau de bord, sous Configuration, cliquez sur Paramètres d'app.
3. Copiez votre clé dev
   
   

   

Pour la prise en charge du deep linking, ajoutez le code suivant à SceneDelegate pour chaque scène dans laquelle votre app prend en charge le deep linking.

1. Importation de la bibliothèque

#import < AppsFlyerLib/AppsFlyerTracker.h >

import AppsFlyerLib

2. Ajout d'implémentation

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

Avant de commencer à tester les installations, mettez en liste blanche l'appareil sur lequel vous allez effectuer le test.

Les installations organiques sont des installations non attribuées qui sont généralement des installations directes à partir des app stores.

Pour simuler une installation organique :

1. Assurez-vous qu'un appareil mobile est connecté à votre ordinateur
2. Dans Xcode, ouvrez le terminal de débogage.
3. Depuis Xcode Studio, installez l'app sur l'appareil ou l'émulateur.
4. Attendez que l'application se lance.
5. Dans le terminal de débogage, recherchez le nom du package de votre app.

Vous devriez voir ce qui suit :

L'envoi du suivi des lancements d'application indique que le SDK signale une installation. Ces données proviennent de la méthodeonConversionDataSuccess d'App Delegate. L'obtention des données de conversion est mentionnée plus loin dans ce guide.

Remarque :depuis le SDK V5, onConversionDataSuccess est le nom de la méthode d'obtention des données de conversion. Si vous utilisez une version du SDK inférieure à la version 5.0.0, le nom de la méthode est onConversionDataReceived . Nous vous recommandons une mise à niveau vers le SDK 5.0.0. Pour en savoir plus, cliquez ici.

Une installation organique doit désormais apparaître sur la page Présentation du tableau de bord de l'application.

Si vous ne voyez pas l'installation sur le tableau de bord de l'app, consultez notre guide de dépannage du SDK.

Une installation non organique est une installation attribuée qui suit généralement un engagement publicitaire. Vous pouvez simuler une installation non organique en utilisant des liens d'attribution.

Marche à suivre :

1. Trouvez quel est l'ID iTunes de votre app, par exemple id123456789.
2. Dans l'URL ci-dessous, remplacez <APP_ID> par l'ID itunes de votre app :
   

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

   Le paramètre pid représente le nom de la source média. Le paramètre c représente le nom de la campagne.
3. Envoyez cette URL à l'appareil (via email ou WhatsApp par exemple).
4. Sur l'appareil, cliquez sur l'URL.
   • Si l'app est répertoriée dans l'app store, vous serez redirigé vers l'app store. Ne pas télécharger l'app depuis l'app store. Passez à l'étape 5.
   • Si l'app n'est pas répertoriée dans l'app store et est encore en développement, l'écran affiche un message indiquant que l'app n'est pas disponible dans l'app store. Passez à l'étape 5.
5. Dans Xcode Studio, ouvrez le terminal de débogage.
6. Connectez l'appareil à votre ordinateur à l'aide d'un câble USB.
7. Depuis Xcode, installez l'app sur l'appareil.
8. Dans le terminal de débogage, recherchez l'ID itunes de votre app.

Vous devriez voir ce qui suit :

Une installation non organique doit désormais apparaître sur la page Présentation du tableau de bord de l'application.

Le SDK contient deux types de constantes qui représentent les informations liées aux événements in app.

• Noms d'événements - ces constantes sont au format AFEventEventName.
  Par exemple AFEventPurchase,AFEventAddToCart .
• Paramètres d'événement - Ces constantes sont au format AFEventParameterParameterName.
  Par exemple AFEventParameterRevenue, AFEventParamaterContentId.

Nous recommandons fortement d'utiliser ces constantes pour les raisons suivantes :

• La dénomination standard permet à AppsFlyer de mapper automatiquement les évènements sur des SRN tels que Facebook, Google, Twitter et Snapchat.
• Rétrocompatibilité - si AppsFlyer décide de modifier le nom ou le paramètre d'un évènement, votre implémentation est compatible avec les version antérieures.

Pour utiliser ces deux interfaces, importez AppsFlyerTracker.h si vous utilisez Objective-C (ou AppsFlyerLib si vous utilisez Swift) :

#import AppsFlyerTracker.h

import AppsFlyerLib

Voici la liste des noms et structures d'évènements recommandés.

Vous pouvez envoyer des revenus avec n'importe quel évènement in-app. Utilisez le paramètre d'évènement af_revenue (AFInAppEventParameterName.REVENUE) pour intégrer le revenu dans l'évènement in-app. Vous pouvez lui affecter n'importe quelle valeur numérique, positive comme négative.

af_revenue est le seul paramètre d’évènement qu'AppsFlyer compte en tant que revenu réel dans les données brutes et le tableau de bord. Pour plus de détails, cliquez ici.

Lors de l'envoi d'évènements avec revenus, pensez aux éléments suivants :

• Si vous définissez un code de devise (voir exemple ci-dessous), il doit s'agir d'un code ISO 4217 de 3 caractères (la devise par défaut est USD).
• Vous pouvez définir le code de devise pour tous les événements en appelant la propriété suivante :
  • Objective-C: [AppsFlyerTracker sharedTracker].currencyCode = @"ZZZ";,
  • Swift: AppsFlyerTracker.shared().currencyCode = "ZZZ"
  Pour en savoir plus sur les paramètres de devise, l'affichage et la conversion de devise, consultez notre guide sur la devise du revenu.
• La valeur de revenu ne doit pas contenir de séparateurs sous forme de virgules, de symbole monétaire ou de texte. Un événement de revenu doit être similaire à 1234.56, par exemple.

Exemple : évènement d'achat d'évènement in-app avec revenus

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

L’événement d’achat ci-dessus a un revenu de 200 USD, apparaissant en tant que revenu dans le tableau de bord.

Enregistrement de revenus négatifs

Dans certaines situations, vous voudrez peut-être enregistrer un revenu négatif.

Par exemple, si l'utilisateur reçoit un remboursement ou annule un abonnement.

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

Le SDK d'AppsFlyer fournit une vérification au niveau du serveur pour les achats in-app. Pour valider un achat, appelez la méthode validateAndTrackInAppPurchase.

Cet appel génère automatiquement un évènement in-app af_purchase si l'achat est validé.

Cet appel contient deux blocs de rappel, l'un pour la « réussite » et l'autre pour « l'échec » (quelle qu'en soit la raison, y compris l'échec de validation). En cas de réussite, un dictionnaire est retourné avec les données de validation de reçu fournies par les serveurs d’Apple. 

Exemple de validation d'un achat :

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

La validation d'un achat in-app envoie automatiquement un évènement d'achat in-app à AppsFlyer. Vous trouverez ci-dessous un exemple des données transmises dans le paramètre 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
}

• Nom de l'événement : 45 caractères maximum
• Valeur de l'événement : ne doit pas dépasser 1000 caractères - s'il est plus long, nous pourrions le tronquer
• Tarification et revenu : utilisez uniquement des chiffres et des décimales, par exemple 5 ou 5,2.
• Les valeurs de tarification et de revenu peuvent comporter jusqu'à 5 chiffres après le symbole de décimale, par exemple, 5.12345
• Les caractères non anglais sont pris en charge, dans les événements in-app, les autres API SDK à partir du SDK Android V4.8.1.

Vous pouvez enregistrer des évènements in-app en appelant trackEvent avec le nom de l'évènement et les paramètres de valeur. Consultez la documentation Événements in-app pour plus de détails.

Vous trouverez ci-dessous un exemple simple sur la façon d'enregistrer un évènement d'achat. Pour obtenir une liste complète des extraits de code prêts à l'emploi par secteur, consultez notre guide concernant les évènements rich in-app par secteur.

Exemple : évènement d'achat 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"]);

Si un utilisateur initie un évènement lorsque la connexion Internet est indisponible, Appsflyer est capable de l'enregistrer. Voici comment cela fonctionne :

1. Le SDK envoie les événements aux serveurs AppsFlyer et attend une réponse.
2. Si le SDK ne reçoit pas une réponse 200, l'événement est stocké dans le cache.
3. Une fois que la réponse 200 suivante est reçue, l'événement stocké est renvoyé au serveur.
4. S'il y a plusieurs événements dans le cache, ils sont envoyés au serveur les uns après les autres.

• Événement in-app enregistré avec succès.
• Une erreur s'est produite lors de l'enregistrement d'un événement 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)
             }
           })
        }
            

OneLink détecte le type d'appareil lors du clic et redirige l'utilisateur vers une destination correspondante, par exemple, Google Play, app store iOS, marchés out-of-source ou pages Web.

Le guide sur les redirections OneLink aborde l'implémentation de liens d'attribution multiplate-forme (aucun codage SDK nécessaire). C'est également la base du deep linking.

Le deep linking vous permet d'envoyer les utilisateurs vers des activités spécifiques tout en leur offrant un contenu personnalisé. Cette fonction est particulièrement utile lors de l'exécution de campagnes de retargeting.

Pour configurer le deep linking avec OneLink, un marketeur ayant accès au tableau de bord d'AppsFlyer et un développeur ayant accès à l'app doivent travailler ensemble.

Consultez notre guide de configuration du deep linking avec OneLink.

Le deep linking différé vous permet d'effectuer le deep link des nouveaux utilisateurs et de leur offrir du contenu personnalisé dès le premier lancement de l'app. Il est différent du deep linking habituel pour lequel l'app doit déjà être installée sur l'appareil de l'utilisateur.

Pour configurer le deep linking différé avec OneLink, le développeur doit également avoir accès au tableau de bord d'AppsFlyer.

La configuration du deep linking différé est la même que celle du deep linking. La seule différence est que vous devez implémenter une logique supplémentaire dans l'app de façon à pouvoir effectuer le deep link des utilisateurs et leur offrir du contenu personnalisé après installation et lancement de l'application.

Consultez notre guide sur le deep linking différé pour en savoir plus.

Le SDK vous fournit les données de conversion ou d'engagement après chaque installation ou évènement de deep linking. Vous pouvez utiliser ces données pour personnaliser du contenu et le comportement de l'app par programme.

Pour obtenir des données de deep linking, implémentez la méthode onAppOpenAttribution.

Consultez notre guide sur les données de deep linking pour en savoir plus.

Pour connaître la façon de configurer la mesure des désinstallations, cliquez ici.

Si vous souhaitez recevoir la confirmation que la demande de suivi a bien été reçue par les serveurs AppsFlyer, il est possible d'implémenter le port d'écoute trackAppLaunchWithCompletionHandler. Vous pouvez ensuite appliquer cette logique pour gérer le succès ou l'échec du suivi des lancements d'app.

Exemple d'implémentation

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

L'API setAdditionalData est requise pour l'intégration au niveau SDK avec plusieurs plates-formes partenaires externes, dont Segment, Adobe et Urban Airship.
Utilisez cette API uniquement si l'article d'intégration de la plate-forme indique spécifiquement que l'API setAdditionalData est requise.

Exemple de code 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

Par défaut, il doit s'écouler au moins 5 secondes entre deux lancements d'apps pour que cela soit considéré comme deux sessions distinctes (pour en savoir plus sur le comptage de session).

Utilisez l'API suivante pour définir la durée minimale entre les sessions :

[AppsFlyerTracker sharedTracker].minTimeBetweenSessions = <votre_temps_personnalisé_en_secondes>;

AppsFlyerTracker.shared().minTimeBetweenSessions = <votre_temps_personnalisé_en_secondes>

Le fait de définir une valeur élevée à la durée personnalisée entre les lancements peut avoir un impact négatif sur les API qui s'appuient sur les données de session, comme le deep linking.

Non disponible pour iOS. 

Certains services tiers tels que les prestataires de services de messagerie encapsulent des liens dans des emails avec leurs propres domaines d'enregistrement des clics. Certains vous permettent même de définir vos propres domaines d'enregistrement des clics. Si OneLink est encapsulé dans de tels domaines, il est possible que ses fonctionnalités soient limitées.

Pour résoudre ce problème, vous pouvez utiliser l'API setResolveDeepLinkURLs. Utilisez cette API pour obtenir le OneLink des domaines de clic qui lancent l'application.  Assurez-vous d'appeler cette API avant d'initialiser le SDK.

Par exemple, vous avez trois domaines de clic qui redirigent vers votre OneLink : https://mysubdomain.onelink.me/abCD. Utilisez cette API pour obtenir le OneLink vers lequel vos domaines de clic redirigent. Cette méthode d'API reçoit une liste de domaines que le SDK résout.

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

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

Le code ci-dessus vous permet d'utiliser votre domaine de clic tout en conservant les fonctionnalités de OneLink. Les domaines de clic sont responsables du lancement de l'application. En retour, l'API obtient le OneLink de ces domaines de clic. Vous pouvez ensuite utiliser les données de ce OneLink pour le deep linking et personnaliser le contenu de l'utilisateur.

Avec AppsFlyer, vous pouvez mesurer les notifications push dans le cadre de campagnes de retargeting.

Pour activer cette fonctionnalité, appelez la méthode handlePushNotificationData dans 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)
}

Pour plus d'informations concernant la mesure des notifications push, veuillez lirececi.

Le fait de permettre à vos utilisateurs existants d'inviter leurs amis et contacts en tant que nouveaux utilisateurs de votre application peut être un facteur de croissance important pour votre application. Avec AppsFlyer, vous pouvez attribuer et enregistrer les installations provenant d'invitations utilisateur au sein de votre app.

Pour obtenir plus d'informations, reportez-vous à l'article concernant l'attribution des invitations utilisateur.

L'ID d'appareil unique d'AppsFlyer est créé pour chaque nouvelle installation d’une application. Vous pouvez utiliser cet ID à différentes fins :

• Envoyez des événements in-app serveur à serveur.
• Faites le correspondre avec les enregistrements d'utilisateurs dans vos systèmes en arrière-plan.
• Mappez les entrées lors de la fusion des données de l'API Pull et de l'API Push.

Utiliser l’API suivante pour obtenir l’ID unique AppsFlyer :

NSString *appsflyerId = [AppsFlyerTracker sharedTracker].getAppsFlyerUID;

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

Pour définir votre ID Utilisateur-Client :

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

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

Dans iOS, l'ID utilisateur du client doit être défini à chaque lancement d'app. Nous vous recommandons de définir l'ID utilisateur du client au début du flux de l'app, car il est uniquement associé aux évènements rapportés après son installation :

• Si setCustomerUserId est appelé avant d'appeller startTracking, l'ID utilisateur du client apparaîtra dans les rapports de données brutes, pour les installations et les évènements.
• S'il est défini après, l'ID utilisateur du client est uniquement associé aux évènements enregistrés après la définition de l'ID utilisateur du client.

Obtenir l'ID Utilisateur-Client :

Pour éviter de redéfinir la valeur de l'ID utilisateur du client après le premier lancement et réduire le nombre d'appels à votre serveur afin d'obtenir l'ID utilisateur du client, vous pouvez vérifier si sa valeur est vide ou non en utilisant :

NSString *customerUserID = [AppsFlyerTracker sharedTracker].customerUserID;

let customerUserID = AppsFlyerTracker.shared().customerUserID

Pour plus d’informations sur l’ID Utilisateur-Client, cliquez ici.

Retarder l'initialisation du SDK dans l'attente du customerUserID

Il est possible d'attendre que l'ID utilisateur client soit défini pour lancer l'initialisation du SDK. Ceci est utile si vous souhaitez que les données d'installation et d'événement contiennent votre ID utilisateur client.

Implémentez le code suivant :

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

Pour en savoir plus sur la façon de retarder l'initialisation du SDK jusqu'à ce que l'ID utilisateur du client soit disponible, cliquez ici.

Dans certains cas extrêmes, vous pouvez vouloir arrêter tout suivi SDK en raison de la conformité aux exigences légales et relatives à la vie privée. La propriété isStopTracking le permet. Une fois cette propriété définie sur true, le SDK cesse de fonctionner et ne communique plus avec les serveurs AppsFlyer.

Il existe différents scénarios d'exclusion d'utilisateurs. Nous recommandons vivement de suivre les instructions exactes du scénario qui correspond à votre application.

[AppsFlyerTracker sharedTracker].isStopTracking = true;

AppsFlyerTracker.shared().isStopTracking = true

Dans chaque événement, le SDK peut être réactivé en appelant la même API, avec la valeur false.

Utilisez cette API lors de l'initialisation du SDK pour anonymiser explicitement les installations, les évènements et les sessions d'un utilisateur :

[AppsFlyerTracker sharedTracker].deviceTrackingDisabled = YES;

AppsFlyerTracker.shared().deviceTrackingDisabled = true

Il est possible de reprendre le suivi en paramétrant deviceTrackingDisabled sur false.