Guide de mise en route de Objectif-C

Remarque:Ce guide décrit l'ancienne implémentation de Google Tag Manager dans les applications Android. Les nouveaux utilisateurs doivent utiliser Tag Manager + Firebase pour implémenter Google Tag Manager dans leurs applications iOS.

Ce guide du développeur explique comment implémenter Google Tag Manager dans une application mobile.

Introduction

Google Tag Manager permet aux développeurs de modifier les valeurs de configuration de leurs applications mobiles à l'aide de l'interface Google Tag Manager, sans avoir à recréer et à renvoyer les fichiers binaires de l'application sur les places de marché d'applications.

Cela est utile pour gérer les valeurs ou les indicateurs de configuration de votre application que vous devrez peut-être modifier à l'avenir, y compris:

• Divers paramètres d'interface utilisateur et chaînes d'affichage
• Tailles, emplacements ou types d'annonces diffusées dans votre application
• Paramètres des jeux

Les valeurs de configuration peuvent également être évaluées au moment de l'exécution à l'aide de règles, permettant ainsi des configurations dynamiques telles que:

• Utiliser la taille de l'écran pour déterminer la taille de la bannière publicitaire
• Utiliser la langue et l'emplacement pour configurer des éléments d'interface utilisateur

Google Tag Manager permet également d'implémenter de façon dynamique des balises et des pixels de suivi dans les applications. Les développeurs peuvent transmettre des événements importants dans une couche de données et décider ultérieurement quels pixels ou balises de suivi doivent être déclenchés. Tag Manager accepte actuellement les balises suivantes:

• Google Analytics pour les applications mobiles
• Balise d'appel de fonction personnalisée

Avant de commencer

Avant d'utiliser ce guide de démarrage, assurez-vous de disposer des éléments suivants:

• Un compte Google Tag Manager
• Une nouvelle macro de conteneur et de collection de valeurs Tag Manager
• Une application mobile pour iOS dans laquelle implémenter Google Tag Manager
• Le SDK des services Google Analytics, qui contient la bibliothèque Tag Manager.

