Guide de mise en route de Objectif-C

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 dans leurs applications mobiles à l'aide de l'interface Google Tag Manager, sans avoir à recréer ni à renvoyer les binaires d'application sur les plates-formes de téléchargement 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 les éléments suivants :

  • 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, ce qui permet 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 les éléments de l'interface utilisateur

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

  • Google Mobile App Analytics
  • Balise d'appel de fonction personnalisée

Avant de commencer

Avant d'utiliser ce guide de démarrage, vous aurez besoin des éléments suivants :

Si vous ne connaissez pas Google Tag Manager, nous vous recommandons d'en savoir plus sur les conteneurs, les macros et les règles (Centre d'aide) avant de continuer ce guide.

Premiers pas

Cette section guide les développeurs tout au long d'un workflow Tag Manager typique :

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

Ajoutez ensuite les éléments suivants aux bibliothèques liées de la cible de votre application s'ils ne sont pas déjà présents :

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

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

  • libAdIdAccess.a
  • AdSupport.framework

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

Google Tag Manager utilise un conteneur par défaut lors de la première exécution de votre application. Le conteneur par défaut est 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 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 de prise en charge" de votre projet.

Le nom de fichier par défaut doit être 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 vous assurer de respecter la convention d'attribution de noms appropriée.

Bien qu'il soit recommandé d'utiliser le fichier binaire, si votre conteneur ne contient pas de règles ni de balises, vous pouvez choisir d'utiliser une liste de propriétés ou un fichier JSON à la place. 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 l'ID de votre conteneur est GTM-1234, vous pouvez spécifier les valeurs de votre conteneur par défaut dans un fichier de liste de propriétés nommé GTM-1234.plist.

3. Ouvrir un conteneur

Avant de récupérer des valeurs à partir d'un conteneur, votre application doit l'ouvrir. L'ouverture d'un conteneur le charge à partir du disque (si disponible) ou le demande 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.

4. Obtenir les valeurs de configuration à partir du conteneur

Une fois le conteneur ouvert, les valeurs de configuration peuvent être récupérées à l'aide des <type>ForKey: méthodes :

// 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 approprié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. Envoyer des valeurs à la couche de données

La couche de données est une carte qui permet aux informations d'exécution de 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 envoyant des informations sur les vues d'écran dans la carte de la couche de données, vous pouvez configurer des balises dans l'interface Web Tag Manager pour déclencher des pixels de conversion et des appels de suivi en réponse à ces vues d'écran sans avoir à les coder en dur dans votre application.

Les événements sont envoyés à 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 (telles que des balises Google Analytics) à déclencher pour chaque vue d'é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 des vues d'écran spécifiques, en créant une règle où est égal à "openScreen" && est égal à "ConfirmationScreen".

6. Prévisualiser et publier un conteneur

Les valeurs des macros correspondent toujours à la version publiée actuelle. Avant de publier la dernière version d'un conteneur, vous pouvez prévisualiser votre conteneur brouillon.

Pour prévisualiser un conteneur, générez une URL de prévisualisation dans l'interface Web Google Tag Manager en sélectionnant la version du conteneur que vous souhaitez prévisualiser, puis en sélectionnant Preview. Enregistrez cette URL de prévisualisation, car vous en aurez besoin lors d'étapes ultérieures.

Les URL d'aperçu sont disponibles dans la fenêtre d'aperçu de l'interface Web Tag Manager.
Figure 1 : Obtenir une URL de prévisualisation à partir de l' interface Web Tag Manager.

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

Tout d'abord, ajoutez les extraits de code en gras suivants au fichier de 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é des 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
Enregistrez le schéma d'URL d'aperçu du tag manager dans le fichier de liste de propriétés de votre application.
Figure 3 : Ajouter le schéma d'URL de prévisualisation Tag Manager au fichier de liste de propriétés de votre application.

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

Lorsque vous êtes prêt à mettre les valeurs de configuration de votre brouillon à la disposition de 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 ouvrir des conteneurs

