Guida introduttiva a Objective-C

Questa guida per gli sviluppatori descrive come implementare Google Tag Manager in un'applicazione mobile.

Introduzione

Google Tag Manager consente agli sviluppatori di modificare i valori di configurazione nelle loro applicazioni mobile utilizzando l'interfaccia di Google Tag Manager senza dover ricompilare e inviare di nuovo i file binari dell'applicazione ai marketplace di app.

Questa funzionalità è utile per gestire eventuali valori o flag di configurazione nell'applicazione che potresti dover modificare in futuro, tra cui:

  • Varie impostazioni dell'interfaccia utente e stringhe di visualizzazione
  • Dimensioni, località o tipi di annunci pubblicati nell'applicazione
  • Impostazioni di gioco

I valori di configurazione possono anche essere valutati in fase di runtime utilizzando le regole, consentendo configurazioni dinamiche come:

  • Utilizzo delle dimensioni dello schermo per determinare le dimensioni del banner pubblicitario
  • Utilizzo della lingua e della località per configurare gli elementi dell'interfaccia utente

Google Tag Manager consente anche l'implementazione dinamica di tag e pixel di monitoraggio nelle applicazioni. Gli sviluppatori possono inviare eventi importanti a un livello dati e decidere in un secondo momento quali tag o pixel di monitoraggio devono essere attivati. Tag Manager supporta i seguenti tag:

  • Google Mobile App Analytics
  • Tag Chiamata funzione personalizzata

Prima di iniziare

Prima di utilizzare questa guida introduttiva, ti servirà quanto segue:

Se non hai mai utilizzato Google Tag Manager, ti consigliamo di scoprire di più su contenitori, macro e regole (Centro assistenza) prima di continuare con questa guida.

Per iniziare

Questa sezione guiderà gli sviluppatori attraverso un flusso di lavoro tipico di Tag Manager:

  1. Aggiungi l'SDK Google Tag Manager al progetto
  2. Imposta i valori predefiniti del contenitore
  3. Apri il contenitore
  4. Ottieni i valori di configurazione dal contenitore
  5. Invia gli eventi al livello dati
  6. Visualizza l'anteprima e pubblica il contenitore

1. Aggiungere l'SDK Google Tag Manager al progetto

Prima di utilizzare l'SDK Google Tag Manager, devi aggiungere libGoogleAnalyticsServices.a e i file di intestazione di Google Tag Manager (GTM) dalla directory Library del pacchetto SDK al tuo progetto.

Quindi, aggiungi quanto segue alle librerie collegate della destinazione dell'applicazione, se non sono già presenti:

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

Se vuoi che la tua applicazione acceda all'Identifier for Advertisers (IDFA) e al flag di monitoraggio fornito da questo framework tramite le macro dell'SDK Google Tag Manager, devi anche collegare queste librerie aggiuntive:

  • libAdIdAccess.a
  • AdSupport.framework

2. Aggiungere un file contenitore predefinito al progetto

Google Tag Manager utilizza un contenitore predefinito alla prima esecuzione dell'applicazione. Il contenitore predefinito verrà utilizzato finché l'app non sarà in grado di recuperare un nuovo contenitore tramite la rete.

Per scaricare e aggiungere un file binario del contenitore predefinito all'applicazione:

  1. Accedi all'interfaccia web di Google Tag Manager.
  2. Seleziona la versione del contenitore che vuoi scaricare.
  3. Fai clic sul pulsante Scarica per recuperare il file binario del contenitore.
  4. Aggiungi il file binario alla directory principale del progetto e alla cartella "File di supporto" del progetto.

Il nome file predefinito deve essere l'ID contenitore (ad esempio GTM-1234). Dopo aver scaricato il file binario, assicurati di rimuovere il suffisso della versione dal nome file per rispettare la convenzione di denominazione corretta.

Sebbene sia consigliabile utilizzare il file binario, se il contenitore non contiene regole o tag, puoi scegliere di utilizzare un file di elenco di proprietà o JSON. Il file deve trovarsi nel bundle principale e deve rispettare la seguente convenzione di denominazione: <Container_ID>.<plist|json>. Ad esempio, se l'ID contenitore è GTM-1234, puoi specificare i valori del contenitore predefinito in un file di elenco di proprietà denominato GTM-1234.plist.

