Guida introduttiva a Objective-C

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

Introduzione

Google Tag Manager consente agli sviluppatori di modificare la configurazione nelle proprie app mobile utilizzando Google Tag Manager senza dover ricreare e inviare nuovamente i file binari delle applicazioni all'app marketplace.

È utile per gestire i valori di configurazione o ai flag nella tua 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 nella tua applicazione.
  • Impostazioni di gioco

I valori di configurazione possono essere valutati anche in fase di runtime tramite regole, l'attivazione di configurazioni dinamiche, ad esempio:

  • Utilizzare le dimensioni dello schermo per determinare le dimensioni del banner dell'annuncio
  • Utilizzo della lingua e della posizione per configurare gli elementi dell'interfaccia utente

Google TagManager consente inoltre l'implementazione dinamica dei tag di monitoraggio e pixel nelle applicazioni. Gli sviluppatori possono eseguire il push di eventi importanti e decidi in seguito quali tag o pixel di monitoraggio attivare. Al momento TagManager supporta i seguenti tag:

  • Google Analytics per app mobile
  • Tag chiamata funzione personalizzata

Prima di iniziare

Prima di utilizzare questa guida introduttiva, avrai bisogno di quanto segue:

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

Per iniziare

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

  1. Aggiungi l'SDK Google Tag Manager al progetto
  2. Impostazione dei valori predefiniti del contenitore
  3. Apri il container
  4. Recuperare i valori di configurazione dal container
  5. Eseguire il push degli eventi al livello dati
  6. Anteprima e Pubblica il container

1. Aggiunta dell'SDK di Google Tag Manager al progetto

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

Poi, 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 desideri che la tua applicazione acceda all'identificatore della inserzionisti (IDFA) e il flag di monitoraggio fornito da tale framework tramite Macro dell'SDK di Google Tag Manager, dovrai collegare anche queste librerie aggiuntive:

  • libAdIdAccess.a
  • AdSupport.framework
di Gemini Advanced.

2. Aggiunta di un file contenitore predefinito al progetto

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

Per scaricare e aggiungere un programma binario del container predefinito alla tua applicazione, segui questi passaggi:

  1. Accedi all'interfaccia web di Google Tag Manager.
  2. Seleziona la versione del contenitore da scaricare.
  3. Fai clic sul pulsante Scarica per recuperare il programma binario del container.
  4. Aggiungi il file binario a alla directory radice del progetto e alla cartella "File di supporto" nel tuo 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 del file per assicurarti di seguire la convenzione di denominazione corretta.

Sebbene sia consigliabile utilizzare il file binario, se il container non contiene regole o tag, puoi scegliere di usare una semplice elenco delle proprietà o JSON . Il file deve trovarsi nel bundle principale e deve seguire questa convenzione di denominazione: <Container_ID>.<plist|json>. Ad esempio, se il tuo ID contenitore è GTM-1234, puoi specificare i valori del contenitore predefiniti in un file di elenco di proprietà denominato GTM-1234.plist.

3. Apertura di un container

Prima di recuperare i valori da un container, l'applicazione deve aprire nel container. L'apertura di un container lo caricherà dal disco (se disponibile) oppure lo richiederà alla rete (se necessario).

Il modo più semplice per aprire un container 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. Recupero dei valori di configurazione dal container

Una volta aperto il contenitore, puoi recuperare i valori di configurazione utilizzando il <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. Invio dei valori al strato dati

Il strato dati è una mappa che consente le informazioni di runtime dell'app, ad esempio eventi o visualizzazioni di schermata di Tag Manager in un containerizzato.

Ad esempio, trasferendo le informazioni sulle visualizzazioni di schermata alla mappa Livelli dati, puoi configurare i tag nell'interfaccia web di Tag Manager per attivare i pixel di conversione e il monitoraggio delle chiamate in risposta alle visualizzazioni di schermata senza la necessità codificali nella tua app.

Gli eventi vengono inviati al strato 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