Si vous débutez avec Google Tag Manager, nous vous recommandons de vous familiariser avec les conteneurs, les macros et les règles (centre d'aide) avant de poursuivre.

Getting Started

Cette section guide les développeurs tout au long d'un flux de travail Tag Manager classique:

1. Ajouter le SDK Google Tag Manager à votre projet
2. Définir les valeurs de conteneur par défaut
3. Ouvrir le conteneur
4. Obtenir des valeurs de configuration à partir du conteneur
5. Envoyer des événements à la couche de données
6. Prévisualiser et publier le conteneur

1. Ajouter le SDK Google Tag Manager à votre projet

Avant d'utiliser le SDK Google Tag Manager, vous devez ajouter libGoogleAnalyticsServices.a et les fichiers d'en-tête Google Tag Manager (GTM) du répertoire Library du package SDK à votre projet.

Ensuite, ajoutez les éléments suivants aux bibliothèques associées de la cible de votre application si elles ne sont pas déjà présentes:

• CoreData.framework
• SystemConfiguration.framework
• libz.dylib
• libsqlite3.dylib
• libGoogleAnalyticsServices.a

Si vous souhaitez que votre application accède à l'identifiant pour les annonceurs (IDFA) et à l'indicateur de suivi fournis par ce framework via les macros du SDK Google Tag Manager, vous devez également associer ces bibliothèques supplémentaires:

• libAdIdAccess.a
• AdSupport.framework

Remarque: Selon vos paramètres de compilation, l'indicateur d'association -force_load /path/to/libAdIdAccess.a peut être requis.

2. Ajouter un fichier de conteneur par défaut à votre projet

Remarque: Si vous n'avez pas encore configuré votre conteneur dans l'interface Web de Google Tag Manager, revenez à cette étape une fois l'opération terminée.

Google Tag Manager utilise un conteneur par défaut lors de la première exécution de votre application. Le conteneur par défaut sera utilisé jusqu'à ce que l'application puisse récupérer un nouveau conteneur sur le réseau.

Pour télécharger et ajouter un binaire de conteneur par défaut à votre application, procédez comme suit:

1. Connectez-vous à l'interface Web de Google Tag Manager.
2. Sélectionnez la version du conteneur que vous souhaitez télécharger.
3. Cliquez sur le bouton Télécharger pour récupérer le binaire du conteneur.
4. Ajoutez le fichier binaire au répertoire racine de votre projet et au dossier "Fichiers acceptés" dans votre projet.

Le nom de fichier par défaut doit correspondre à l'ID du conteneur (par exemple, GTM-1234). Une fois que vous avez téléchargé le fichier binaire, veillez à supprimer le suffixe de version du nom de fichier pour respecter la convention d'attribution de noms appropriée.

Bien qu'il soit recommandé d'utiliser le fichier binaire, si votre conteneur ne contient ni règles ni balises, vous pouvez opter pour une liste de propriétés ou un fichier JSON simple. Le fichier doit se trouver dans le bundle principal et respecter la convention d'attribution de noms suivante: <Container_ID>.<plist|json>. Par exemple, si votre ID de conteneur est GTM-1234, vous pouvez spécifier les valeurs de conteneur par défaut dans un fichier de liste de propriétés nommé GTM-1234.plist.

Remarque: Si une liste de propriétés et un conteneur JSON par défaut sont présents dans le bundle principal, le SDK utilisera cette liste comme conteneur par défaut.

3. Ouvrir un conteneur

Avant de pouvoir récupérer les valeurs d'un conteneur, votre application doit l'ouvrir. L'ouverture d'un conteneur permet de le charger à partir du disque (si disponible) ou de le demander au réseau (si nécessaire).

Le moyen le plus simple d'ouvrir un conteneur sur iOS consiste à utiliser openContainerWithId:tagManager:openType:timeout:notifier:, comme dans l'exemple suivant:

// MyAppDelegate.h
// This example assumes this file is using ARC.
#import <UIKit/UIKit.h>

@class TAGManager;
@class TAGContainer;

@interface MyAppDelegate : UIResponder <UIApplicationDelegate>

@property (nonatomic, strong) TAGManager *tagManager;
@property (nonatomic, strong) TAGContainer *container;

@end


// MyAppDelegate.m
// This example assumes this file is using ARC.
#import "MyAppDelegate.h"
#import "TAGContainer.h"
#import "TAGContainerOpener.h"
#import "TAGManager.h"

@interface MyAppDelegate ()<TAGContainerOpenerNotifier>
@end

@implementation MyAppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  self.tagManager = [TAGManager instance];

  // Optional: Change the LogLevel to Verbose to enable logging at VERBOSE and higher levels.
  [self.tagManager.logger setLogLevel:kTAGLoggerLogLevelVerbose];

  /*
   * Opens a container.
   *
   * @param containerId The ID of the container to load.
   * @param tagManager The TAGManager instance for getting the container.
   * @param openType The choice of how to open the container.
   * @param timeout The timeout period (default is 2.0 seconds).
   * @param notifier The notifier to inform on container load events.
   */
  [TAGContainerOpener openContainerWithId:@"GTM-XXXX"   // Update with your Container ID.
                               tagManager:self.tagManager
                                 openType:kTAGOpenTypePreferFresh
                                  timeout:nil
                                 notifier:self];

  // Method calls that don't need the container.

  return YES;
}

// TAGContainerOpenerNotifier callback.
- (void)containerAvailable:(TAGContainer *)container {
  // Note that containerAvailable may be called on any thread, so you may need to dispatch back to
  // your main thread.
  dispatch_async(dispatch_get_main_queue(), ^{
    self.container = container;
  });
}

// The rest of your app delegate implementation.

Remarque: Si votre application dépend des valeurs de configuration du conteneur, vous devez afficher un écran de démarrage ou une autre vue intermédiaire jusqu'au chargement du conteneur. Pour ce faire, vous pouvez déplacer le code de chargement du conteneur dans votre contrôleur de vue racine. Votre contrôleur de vue racine peut présenter une vue modale pendant le chargement du conteneur.

4. Obtenir des valeurs de configuration à partir du conteneur

Une fois le conteneur ouvert, vous pouvez récupérer les valeurs de configuration à l'aide des méthodes <type>ForKey::

// Retrieving a configuration value from a Tag Manager Container.

MyAppDelegate *appDelegate = (MyAppDelegate *)[[UIApplication sharedApplication] delegate];
TAGContainer *container = appDelegate.container;