3. Aprire un contenitore

Prima di recuperare i valori da un contenitore, l'applicazione deve aprire il contenitore. L'apertura di un contenitore lo carica dal disco (se disponibile) o lo richiede dalla rete (se necessario).

Il modo più semplice per aprire un contenitore su iOS è utilizzare openContainerWithId:tagManager:openType:timeout:notifier:, come nell'esempio seguente:

// 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. Ottenere i valori di configurazione dal contenitore

Una volta aperto il contenitore, i valori di configurazione possono essere recuperati utilizzando i <type>ForKey: metodi:

// 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"];

Le richieste effettuate con una chiave inesistente restituiranno un valore predefinito appropriato al tipo richiesto:

// 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. Inviare i valori al livello dati

Il livello dati è una mappa che consente di rendere disponibili le informazioni di runtime sulla tua app, come gli eventi touch o le visualizzazioni di schermate, alle macro e ai tag di Tag Manager in un contenitore.

Ad esempio, inviando informazioni sulle visualizzazioni di schermate alla mappa del livello dati, puoi configurare i tag nell'interfaccia web di Tag Manager in modo che attivino i pixel di conversione e le chiamate di monitoraggio in risposta a queste visualizzazioni di schermate senza doverli codificare in modo hard coded nell'app.

Gli eventi vengono inviati al livello dati utilizzando 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

Nell'interfaccia web, ora puoi creare tag (come i tag Google Analytics) da attivare per ogni visualizzazione di schermata creando questa regola: equals "openScreen". Per passare il nome della schermata a uno di questi tag, crea una macro del livello dati che faccia riferimento alla chiave "screenName" nel livello dati. Puoi anche creare un tag (come un pixel di conversione di Google Ads) da attivare solo per visualizzazioni di schermate specifiche creando una regola in cui equals "openScreen" && equals "ConfirmationScreen".

6. Visualizzare l'anteprima e pubblicare un contenitore

I valori delle macro corrispondono sempre alla versione pubblicata corrente. Prima di pubblicare l'ultima versione di un contenitore, puoi visualizzare l'anteprima della bozza del contenitore.

Per visualizzare l'anteprima di un contenitore, genera un URL di anteprima nell'interfaccia web di Google Tag Manager selezionando la versione del contenitore di cui vuoi visualizzare l'anteprima e poi selezionando Preview. Salva questo URL di anteprima perché ti servirà nei passaggi successivi.

Gli URL di anteprima sono disponibili nella finestra di anteprima dell'interfaccia web di Tag Manager
Figura 1: ottenere un URL di anteprima dall' interfaccia web di Tag Manager.

Per attivare le anteprime dei contenitori, devi aggiungere codice al file di implementazione del delegato dell'app e definire lo schema dell'URL di anteprima di Google Tag Manager nell'elenco delle proprietà del progetto.

Innanzitutto, aggiungi i seguenti snippet di codice in grassetto al file del delegato dell'app:

@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;
}

Quindi, registra il seguente identificatore URL e schema URL nella chiave dei tipi di URL del file di elenco delle proprietà dell'applicazione:

URL identifier: your.package_name
URL scheme: tagmanager.c.your.package.name
Registra lo schema dell'URL di anteprima di Tag Manager nel file di elenco delle proprietà dell'applicazione.
Figura 3: aggiungere lo schema dell'URL di anteprima di Tag Manager al file di elenco delle proprietà dell'applicazione.

Apri il link su un emulatore o un dispositivo fisico per visualizzare l'anteprima della bozza del contenitore nell'app.

Quando la bozza dei valori di configurazione è pronta per essere resa disponibile per la tua applicazione, pubblica il contenitore.

Configurazione avanzata

Google Tag Manager per dispositivi mobili offre una serie di opzioni di configurazione avanzate che consentono di selezionare i valori in base alle condizioni di runtime utilizzando le regole, aggiornare manualmente il contenitore e ottenere opzioni aggiuntive per l'apertura dei contenitori. Le sezioni seguenti descrivono alcune delle configurazioni avanzate più comuni.

Opzioni avanzate per l'apertura dei contenitori

L'SDK Google Tag Manager fornisce diversi metodi per aprire i contenitori che possono darti un maggiore controllo sul processo di caricamento:

openContainerById:callback:

openContainerById:callback: è l'API di livello più basso e più flessibile per l'apertura di un contenitore. Restituisce immediatamente un contenitore predefinito e carica in modo asincrono un contenitore dal disco o dalla rete se non esiste un contenitore salvato o se il contenitore salvato non è aggiornato (più di 12 ore).

@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

Durante il processo di caricamento, openContainerById:callback: emette diversi callback del ciclo di vita in modo che il codice possa scoprire quando inizia la richiesta di caricamento, se e perché non riesce o riesce e se il contenitore è stato caricato dal disco o dalla rete.

A meno che non sia accettabile che l'applicazione utilizzi i valori predefiniti, dovrai utilizzare questi callback per sapere quando è stato caricato un contenitore salvato o di rete. Tieni presente che non potrai caricare un contenitore salvato o di rete se è la prima volta che l'app viene eseguita e non è presente una connessione di rete.

openContainerById:callback: passa i seguenti valori enum come argomenti a questi callback:

RefreshType

ValoreDescrizione
kTAGContainerCallbackRefreshTypeSaved La richiesta di aggiornamento sta caricando un contenitore salvato localmente.
kTAGContainerCallbackRefreshTypeNetwork La richiesta di aggiornamento sta caricando un contenitore tramite la rete.

RefreshFailure

ValoreDescrizione
kTAGContainerCallbackRefreshFailureNoSavedContainer Non è disponibile alcun contenitore salvato.
kTAGContainerCallbackRefreshFailureIoError Un errore di I/O ha impedito l'aggiornamento del contenitore.
kTAGContainerCallbackRefreshFailureNoNetwork Non è disponibile alcuna connessione di rete.
kTAGContainerCallbackRefreshFailureNetworkError Si è verificato un errore di rete.
kTAGContainerCallbackRefreshFailureServerError Si è verificato un errore sul server.
kTAGContainerCallbackRefreshFailureUnknownError Si è verificato un errore che non può essere classificato.

Metodi per l'apertura di contenitori non predefiniti e aggiornati

TAGContainerOpener esegue il wrapping di openContainerById:callback: e fornisce due metodi pratici per l'apertura dei contenitori: openContainerWithId:tagManager:openType:timeout:notifier: e openContainerWithId:tagManager:openType:timeout:.

Ognuno di questi metodi accetta un'enumerazione che richiede un contenitore non predefinito o aggiornato.

kTAGOpenTypePreferNonDefault è consigliato per la maggior parte delle applicazioni e tenta di restituire il primo contenitore non predefinito disponibile entro un determinato periodo di timeout, dal disco o dalla rete, anche se il contenitore ha più di 12 ore. Se restituisce un contenitore salvato non aggiornato, effettuerà anche una richiesta di rete asincrona per uno aggiornato. Quando utilizzi kTAGOpenTypePreferNonDefault, viene restituito un contenitore predefinito se non è disponibile nessun altro contenitore o se viene superato il periodo di timeout.

kTAGOpenTypePreferFresh tenta di restituire un contenitore aggiornato dal disco o dalla rete entro il periodo di timeout specificato. Restituisce un contenitore salvato se non è disponibile una connessione di rete e/o se viene superato il periodo di timeout.

Non è consigliabile utilizzare kTAGOpenTypePreferFresh in posizioni in cui un tempo di richiesta più lungo potrebbe influire notevolmente sull'esperienza utente, ad esempio con i flag dell'interfaccia utente o le stringhe di visualizzazione. Puoi anche utilizzare TAGContainer::refresh in qualsiasi momento per forzare una richiesta di contenitore di rete.

Entrambi questi metodi pratici non sono bloccanti. openContainerWithId:tagManager:openType:timeout: restituisce un TAGContainerFuture oggetto, il cui get metodo restituisce un TAGContainer non appena viene caricato (ma fino ad allora verrà bloccato). Il metodo openContainerWithId:tagManager:openType:timeout:notifier: accetta un singolo callback, chiamato quando il contenitore è disponibile. Entrambi i metodi hanno un periodo di timeout predefinito di 2.0 secondi.

Valutare le macro in fase di runtime utilizzando le regole