Ora nell'interfaccia web puoi creare tag, ad esempio quelli di Google Analytics. per l'attivazione per ogni visualizzazione di schermata mediante la creazione di questa regola: è uguale a "openScreen". Trasmettere il nome della schermata a uno di questi tag, crea una macro livello dati che faccia riferimento a "screenName" nel livello dati. Puoi anche creare un tag (ad esempio un pixel di conversione di Google Ads) affinché si attivi solo per visualizzazioni di schermata specifiche, creazione di una regola in cui è uguale a "openScreen" && è uguale a "ConfirmationScreen".

6. Anteprima e Pubblicazione di un container

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

Per visualizzare l'anteprima di un contenitore, genera un URL di anteprima nella Interfaccia web di Tag Manager selezionando la versione del contenitore vuoi visualizzare l'anteprima, poi seleziona Preview. Attendi questo URL di anteprima perché ne avrai bisogno nei passaggi successivi.

Gli URL di anteprima sono disponibili nella finestra di anteprima del tag Interfaccia web del gestore
Figura 1: ottenimento di un URL di anteprima dalla Interfaccia web di Tag Manager.

Per attivare le anteprime dei contenitori, devi aggiungere codice alla tua app delegare il file di implementazione e definire l'URL di anteprima di Google Tag Manager nell'elenco delle proprietà del progetto.

Innanzitutto, aggiungi i seguenti snippet di codice in grassetto al file di delega 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 e lo schema URL nel campo 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 URL di anteprima di Tag Manager nel di elenco delle proprietà.
Figura 3: aggiunta dello schema URL di anteprima di Tag Manager al file di elenco delle proprietà dell'applicazione.
di Gemini Advanced.

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

Quando è tutto pronto per rendere disponibili i valori della bozza di configurazione applicazione, pubblica il contenitore.

Configurazione avanzata

Google Tag Manager per dispositivi mobili offre diverse che consentono di selezionare i valori in base alle condizioni di runtime utilizzando aggiornare manualmente il container e visualizzare opzioni aggiuntive per l'apertura containerizzati. Le seguenti sezioni descrivono alcuni dei metodi avanzati più comuni configurazioni.

Opzioni avanzate per l'apertura di container

L'SDK di Google Tag Manager offre diversi metodi per aprire di container che possono darti maggiore controllo sul processo di caricamento:

openContainerById:callback:

openContainerById:callback: è l'API di livello più basso e più flessibile per aprire una containerizzato. Viene restituito immediatamente con un container predefinito carica in modo asincrono anche un container dal disco o dalla rete se non vengono salvati esistente o se il contenitore salvato non è aggiornato (più di 12 ore fa).

@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 la procedura di caricamento, sono stati riscontrati openContainerById:callback: problemi diversi callback del ciclo di vita in modo che il codice possa scoprire quando una richiesta di caricamento iniziale, se e perché ha esito negativo o ha esito positivo e se il container è stato caricato dal disco o dalla rete.

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

openContainerById:callback: supera il seguente enum come argomenti per queste chiamate:

RefreshType

ValoreDescrizione
kTAGContainerCallbackRefreshTypeSaved La richiesta di aggiornamento sta caricando un container salvato localmente.
kTAGContainerCallbackRefreshTypeNetwork La richiesta di aggiornamento sta caricando un container sulla rete.

RefreshFailure

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

Metodi per l'apertura di container non predefiniti e nuovi

TAGContainerOpener aggrega openContainerById:callback: e offre due metodi pratici per aprire i container: openContainerWithId:tagManager:openType:timeout:notifier: e openContainerWithId:tagManager:openType:timeout:.

Ognuno di questi metodi richiede un'enumerazione che richiede un valore non predefinito nuovo container.

kTAGOpenTypePreferNonDefault è consigliato per la maggior parte delle applicazioni tenta di restituire il primo container non predefinito disponibile all'interno di un determinato periodo di timeout, dal disco o dalla rete, anche se il container è maggiore più di 12 ore fa. Se restituisce un container salvato inattivo, una richiesta di rete asincrona per una nuova query. Quando utilizzi kTAGOpenTypePreferNonDefault, un valore predefinito verrà restituito se non sono disponibili altri container o se il periodo di timeout è superato.

kTAGOpenTypePreferFresh tenta di restituire un container nuovo da il disco o la rete entro un determinato periodo di timeout. Restituisce un container salvato se una rete la connessione non è disponibile e/o il periodo di timeout è stato superato.