// Get the configuration value by key.
NSString *title = [container stringForKey:@"title_string"];

Les requêtes effectuées avec une clé inexistante renvoient une valeur par défaut adaptée au type demandé:

// Empty keys will return a default value depending on the type requested.

// Key does not exist. An empty string is returned.
NSString subtitle = [container stringForKey:@"Non-existent-key"];
[subtitle isEqualToString:@""]; // Evaluates to true.

5. Transmettre des valeurs à la couche de données

La couche de données est une carte qui permet aux informations d'exécution concernant votre application, telles que les événements tactiles ou les vues d'écran, d'être disponibles pour les macros et les balises Tag Manager dans un conteneur.

Par exemple, en transférant les informations sur les visionnages d'écran dans la carte DataLayer, vous pouvez configurer des balises dans l'interface Web de Tag Manager pour déclencher des pixels de conversion et suivre les appels en réponse à ces vues d'écran, sans avoir à les coder en dur dans votre application.

Les événements sont transmis à la couche de données à l'aide de push:.

//
//  ViewController.m
//  Pushing an openScreen event with a screen name into the data layer.
//

#import "MyAppDelegate.h"
#import "TAGDataLayer.h"
#import "ViewController.h"

@implementation ViewController

- (void)viewDidAppear:(BOOL)animated {
    [super viewDidAppear:animated];

    // The container should have already been opened, otherwise events pushed to
    // the data layer will not fire tags in that container.
    TAGDataLayer *dataLayer = [TAGManager instance].dataLayer;

    [dataLayer push:@{@"event": @"openScreen", @"screenName": @"Home Screen"}];
}

// Rest of the ViewController implementation

@end

