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 ricreare e inviare nuovamente i programmi binari delle applicazioni ai marketplace delle app.
Questo è utile per gestire i valori o i flag di configurazione nell'applicazione che potresti dover modificare in futuro, ad esempio:
- Varie impostazioni dell'interfaccia utente e stringhe di visualizzazione
- Dimensioni, posizioni o tipi di annunci pubblicati nella tua applicazione
- Impostazioni di gioco
I valori di configurazione possono essere valutati anche in fase di runtime utilizzando regole, abilitando configurazioni dinamiche quali:
- 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 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. Al momento TagManager supporta i seguenti tag:
- Google Analytics per app mobili
- Tag chiamata funzione personalizzata
Prima di iniziare
Prima di utilizzare questa guida introduttiva, devi disporre di:
- Un account Google Tag Manager.
- Una nuova macro Raccolta valori e contenitore di Tag Manager
- Un'applicazione mobile per iOS in cui implementare Google Tag Manager
- Google Analytics Services SDK, che contiene la libreria di Tag Manager.
Se non hai mai utilizzato Google Tag Manager, ti consigliamo di scoprire 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:
- Aggiungere l'SDK di Google Tag Manager al progetto
- Impostare valori predefiniti per il contenitore
- Apri il contenitore
- Recupero dei valori di configurazione dal contenitore
- Eseguire il push degli eventi al livello dati
- Visualizzare l'anteprima del contenitore e pubblicarlo
1. Aggiunta dell'SDK di Google Tag Manager al progetto
Prima di utilizzare l'SDK di Google Tag Manager, devi aggiungere al tuo progetto i file di intestazione
libGoogleAnalyticsServices.a
e i file di intestazione di Google Tag Manager (GTM) dalla directory Library
del pacchetto SDK.
Quindi, aggiungi quanto segue alle librerie collegate della destinazione dell'applicazione se non sono già presenti:
CoreData.frameworkSystemConfiguration.frameworklibz.dyliblibsqlite3.dyliblibGoogleAnalyticsServices.a
Se vuoi che la tua applicazione acceda all'identificatore per gli inserzionisti (IDFA) e al flag di monitoraggio fornito da tale framework tramite le macro dell'SDK di Google Tag Manager, devi collegare anche queste librerie aggiuntive:
libAdIdAccess.aAdSupport.framework
2. Aggiunta di un file contenitore predefinito al progetto
Google Tag Manager utilizza un contenitore predefinito alla prima esecuzione dell'applicazione. Verrà utilizzato il container predefinito finché l'app non sarà in grado di recuperare un nuovo container sulla rete.
Per scaricare e aggiungere un programma binario del container predefinito alla tua applicazione:
- Accedi all'interfaccia web di Google Tag Manager.
- Seleziona la Versione del contenitore da scaricare.
- Fai clic sul pulsante Scarica per recuperare il programma binario del container.
- 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). Una volta scaricato il file binario, assicurati di rimuovere il suffisso di versione dal nome del file per assicurarti di seguire la convenzione di denominazione corretta.
Sebbene sia consigliato utilizzare il file binario, se il container non contiene regole o tag, puoi scegliere di utilizzare un semplice elenco di proprietà o un file 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 predefiniti del contenitore in un file di elenco delle proprietà denominato GTM-1234.plist.
3. Apertura di un container
Prima di recuperare i valori da un container, l'applicazione deve aprire il container. Quando apri un container, questo viene caricato dal disco (se disponibile) o richiesto 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. Recupero dei valori di configurazione dal container
Una volta aperto il container, i valori di configurazione possono essere recuperati utilizzando i metodi <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"];
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 livello dati
Il Datalayer è una mappa che consente di rendere disponibili informazioni di runtime sulla tua app, come eventi di tocco o visualizzazioni di schermata, alle macro e ai tag di Tag Manager in un contenitore.
Ad esempio, inserendo le informazioni sulle visualizzazioni di schermata nella mappa Datalayer, puoi impostare i tag nell'interfaccia web di Tag Manager per attivare i pixel di conversione e monitorare le chiamate in risposta a queste visualizzazioni di schermata, senza doverli codificare nella tua 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 quelli di Google Analytics) da attivare per ogni visualizzazione di schermata creando questa regola: è uguale a "openScreen". Per passare il nome 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 (ad esempio un pixel di conversione di Google Ads) da attivare solo per determinate visualizzazioni di schermata, creando una regola in cui uguale a "openScreen" && è uguale a "ConfirmationScreen".
6. Visualizzazione dell'anteprima e pubblicazione di un contenitore
I valori delle macro corrisponderanno sempre alla versione pubblicata corrente. Prima di pubblicare la versione più recente di un contenitore, puoi visualizzare l'anteprima del contenitore in versione bozza.
Per visualizzare l'anteprima di un contenitore, genera un URL di anteprima nell'interfaccia web di Google Tag Manager selezionando la versione del contenitore da visualizzare in anteprima e poi selezionando Preview. Aspetta a
questo URL di anteprima che ti servirà nei passaggi successivi.
Per attivare le anteprime del contenitore, devi aggiungere codice al file di implementazione del delegato dell'app e definire lo schema URL di anteprima di Google Tag Manager nell'elenco delle proprietà del progetto.
Innanzitutto, aggiungi i seguenti snippet di codice in grassetto al file delegato della tua 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;
}
A questo punto, registra il seguente identificatore e schema URL sotto la 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
Apri il link su un emulatore o su un dispositivo fisico per visualizzare l'anteprima del contenitore della bozza nella tua app.
Quando è tutto pronto per rendere disponibili per la tua applicazione i valori di configurazione della bozza, pubblica il contenitore.
Configurazione avanzata
Google Tag Manager per dispositivi mobili offre una serie di opzioni di configurazione avanzate che consentono di selezionare valori in base alle condizioni di runtime mediante regole, aggiornare manualmente il contenitore e visualizzare opzioni aggiuntive per l'apertura dei contenitori. Le seguenti sezioni descrivono alcune delle configurazioni avanzate più comuni.
Opzioni avanzate per l'apertura dei container
L'SDK di Google Tag Manager offre diversi metodi per aprire i contenitori che possono offrire un maggiore controllo sul processo di caricamento:
openContainerById:callback:
openContainerById:callback: è l'API di livello più basso e più flessibile per aprire un container. Viene restituito immediatamente con un container predefinito e carica anche in modo asincrono un container dal disco o dalla rete se non esiste un container salvato o se il container salvato non è aggiornato (più di 12 ore prima).
@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: invia diversi callback del ciclo di vita in modo che il codice possa scoprire quando inizia la richiesta di caricamento, se e perché ha esito negativo o positivo e se il container è stato caricato dal disco o dalla rete.
A meno che l'applicazione non utilizzi i valori predefiniti, dovrai utilizzare questi callback per sapere quando è stato caricato un container di rete o salvato. 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
| Valore | Descrizione |
|---|---|
kTAGContainerCallbackRefreshTypeSaved
|
La richiesta di aggiornamento sta caricando un contenitore salvato localmente. |
kTAGContainerCallbackRefreshTypeNetwork
|
La richiesta di aggiornamento sta caricando un container sulla rete. |
RefreshFailure
| Valore | Descrizione |
|---|---|
kTAGContainerCallbackRefreshFailureNoSavedContainer
|
Non è disponibile alcun contenitore salvato. |
kTAGContainerCallbackRefreshFailureIoError
|
Un errore 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 classificato. |
Metodi per aprire container non predefiniti e aggiornati
TAGContainerOpener aggrega openContainerById:callback:
e offre due metodi di apertura per aprire i container:
openContainerWithId:tagManager:openType:timeout:notifier: e
openContainerWithId:tagManager:openType:timeout:.
Ciascuno di questi metodi richiede un'enumerazione che richiede un container non predefinito o aggiornato.
kTAGOpenTypePreferNonDefault è consigliato per la maggior parte delle applicazioni e tenta di restituire il primo container non predefinito disponibile entro un determinato periodo di timeout, dal disco o dalla rete, anche se il container risale a più di 12 ore prima. Se restituisce un container salvato inattivo, effettua anche una richiesta di rete asincrona per uno nuovo.
Quando utilizzi kTAGOpenTypePreferNonDefault, verrà restituito un container predefinito se non sono disponibili altri container o se il periodo di timeout è stato superato.
kTAGOpenTypePreferFresh tenta di restituire un container nuovo dal disco o dalla rete entro il periodo di timeout specificato.
Restituisce un contenitore salvato se una connessione di rete non è disponibile e/o se viene superato il periodo di timeout.
Non è consigliabile utilizzare kTAGOpenTypePreferFresh in luoghi in cui un tempo di richiesta più lungo potrebbe influire notevolmente sull'esperienza utente, ad esempio con flag UI o stringhe di visualizzazione. Puoi anche utilizzare
TAGContainer::refresh in qualsiasi momento
per forzare una richiesta del contenitore di rete.
Entrambi questi metodi di praticità non bloccano la migrazione.
openContainerWithId:tagManager:openType:timeout: restituisce un oggetto TAGContainerFuture, il cui metodo get restituisce un oggetto TAGContainer non appena è stato caricato (ma questo bloccherà fino ad allora).
Il metodo openContainerWithId:tagManager:openType:timeout:notifier: prevede un singolo callback,
chiamato quando il container è disponibile.
Entrambi i metodi hanno un periodo di timeout predefinito di 2.0 secondi.
Valutazione delle macro durante il runtime utilizzando le regole
I container possono valutare i valori in fase di runtime utilizzando le regole. Le regole possono basarsi su criteri come la lingua del dispositivo, la piattaforma o qualsiasi altro valore macro. Ad esempio, è possibile utilizzare le regole per selezionare una stringa di visualizzazione localizzata in base alla lingua del dispositivo in fase di runtime. Questa regola può essere configurata utilizzando la regola seguente:
Puoi quindi creare macro di raccolta valori per ogni lingua e aggiungere questa regola a ogni macro, inserendo il codice lingua appropriato. Quando questo container sarà pubblicato, la tua applicazione sarà in grado di visualizzare stringhe di visualizzazione localizzate, 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 di container binario come contenitore predefinito.
Scopri di più sulla configurazione delle regole (Centro assistenza).
File container predefiniti binari
I container predefiniti che richiedono regole devono utilizzare un file container binario anziché un file di elenco delle proprietà o JSON come contenitore predefinito. I container binari offrono supporto per determinare i valori delle macro in fase di runtime con le regole di Google Tag Manager, al contrario dei file elenco proprietà o JSON.
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 siano presenti un file di elenco delle proprietà e/o un file JSON e un file di container binario, l'SDK utilizzerà il file del container binario come container predefinito.
Utilizzo delle macro Chiamata funzione
Le macro di chiamata funzione sono macro impostate sul valore restituito di una funzione specificata nell'applicazione. Le macro delle chiamate di funzione possono essere utilizzate per incorporare i valori di runtime nelle regole di Google Tag Manager, ad esempio per determinare in fase di runtime quale prezzo mostrare a un utente in base alla lingua e alla valuta configurate di un dispositivo.
Per configurare una macro chiamata funzione:
- Definisci la macro chiamata funzione nell'interfaccia web di Google Tag Manager. Gli argomenti possono facoltativamente essere configurati come coppie chiave-valore.
- Definisci un gestore che implementa il protocollo
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 - 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
Utilizzo dei tag di chiamata funzione
I tag di chiamata funzione consentono l'esecuzione di funzioni preregistrate ogni volta che viene eseguito il push di un evento al livello dati e il valore delle regole tag viene valutato a true.
Per configurare un tag di chiamata funzione:
- Definisci il tag di chiamata funzione nell'interfaccia web di Google Tag Manager. Gli argomenti possono facoltativamente essere configurati come coppie chiave-valore.
- 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 - Registra il gestore di tag delle chiamate di funzione utilizzando il nome del tag configurato nell'interfaccia web di 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
Impostazione di un periodo di aggiornamento personalizzato
L'SDK di Google Tag Manager tenterà di recuperare
un contenitore nuovo se l'età del contenitore attuale supera le 12 ore. Per impostare un periodo di aggiornamento dei container 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];
Debug con logger
Per impostazione predefinita, l'SDK di 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 il livello di log del logger esistente utilizzando
TagManager::logger::setLogLevel,
come nell'esempio seguente:
// Change the LogLevel to INFO to enable logging at INFO and higher levels. self.tagManager = [TAGManager instance]; [self.tagManager.logger setLogLevel:kTAGLoggerLogLevelInfo];