Le SDK Google Tag Manager fournit plusieurs méthodes pour ouvrir des conteneurs, ce qui vous permet 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. Elle renvoie immédiatement un conteneur par défaut et charge également de manière asynchrone un conteneur à partir du disque ou du réseau si aucun conteneur enregistré n'existe ou si le conteneur enregistré n'est pas récent (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 savoir quand la requête de chargement commence, si elle échoue ou réussit, et si le conteneur a finalement été chargé à partir du disque ou du réseau.

À moins qu'il ne soit acceptable que votre application utilise les valeurs par défaut, vous devrez utiliser ces rappels pour savoir quand un conteneur enregistré ou réseau a été chargé. Notez que vous ne pourrez pas charger un conteneur enregistré ou réseau s'il s'agit de la première exécution de l'application 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

ValeurDescription
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

ValeurDescription
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 n'est disponible.
kTAGContainerCallbackRefreshFailureNetworkError Une erreur réseau s'est produite.
kTAGContainerCallbackRefreshFailureServerError Une erreur s'est produite sur le serveur.
kTAGContainerCallbackRefreshFailureUnknownError Une erreur non classifiable s'est produite.

Méthodes pour ouvrir des conteneurs non par défaut et récents

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 utilise une énumération demandant un conteneur non 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 date de plus de 12 heures. S'il renvoie un conteneur enregistré obsolète, il effectue é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 est dépassé.

kTAGOpenTypePreferFresh tente de renvoyer un conteneur récent à partir du disque ou du réseau dans le délai spécifié. Il renvoie un conteneur enregistré si aucune connexion réseau n'est disponible et/ou si le délai est dépassé.

Il n'est pas recommandé d'utiliser kTAGOpenTypePreferFresh dans les cas 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 ne sont pas bloquantes. openContainerWithId:tagManager:openType:timeout: renvoie un objet TAGContainerFuture, dont la méthode get renvoie un TAGContainer dès qu'il est chargé (mais qui sera bloqué jusque-là). La méthode openContainerWithId:tagManager:openType:timeout:notifier: utilise un seul rappel, appelé lorsque le conteneur est disponible. Les deux méthodes ont un délai par défaut de 2.0 secondes.

Évaluer les 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, les 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, utilisez la règle suivante :

Une règle est utilisée pour sélectionner les chaînes d'affichage en fonction de la langue de l'appareil au moment de l'exécution : la langue est &quot;es&quot;. Cette règle utilise la macro de langue prédéfinie et un code de langue ISO 639-1 à deux caractères.
Figure 1:Ajouter une règle pour n'activer une macro de collecte de valeurs que pour les appareils configurés pour utiliser l'espagnol.

Vous pouvez ensuite créer des macros de collecte de valeurs pour chaque langue et ajouter cette règle à chaque macro en insérant le code de langue approprié. Lorsque ce conteneur est publié, votre application peut 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 a besoin de 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 par défaut binaires

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

Les fichiers de conteneur binaires peuvent être téléchargés à partir de l'interface Web Google Tag Manager et doivent être ajoutés au bundle principal de votre application en respectant la convention d'attribution de noms suivante : GTM-XXXX, où le nom de fichier représente l'ID de votre 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 des macros d'appel de fonction

Les macros d'appel de fonction sont des macros définies sur la valeur renvoyée d'une fonction spécifiée dans votre application. Les macros d'appel de fonction peuvent être utilisées pour 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 à 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 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 TAGFunctionCallMacroHandler protocole : 
    // 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 du nom de 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 des balises d'appel de fonction

Les balises d'appel de fonction permettent d'exécuter des fonctions pré-enregistrées chaque fois que un événement est envoyé à la couche de données et que les règles de balise sont évaluées sur true.

Pour configurer une balise d'appel de fonction :

  1. Définissez la balise d'appel de fonction dans l'interface Web 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 le interface Web 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 l'âge du conteneur actuel dépasse 12 heures. Pour définir une période d'actualisation personnalisée pour le conteneur, 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éboguer avec Logger

Par défaut, le SDK Google Tag Manager affiche les erreurs et les avertissements dans les journaux. L'activation d'une journalisation plus détaillée peut être utile pour le débogage et est possible en implémentant votre propre Logger, comme dans cet exemple :

// 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 LogLevel du Logger existant à l'aide de 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];