I contenitori possono valutare i valori in fase di runtime utilizzando le regole. Le regole possono essere basate su criteri come la lingua del dispositivo, la piattaforma o qualsiasi altro valore macro. Ad esempio, le regole possono essere utilizzate per selezionare una stringa di visualizzazione localizzata in base alla lingua del dispositivo in fase di runtime. Questa operazione può essere configurata utilizzando la seguente regola:

Una regola viene utilizzata per selezionare le stringhe di visualizzazione in base alla lingua del dispositivo in fase di runtime: la lingua è spagnolo. Questa regola utilizza la macro linguistica predefinita e un codice lingua ISO 639-1 di due caratteri.
Figura 1:aggiungere una regola per attivare una macro di raccolta dei valori solo per i dispositivi configurati per utilizzare la lingua spagnola.

Puoi quindi creare macro di raccolta dei valori per ogni lingua e aggiungere questa regola a ogni macro, inserendo il codice lingua appropriato. Quando questo contenitore viene pubblicato, l'applicazione sarà in grado di visualizzare le stringhe di visualizzazione localizzate, a seconda della lingua del dispositivo dell'utente in fase di runtime.

Tieni presente che, se il contenitore predefinito richiede regole, devi utilizzare un file contenitore binario come contenitore predefinito.

Scopri di più sulla configurazione delle regole (Centro assistenza).

File contenitore predefinito binario

I contenitori predefiniti che richiedono regole devono utilizzare un file contenitore binario anziché un file di elenco di proprietà o JSON file come contenitore predefinito. I contenitori binari supportano la determinazione dei valori delle macro in fase di runtime con le regole di Google Tag Manager, mentre i file di elenco di proprietà o JSON non lo fanno.

I file contenitore binari possono essere scaricati dall'interfaccia web di Google Tag Manager e devono essere aggiunti al bundle dell'applicazione principale seguendo questa convenzione di denominazione: GTM-XXXX, dove il nome file rappresenta l'ID contenitore.

Nei casi in cui sono presenti un file di elenco di proprietà e/o un file JSON, nonché un file contenitore binario, l'SDK utilizzerà il file contenitore binario come contenitore predefinito.

Utilizzare le macro Chiamata funzione

Le macro Chiamata funzione sono macro impostate sul valore restituito di una funzione specificata nell'applicazione. Le macro Chiamata funzione possono essere utilizzate per incorporare i valori di runtime con le regole di Google Tag Manager, ad esempio per determinare in fase di runtime il prezzo da mostrare a un utente in base alla lingua e alla valuta configurate di un dispositivo.

Per configurare una macro Chiamata funzione:

  1. Definisci la macro Chiamata funzione nell'interfaccia web di Google Tag Manager. Facoltativamente, gli argomenti possono essere configurati come coppie chiave-valore.
  2. Definisci un gestore che implementi il TAGFunctionCallMacroHandler protocollo: 
    // 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. Registra il gestore utilizzando TAGContainer::registerFunctionCallMacroHandler:forMacro: e il nome della funzione specificato nell'interfaccia di 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

Utilizzare i tag Chiamata funzione

I tag Chiamata funzione consentono di eseguire le funzioni preregistrate ogni volta che un evento viene inviato al livello dati e le regole dei tag restituiscono true.

Per configurare un tag Chiamata funzione:

  1. Definisci il tag Chiamata funzione nell'interfaccia web di Google Tag Manager. Facoltativamente, gli argomenti possono essere configurati come coppie chiave-valore.
  2. Implementa il protocollo 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. Registra il gestore dei tag Chiamata funzione utilizzando il nome del tag configurato nell' Google Tag Manager web interface: 
    //
// 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

Impostare un periodo di aggiornamento personalizzato

L'SDK Google Tag Manager tenterà di recuperare un contenitore aggiornato se l'età del contenitore corrente supera le 12 ore. Per impostare un periodo di aggiornamento del contenitore personalizzato, utilizza NSTimer, come nell' esempio seguente:

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

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

Eseguire il debug con Logger

Per impostazione predefinita, l'SDK Google Tag Manager stampa errori e avvisi nei log. L'attivazione di log più dettagliati può essere utile per il debug ed è possibile implementando il tuo Logger, come in questo esempio:

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

In alternativa, puoi impostare LogLevel del Logger esistente utilizzando TagManager::logger::setLogLevel, come in questo esempio:

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