Dans l'interface Web, vous pouvez désormais créer des balises (comme des balises Google Analytics) à déclencher pour chaque visionnage de l'écran, en créant la règle suivante : est égal à "openScreen". Pour transmettre le nom de l'écran à l'une de ces balises, créez une macro de couche de données qui référence la clé "screenName" dans la couche de données. Vous pouvez également créer une balise (telle qu'un pixel de conversion Google Ads) à déclencher uniquement pour certains visionnages de l'écran. Pour ce faire, créez une règle où est égal(e) à "openScreen" et à "ConfirmationScreen".

Remarque: Les valeurs et les clés d'événement DataLayer doivent être utilisées de la manière la plus cohérente possible. Ainsi, dans cet exemple, tous les affichages de l'écran utilisent "openScreen" comme valeur d'événement et "screenName" comme clé de nom d'écran. Cela facilite au maximum l'accès à la couche de données et la création de balises supplémentaires à l'avenir.

6. Prévisualiser et publier un conteneur

Les valeurs de la macro correspondront toujours à la version publiée actuellement. Avant de publier la dernière version d'un conteneur, vous pouvez prévisualiser le brouillon de votre conteneur.

Pour prévisualiser un conteneur, générez une URL d'aperçu dans l'interface Web de Google Tag Manager. Pour ce faire, sélectionnez la version du conteneur que vous souhaitez prévisualiser, puis cliquez sur Preview. Conservez cette URL d'aperçu, car vous en aurez besoin dans les prochaines étapes.

Figure 1 : Obtenir une URL d'aperçu à partir de l'interface Web de Tag Manager

Pour activer les aperçus de conteneurs, vous devez ajouter du code au fichier d'implémentation de votre délégué et définir le schéma d'URL d'aperçu Google Tag Manager dans la liste des propriétés de votre projet.

Tout d'abord, ajoutez les extraits de code en gras suivants au fichier délégué de votre application:

@implementation MyAppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {

  self.tagManager = [TAGManager instance];
  
  // Add the code in bold below to preview a Google Tag Manager container.
  // IMPORTANT: This code must be called before the container is opened.
  NSURL *url = [launchOptions valueForKey:UIApplicationLaunchOptionsURLKey];
  if (url != nil) {
    [self.tagManager previewWithUrl:url];
  }
  
  id<TAGContainerFuture> future =
      [TAGContainerOpener openContainerWithId:@"GTM-XXXX"    // Placeholder Container ID.
                                   tagManager:self.tagManager
                                     openType:kTAGOpenTypePreferNonDefault
                                      timeout:nil];

  // The rest of your method implementation.

  self.container = [future get];

  return YES;
}


// Add the code in bold below preview a Google Tag Manager container.
- (BOOL)application:(UIApplication *)application
            openURL:(NSURL *)url
  sourceApplication:(NSString *)sourceApplication
         annotation:(id)annotation {

  if ([self.tagManager previewWithUrl:url]) {
    return YES;
  }

  // Code to handle other urls.
  return NO;
}

Ensuite, enregistrez l'identifiant d'URL et le schéma d'URL suivants sous la clé de types d'URL du fichier de liste de propriétés de votre application:

URL identifier: your.package_name
URL scheme: tagmanager.c.your.package.name

Figure 3 : Ajout du schéma d'URL d'aperçu Tag Manager au fichier de liste de propriétés de votre application

Remarque: your.package.name doit correspondre au nom de l'application utilisée pour générer l'URL d'aperçu (Figure 1).

Ouvrez le lien sur un émulateur ou un appareil physique pour prévisualiser le brouillon de conteneur dans votre application.

Lorsque vous êtes prêt à rendre votre brouillon de valeur de configuration disponible pour votre application, publiez le conteneur.

Configuration avancée

Google Tag Manager pour mobile propose un certain nombre d'options de configuration avancées qui vous permettent de sélectionner des valeurs en fonction des conditions d'exécution à l'aide de règles, d'actualiser manuellement le conteneur et d'obtenir des options supplémentaires pour ouvrir des conteneurs. Les sections suivantes décrivent plusieurs des configurations avancées les plus courantes.

Options avancées pour l'ouverture des conteneurs

Le SDK Google Tag Manager propose plusieurs méthodes pour ouvrir les conteneurs et vous permettre de mieux contrôler le processus de chargement:

openContainerById:callback:

openContainerById:callback: est l'API de niveau le plus bas et la plus flexible pour ouvrir un conteneur. Il s'affiche immédiatement avec un conteneur par défaut et charge également un conteneur de manière asynchrone à partir du disque ou du réseau si aucun conteneur enregistré n'existe ou si le conteneur enregistré n'est pas à jour (plus de 12 heures).

@interface ContainerCallback : NSObject<TAGContainerCallback>

@end

@implementation ContainerCallback

/**
 * Called before the refresh is about to begin.
 *
 * @param container The container being refreshed.
 * @param refreshType The type of refresh which is starting.
 */
- (void)containerRefreshBegin:(TAGContainer *)container
                  refreshType:(TAGContainerCallbackRefreshType)refreshType {
  // Notify UI that container refresh is beginning.
}

/**
 * Called when a refresh has successfully completed for the given refresh type.
 *
 * @param container The container being refreshed.
 * @param refreshType The type of refresh which completed successfully.
 */
- (void)containerRefreshSuccess:(TAGContainer *)container
                    refreshType:(TAGContainerCallbackRefreshType)refreshType {
  // Notify UI that container is available.
}

/**
 * Called when a refresh has failed to complete for the given refresh type.
 *
 * @param container The container being refreshed.
 * @param failure The reason for the refresh failure.
 * @param refreshType The type of refresh which failed.
 */
- (void)containerRefreshFailure:(TAGContainer *)container
                        failure:(TAGContainerCallbackRefreshFailure)failure
                    refreshType:(TAGContainerCallbackRefreshType)refreshType {
  // Notify UI that container request has failed.
}
@end

Tout au long du processus de chargement, openContainerById:callback: émet plusieurs rappels de cycle de vie afin que votre code puisse déterminer quand la requête de chargement commence, si et pourquoi elle échoue ou réussit, et si le conteneur a finalement été chargé à partir du disque ou du réseau.

À moins que votre application ne puisse utiliser les valeurs par défaut, vous devrez utiliser ces rappels pour savoir quand un conteneur réseau ou enregistré est chargé. Notez que vous ne pourrez pas charger un conteneur enregistré ou réseau si c'est la première fois que l'application est exécutée et qu'il n'y a pas de connexion réseau.

openContainerById:callback: transmet les valeurs enum suivantes en tant qu'arguments à ces rappels:

RefreshType

Valeur	Description
kTAGContainerCallbackRefreshTypeSaved	La requête d'actualisation charge un conteneur enregistré localement.
kTAGContainerCallbackRefreshTypeNetwork	La requête d'actualisation charge un conteneur sur le réseau.

RefreshFailure

Valeur	Description
kTAGContainerCallbackRefreshFailureNoSavedContainer	Aucun conteneur enregistré n'est disponible.
kTAGContainerCallbackRefreshFailureIoError	Une erreur d'E/S a empêché l'actualisation du conteneur.
kTAGContainerCallbackRefreshFailureNoNetwork	Aucune connexion réseau disponible.
kTAGContainerCallbackRefreshFailureNetworkError	Une erreur de réseau s'est produite.
kTAGContainerCallbackRefreshFailureServerError	Une erreur s'est produite sur le serveur.
kTAGContainerCallbackRefreshFailureUnknownError	Une erreur qui ne peut pas être classée par catégorie s'est produite.

Méthodes d'ouverture de conteneurs nouveaux et non par défaut

TAGContainerOpener encapsule openContainerById:callback: et fournit deux méthodes pratiques pour ouvrir des conteneurs : openContainerWithId:tagManager:openType:timeout:notifier: et openContainerWithId:tagManager:openType:timeout:.

Chacune de ces méthodes nécessite une énumération demandant un conteneur autre que celui par défaut ou récent.

kTAGOpenTypePreferNonDefault est recommandé pour la plupart des applications et tente de renvoyer le premier conteneur non par défaut disponible dans un délai donné, à partir du disque ou du réseau, même si ce conteneur a plus de 12 heures. S'il renvoie un conteneur enregistré obsolète, il envoie également une requête réseau asynchrone pour en obtenir un nouveau. Lorsque vous utilisez kTAGOpenTypePreferNonDefault, un conteneur par défaut est renvoyé si aucun autre conteneur n'est disponible ou si le délai avant expiration est dépassé.

kTAGOpenTypePreferFresh tente de renvoyer un conteneur récent à partir du disque ou du réseau dans le délai imparti. Elle renvoie un conteneur enregistré si une connexion réseau est indisponible et/ou si le délai avant expiration est dépassé.

Il n'est pas recommandé d'utiliser kTAGOpenTypePreferFresh dans les endroits où un délai de requête plus long peut affecter sensiblement l'expérience utilisateur, par exemple avec des indicateurs d'interface utilisateur ou des chaînes d'affichage. Vous pouvez également utiliser TAGContainer::refresh à tout moment pour forcer une requête de conteneur réseau.

Ces deux méthodes pratiques sont non bloquantes. openContainerWithId:tagManager:openType:timeout: renvoie un objet TAGContainerFuture, dont la méthode get renvoie un TAGContainer dès qu'il est chargé (mais cela bloquera jusqu'à cette date). La méthode openContainerWithId:tagManager:openType:timeout:notifier: n'utilise qu'un seul rappel, appelé lorsque le conteneur est disponible. Les deux méthodes ont un délai avant expiration par défaut de 2.0 secondes.