Non è consigliabile utilizzare kTAGOpenTypePreferFresh in cui una richiesta più lunga può influire notevolmente sull'esperienza utente, ad esempio con flag UI o stringhe di visualizzazione. Puoi inoltre utilizzare TAGContainer::refresh in qualsiasi momento per forzare una richiesta di container di rete.

Entrambi questi metodi non comportano il blocco. openContainerWithId:tagManager:openType:timeout: restituisce un Oggetto TAGContainerFuture, il cui metodo get restituisce un TAGContainer non appena viene caricato (che fino ad allora verrà bloccato). Il metodo openContainerWithId:tagManager:openType:timeout:notifier: richiede un singolo callback, quando il container è disponibile. Entrambi i metodi hanno un periodo di timeout predefinito 2.0 secondi.

Valutazione delle macro in fase di runtime mediante regole

I container possono valutare i valori in fase di runtime tramite le regole. Le regole possono essere basate in base a criteri come lingua del dispositivo, piattaforma o qualsiasi altro valore macro. Per esempio, è possibile utilizzare le regole per selezionare una stringa di visualizzazione localizzata in base al lingua del dispositivo in fase di runtime. Può essere configurato utilizzando regola seguente:

Una regola viene utilizzata per selezionare le stringhe di visualizzazione in base alla lingua del dispositivo in runtime: il linguaggio è uguale a es. Questa regola utilizza il linguaggio predefinito e un codice lingua ISO 639-1 a due caratteri.
Figura 1: aggiunta di una regola per attivare una macro raccolta valori solo per i dispositivi configurate per l'uso della lingua spagnola.

Puoi quindi creare macro per la raccolta dei valori per ogni lingua e aggiungere a ogni macro, inserendo il codice lingua appropriato. Quando il container è stata pubblicata, la tua applicazione potrà mostrare una visualizzazione localizzata stringhe, a seconda della lingua del dispositivo dell'utente in fase di runtime.

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

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

File container binari predefiniti

I container predefiniti che richiedono regole devono utilizzare un file container binario anziché un file di elenco delle proprietà o JSON come container predefinito. I container binari offrono supporto per determinare i valori delle macro in fase di esecuzione con le regole di Google Tag Manager, mentre elenco delle proprietà o JSON al contrario.

I file contenitore binari possono essere scaricati dal sito web di Google Tag Manager dell'interfaccia utente devono essere aggiunti al bundle di applicazioni principale seguendo questa convenzione di denominazione: GTM-XXXX, dove il nome del file rappresenta ID contenitore.

Nei casi in cui un file di elenco delle proprietà e/o un file JSON e un file del container binario, l'SDK utilizzerà il container binario predefinito è il container.

Utilizzo delle macro chiamata funzione

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

Per configurare una macro di chiamata di funzione:

  1. Definisci la macro di chiamata di funzione nell'interfaccia web di Google Tag Manager. Gli argomenti possono essere configurati facoltativamente come coppie chiave-valore.
  2. Definisci un gestore che implementa 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::registerFunctionCallMacroprov:forMacro: e il nome della funzione specificate nell'interfaccia di Google Tag Manager:
    4. //
// 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

Utilizzo dei tag di chiamata di funzione

I tag di chiamata di funzione consentono l'esecuzione di funzioni preregistrate ogni volta viene inviato un evento al livello dati e alle regole dei tag restituisce true.

Per configurare un tag di chiamata di funzione:

  1. Definisci il tag di chiamata di funzione nell'interfaccia web di Google Tag Manager. Gli argomenti possono essere configurati facoltativamente 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. Registrare il gestore di tag di chiamata di funzione utilizzando il nome tag configurato nel Interfaccia web di Google Tag Manager:
    4. //
// 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

Impostazione di un periodo di aggiornamento personalizzato

L'SDK di Google Tag Manager tenterà di recuperare un nuovo contenitore se l'attuale età del contenitore supera le 12 ore. Per impostare un il periodo di aggiornamento del container personalizzato, NSTimer, come negli 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];

Debug con Logger

Per impostazione predefinita, l'SDK di Google Tag Manager stampa errori e avvisi nei log. L'attivazione di un logging più dettagliato può essere utile per il debug e può essere 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 il valore 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];