Évaluer des macros au moment de l'exécution à l'aide de règles

Les conteneurs peuvent évaluer des valeurs au moment de l'exécution à l'aide de règles. Les règles peuvent être basées sur des critères tels que la langue de l'appareil, la plate-forme ou toute autre valeur de macro. Par exemple, des règles peuvent être utilisées pour sélectionner une chaîne d'affichage localisée en fonction de la langue de l'appareil au moment de l'exécution. Pour ce faire, vous pouvez utiliser la règle suivante:

Figure 1:Ajout d'une règle permettant d'activer une macro de collecte de valeurs uniquement pour les appareils configurés pour utiliser l'espagnol.

Vous pouvez ensuite créer des macros de collection de valeurs pour chaque langage, puis ajouter cette règle à chaque macro, en insérant le code de langue approprié. Une fois ce conteneur publié, votre application pourra afficher des chaînes d'affichage localisées, en fonction de la langue de l'appareil de l'utilisateur au moment de l'exécution.

Notez que si votre conteneur par défaut nécessite des règles, vous devez utiliser un fichier de conteneur binaire comme conteneur par défaut.

En savoir plus sur la configuration des règles (centre d'aide)

Fichiers de conteneur binaires par défaut

Les conteneurs par défaut nécessitant des règles doivent utiliser un fichier de conteneur binaire au lieu d'un fichier de liste de propriétés ou d'un fichier JSON comme conteneur par défaut. Les conteneurs binaires permettent de déterminer les valeurs des macros au moment de l'exécution à l'aide de règles Google Tag Manager, contrairement aux listes de propriétés ou aux fichiers JSON.

Vous pouvez télécharger les fichiers de conteneurs binaires à partir de l'interface Web de Google Tag Manager et les ajouter à votre app bundle principal en respectant la convention d'attribution de noms suivante : GTM-XXXX, où le nom de fichier représente votre ID de conteneur.

Si un fichier de liste de propriétés et/ou un fichier JSON ainsi qu'un fichier de conteneur binaire sont présents, le SDK utilise le fichier de conteneur binaire comme conteneur par défaut.

Utiliser les macros d'appel de fonction

Les macros d'appel de fonction sont des macros définies sur la valeur renvoyée par une fonction spécifiée dans votre application. Les macros d'appel de fonctions permettent d'intégrer des valeurs d'exécution à vos règles Google Tag Manager, par exemple pour déterminer au moment de l'exécution le prix à afficher pour un utilisateur en fonction de la langue et de la devise configurées sur un appareil.

Pour configurer une macro d'appel de fonction:

1. Définissez la macro d'appel de fonction dans l'interface Web de Google Tag Manager. Les arguments peuvent éventuellement être configurés en tant que paires clé/valeur.
2. Définissez un gestionnaire qui implémente le protocole TAGFunctionCallMacroHandler :

   // MyFunctionCallMacroHandler.h
   #import "TAGContainer.h"
   
   // The function name field of the macro, as defined in the Google Tag Manager
   // web interface.
   extern NSString *const kMyMacroFunctionName;
   
   @interface MyFunctionCallMacroHandler : NSObject<TAGFunctionCallMacroHandler>
   
   @end
   
   
   // MyFunctionCallMacroHandler.m
   #import "MyFunctionCallMacroHandler.h"
   
   // Corresponds to the function name field in the Google Tag Manager interface.
   NSString *const kMyMacroFunctionName = @"myConfiguredFunctionName";
   
   @implementation MacroHandler
   
   - (id)valueForMacro:(NSString *)functionName parameters:(NSDictionary *)parameters {
   
     if ([functionName isEqualToString:kMyMacroFunctionName]) {
       // Process and return the calculated value of this macro accordingly.
       return macro_value;
     }
     return nil;
   }
   
   @end
   

3. Enregistrez le gestionnaire à l'aide de TAGContainer::registerFunctionCallMacroHandler:forMacro: et le nom de la fonction spécifié dans l'interface Google Tag Manager:

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

@interface MyAppDelegate : UIResponder <UIApplicationDelegate>

@end


//
// MyAppDelegate.m
//
#import "MyAppDelegate.h"
#import "MyFunctionCallMacroHandler.h"
#import "TAGContainer.h"
#import "TAGContainerOpener.h"
#import "TAGManager.h"

@implementation MyAppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
  // Open the container.
  id<TAGContainerFuture> future =
      [TAGContainerOpener openContainerWithId:@"GTM-XXXX"    // Placeholder Container ID.
                                   tagManager:[TAGManager instance]
                                     openType:kTAGOpenTypePreferNonDefault
                                      timeout:nil];

  // Method calls that don't need the container.

  self.container = [future get];

  // Register a function call macro handler using the macro name defined
  // in the Google Tag Manager web interface.
  [self.container registerFunctionCallMacroHandler:[[MyFunctionCallMacroHandler alloc] init]
                                          forMacro:kMyMacroFunctionName];
}

@end

Utiliser les balises d'appel de fonction

Les tags d'appel de fonctions permettent d'exécuter des fonctions préenregistrées chaque fois qu'un événement est transmis à la couche de données et que les règles de tag donnent la valeur true.

Pour configurer une balise d'appel de fonction:

1. Définissez la balise d'appel de fonction dans l'interface Web de Google Tag Manager. Les arguments peuvent éventuellement être configurés en tant que paires clé/valeur.
2. Implémentez le protocole TAGFunctionCallTagHandler :

   //
   // MyFunctionCallTagHandler.h
   //
   
   #import "TAGContainer.h"
   
   extern NSString *const kMyTagFunctionName;
   
   @interface MyFunctionCallTagHandler : NSObject<TAGFunctionCallTagHandler>
   
   @end
   
   
   //
   // MyFunctionCallTagHandler.m
   //
   
   // Corresponds to the function name field in the Google Tag Manager interface.
   NSString *const kMyTagFunctionName = @"myConfiguredFunctionName";
   
   @implementation MyFunctionCallTagHandler
   
   /**
    * This method will be called when any custom tag's rule(s) evaluate to true and
    * should check the functionName and process accordingly.
    *
    * @param functionName corresponds to the function name field, not tag
    *     name field, defined in the Google Tag Manager web interface.
    * @param parameters An optional map of parameters as defined in the Google
    *     Tag Manager web interface.
    */
   - (void)execute:(NSString *)functionName parameters:(NSDictionary *)parameters {
   
     if ([functionName isEqualToString:kMyTagFunctionName]) {
       // Process accordingly.
     }
   }
   @end
   

3. Enregistrez le gestionnaire de balises d'appel de fonction à l'aide du nom de balise configuré dans l'interface Web de Google Tag Manager:

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

@interface MyAppDelegate : UIResponder <UIApplicationDelegate>

@end


//
// MyAppDelegate.m
//
#import "MyAppDelegate.h"
#import "MyFunctionCallTagHandler.h"
#import "TAGContainer.h"
#import "TAGContainerOpener.h"
#import "TAGManager.h"

@implementation MyAppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {

  // Open the container.
  id<TAGContainerFuture> future =
      [TAGContainerOpener openContainerWithId:@"GTM-XXXX"    // Placeholder Container ID.
                                   tagManager:[TAGManager instance]
                                     openType:kTAGOpenTypePreferNonDefault
                                      timeout:nil];

  // Method calls that don't need the container.

  self.container = [future get];

  // Register a function call tag handler using the function name of the tag as
  // defined in the Google Tag Manager web interface.
  [self.container registerFunctionCallTagHandler:[[MyFunctionCallTagHandler alloc] init]
                                          forTag:kMyTagFunctionName];
}
@end

Définir une période d'actualisation personnalisée

Le SDK Google Tag Manager tente de récupérer un nouveau conteneur si son âge actuel dépasse 12 heures. Pour définir une période d'actualisation du conteneur personnalisé, utilisez NSTimer, comme dans l'exemple suivant:

- (void)refreshContainer:(NSTimer *)timer {
  [self.container refresh];
}

self.refreshTimer = [NSTimer scheduledTimerWithTimeInterval:<refresh_interval>
                                                     target:self
                                                   selector:@selector(refreshContainer:)
                                                   userInfo:nil
                                                    repeats:YES];

Débogage avec Enregistreur

Le SDK Google Tag Manager affiche par défaut les erreurs et les avertissements dans les journaux. L'activation de la journalisation détaillée peut être utile pour le débogage. Vous pouvez l'implémenter en implémentant votre propre Logger, comme dans l'exemple suivant:

// MyAppDelegate.h
// This example assumes this file is using ARC.
// This Logger class will print out not just errors and warnings (as the default
// logger does), but also info, debug, and verbose messages.
@interface MyLogger: NSObject<TAGLogger>
@end

@implementation MyLogger
- (void)error:(NSString *)message {
  NSLog(@"Error: %@", message);
}

- (void)warning:(NSString *)message {
  NSLog(@"Warning: %@", message);
}

- (void)info:(NSString *)message {
  NSLog(@"Info: %@", message);
}

- (void)debug:(NSString *)message {
  NSLog(@"Debug: %@", message);
}

- (void)verbose:(NSString *)message {
  NSLog(@"Verbose: %@", message);
}
@end

// MyAppDelegate.m
// This example assumes this file is using ARC.
@implementation MyAppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  self.tagManager = [TAGManager instance];
  
  self.tagManager.logger = [[MyLogger alloc] init];
  
  // Rest of Tag Manager and method implementation.
  return YES;
}
// Rest of app delegate implementation.
@end

Vous pouvez également définir le niveau de journalisation du journal de bord existant en utilisant TagManager::logger::setLogLevel, comme dans cet exemple :

// Change the LogLevel to INFO to enable logging at INFO and higher levels.
self.tagManager = [TAGManager instance];
[self.tagManager.logger setLogLevel:kTAGLoggerLogLevelInfo];