En esta guía para desarrolladores, se describe cómo implementar Google Tag Manager en una aplicación para dispositivos móviles.
Introducción
Google Tag Manager permite que los desarrolladores cambien los valores de configuración en sus aplicaciones para dispositivos móviles con la interfaz de Google Tag Manager sin tener que volver a compilar y enviar los objetos binarios de la aplicación a los mercados de aplicaciones.
Esto es útil para administrar cualquier valor de configuración o marca en tu aplicación que debas cambiar en el futuro, incluidos los siguientes:
- Varios parámetros de configuración de la IU y cadenas de visualización
- Los tamaños, las ubicaciones o los tipos de anuncios que se publican en tu aplicación
- Configuración de juegos
Los valores de configuración también se pueden evaluar en el entorno de ejecución con reglas, lo que habilita configuraciones dinámicas como las siguientes:
- Cómo usar el tamaño de la pantalla para determinar el tamaño del banner de anuncio
- Cómo usar el idioma y la ubicación para configurar los elementos de la IU
Google Tag Manager también permite la implementación dinámica de etiquetas y píxeles de seguimiento en las aplicaciones. Los desarrolladores pueden enviar eventos importantes a una capa de datos y decidir más tarde qué etiquetas o píxeles de seguimiento se deben activar. TagManager admite las siguientes etiquetas:
- Google Analytics para aplicaciones móviles
- Etiqueta de llamada a función personalizada
Antes de comenzar
Antes de usar esta guía de introducción, necesitarás lo siguiente:
- Una cuenta de Google Tag Manager
- Un nuevo contenedor de Tag Manager y una macro de recopilación de valores
- Una aplicación para dispositivos móviles iOS en la que se implementará Google Tag Manager
- El SDK de servicios de Google Analytics, que contiene la biblioteca de Tag Manager
Si es la primera vez que usas Google Tag Manager, te recomendamos que obtengas más información sobre los contenedores, las macros y las reglas (Centro de ayuda) antes de continuar con esta guía.
Comenzar
En esta sección, se guiará a los desarrolladores a través de un flujo de trabajo típico de Tag Manager:
- Agrega el SDK de Google Tag Manager a tu proyecto
- Establece los valores predeterminados del contenedor
- Abre el contenedor
- Obtén valores de configuración del contenedor
- Envía eventos a la capa de datos
- Obtén una vista previa del contenedor y publícalo
1. Agrega el SDK de Google Tag Manager a tu proyecto
Antes de usar el SDK de Google Tag Manager, deberás agregar
libGoogleAnalyticsServices.a
y los archivos de encabezado de Google Tag Manager (GTM) del directorio Library
del paquete del SDK a tu proyecto.
Luego, agrega lo siguiente a las bibliotecas vinculadas de tu destino de aplicación si aún no están presentes:
CoreData.frameworkSystemConfiguration.frameworklibz.dyliblibsqlite3.dyliblibGoogleAnalyticsServices.a
Si quieres que tu aplicación acceda al identificador para anunciantes (IDFA) y al indicador de seguimiento que proporciona ese framework a través de las macros del SDK de Google Tag Manager, también deberás vincular estas bibliotecas adicionales:
libAdIdAccess.aAdSupport.framework
2. Agrega un archivo de contenedor predeterminado a tu proyecto
Google Tag Manager usa un contenedor predeterminado en la primera ejecución de tu aplicación. El contenedor predeterminado se usará hasta que la app pueda recuperar un contenedor nuevo a través de la red.
Para descargar y agregar un objeto binario de contenedor predeterminado a tu aplicación, sigue estos pasos:
- Accede a la interfaz web de Google Tag Manager.
- Selecciona la versión del contenedor que quieres descargar.
- Haz clic en el botón Descargar para recuperar el objeto binario del contenedor.
- Agrega el archivo binario al directorio raíz de tu proyecto y a la carpeta "Supporting Files" de tu proyecto.
El nombre de archivo predeterminado debe ser el ID del contenedor (por ejemplo, GTM-1234). Una vez que hayas descargado el archivo binario, asegúrate de quitar el sufijo de la versión del nombre de archivo para asegurarte de seguir la convención de nombres correcta.
Aunque se recomienda usar el archivo binario, si tu contenedor no tiene reglas ni etiquetas,
puedes optar por usar una lista de propiedades o un archivo JSON. El archivo debe estar ubicado en el paquete principal y debe seguir
esta convención de nombres: <Container_ID>.<plist|json>.
Por ejemplo, si el ID de tu contenedor es GTM-1234, puedes especificar los valores predeterminados del contenedor en un archivo de lista de propiedades llamado GTM-1234.plist.
3. Cómo abrir un contenedor
Antes de recuperar valores de un contenedor, tu aplicación debe abrirlo. Cuando se abre un contenedor, se carga desde el disco (si está disponible) o se solicita desde la red (si es necesario).
La forma más sencilla de abrir un contenedor en iOS es usar
openContainerWithId:tagManager:openType:timeout:notifier:, como en el siguiente ejemplo:
// 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. Obtén valores de configuración del contenedor
Una vez que se abre el contenedor, los valores de configuración se pueden recuperar con
los métodos <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"];
Las solicitudes realizadas con una clave inexistente devolverán un valor predeterminado adecuado para el tipo solicitado:
// 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. Cómo enviar valores a la capa de datos
DataLayer es un mapa que permite que la información del tiempo de ejecución de tu app, como los eventos táctiles o las vistas de pantalla, esté disponible para las macros y las etiquetas de Tag Manager en un contenedor.
Por ejemplo, si envías información sobre las vistas de pantalla al mapa de DataLayer, puedes configurar etiquetas en la interfaz web de Tag Manager para activar píxeles de conversiones y llamadas de seguimiento en respuesta a esas vistas de pantalla sin necesidad de codificarlas en tu app.
Los eventos se envían a la capa de datos con 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
En la interfaz web, ahora puedes crear etiquetas (como las de Google Analytics) para que se activen en cada vista de pantalla con la siguiente regla: es igual a "openScreen". Para pasar el nombre de la pantalla a una de estas etiquetas, crea una macro de capa de datos que haga referencia a la clave "screenName" en la capa de datos. También puedes crear una etiqueta (como un píxel de conversiones de Google Ads) para que se active solo en vistas de pantalla específicas. Para ello, crea una regla en la que sea igual a "openScreen" && sea igual a "ConfirmationScreen".
6. Cómo obtener una vista previa de un contenedor y publicarlo
Los valores de las macros siempre corresponderán a la versión publicada actual. Antes de publicar la versión más reciente de un contenedor, puedes obtener una vista previa de tu contenedor en borrador.
Para obtener una vista previa de un contenedor, genera una URL de vista previa en la interfaz web de Google Tag Manager. Para ello, selecciona la versión del contenedor de la que deseas obtener una vista previa y, luego, selecciona Preview. Guarda
esta URL de vista previa, ya que la necesitarás en los pasos posteriores.
Para habilitar las vistas previas de contenedores, debes agregar código al archivo de implementación del delegado de la app y definir el esquema de URL de vista previa de Google Tag Manager en la lista de propiedades de tu proyecto.
Primero, agrega los siguientes fragmentos de código en negrita al archivo delegado de tu 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 continuación, registra el siguiente identificador y esquema de URL en la clave de tipos de URL del archivo de lista de propiedades de tu aplicación:
URL identifier: your.package_name URL scheme: tagmanager.c.your.package.name
Abre el vínculo en un emulador o dispositivo físico para obtener una vista previa del contenedor de borrador en tu app.
Cuando todo esté listo para que los valores de configuración del borrador estén disponibles en tu aplicación, publica el contenedor.
Configuración avanzada
Google Tag Manager para dispositivos móviles tiene varias opciones de configuración avanzada que te permiten seleccionar valores según las condiciones del entorno de ejecución con reglas, actualizar manualmente el contenedor y obtener opciones adicionales para abrir contenedores. En las siguientes secciones, se describen varias de las configuraciones avanzadas más comunes.
Opciones avanzadas para abrir contenedores
El SDK de Google Tag Manager proporciona varios métodos para abrir contenedores que pueden darte más control sobre el proceso de carga:
openContainerById:callback:
openContainerById:callback: es la API de nivel más bajo y más flexible para abrir un contenedor. Muestra de inmediato un contenedor predeterminado y,
además, carga de forma asíncrona un contenedor desde el disco o la red si no existe un contenedor
guardado o si el contenedor guardado no es reciente (tiene más de 12 horas).
@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 el proceso de carga, openContainerById:callback: emite
varias devoluciones de llamada de ciclo de vida para que tu código pueda averiguar cuándo
comienza la solicitud de carga, si falla o se completa correctamente (y por qué), y si
el contenedor se cargó desde el disco o la red.
A menos que sea aceptable que tu aplicación use los valores predeterminados, deberás usar estas devoluciones de llamada para saber cuándo se cargó un contenedor guardado o de red. Ten en cuenta que no podrás cargar un contenedor guardado o de red si es la primera vez que se ejecuta la app y no hay conexión de red.
openContainerById:callback: pasa los siguientes valores de enum como argumentos a estas devoluciones de llamada:
RefreshType
| Valor | Descripción |
|---|---|
kTAGContainerCallbackRefreshTypeSaved
|
La solicitud de actualización está cargando un contenedor guardado de forma local. |
kTAGContainerCallbackRefreshTypeNetwork
|
La solicitud de actualización está cargando un contenedor a través de la red. |
RefreshFailure
| Valor | Descripción |
|---|---|
kTAGContainerCallbackRefreshFailureNoSavedContainer
|
No hay ningún contenedor guardado disponible. |
kTAGContainerCallbackRefreshFailureIoError
|
Un error de E/S impidió que se actualizara el contenedor. |
kTAGContainerCallbackRefreshFailureNoNetwork
|
No hay ninguna conexión de red disponible. |
kTAGContainerCallbackRefreshFailureNetworkError
|
Se produjo un error de red. |
kTAGContainerCallbackRefreshFailureServerError
|
Se produjo un error en el servidor. |
kTAGContainerCallbackRefreshFailureUnknownError
|
Se produjo un error que no se puede categorizar. |
Métodos para abrir contenedores nuevos y no predeterminados
TAGContainerOpener une openContainerById:callback: y proporciona dos métodos de conveniencia para abrir contenedores: openContainerWithId:tagManager:openType:timeout:notifier: y openContainerWithId:tagManager:openType:timeout:.
Cada uno de estos métodos toma una enumeración que solicita un contenedor no predeterminado o nuevo.
Se recomienda kTAGOpenTypePreferNonDefault para la mayoría de las aplicaciones y
intenta devolver el primer contenedor no predeterminado disponible dentro de un período de tiempo de espera determinado, ya sea desde el disco o la red, incluso si ese contenedor tiene más
de 12 horas de antigüedad. Si devuelve un contenedor guardado obsoleto, también realizará una solicitud de red asíncrona para obtener uno nuevo.
Cuando uses kTAGOpenTypePreferNonDefault, se devolverá un contenedor predeterminado si no hay otro disponible o si se supera el período de tiempo de espera.
kTAGOpenTypePreferFresh intenta devolver un contenedor nuevo desde
el disco o la red dentro del período de tiempo de espera determinado.
Devuelve un contenedor guardado si no hay una conexión de red disponible o si se supera el período de tiempo de espera.
No se recomienda usar kTAGOpenTypePreferFresh
en lugares donde un tiempo de solicitud más largo pueda afectar notablemente la experiencia del usuario,
como con marcas de IU o cadenas de visualización. También puedes usar TAGContainer::refresh en cualquier momento para forzar una solicitud de contenedor de red.
Ambos métodos de conveniencia no son de bloqueo.
openContainerWithId:tagManager:openType:timeout: devuelve un objeto TAGContainerFuture, cuyo método get devuelve un TAGContainer en cuanto se carga (pero se bloqueará hasta entonces).
El método openContainerWithId:tagManager:openType:timeout:notifier: toma una sola devolución de llamada, a la que se llama cuando el contenedor está disponible.
Ambos métodos tienen un período de tiempo de espera predeterminado de
2.0 segundos.
Cómo evaluar macros en el entorno de ejecución con reglas
Los contenedores pueden evaluar valores en el entorno de ejecución con reglas. Las reglas pueden basarse en criterios como el idioma del dispositivo, la plataforma o cualquier otro valor de macro. Por ejemplo, se pueden usar reglas para seleccionar una cadena de visualización localizada según el idioma del dispositivo en el entorno de ejecución. Esto se puede configurar con la siguiente regla:
Luego, puedes crear macros de recopilación de valores para cada idioma y agregar esta regla a cada macro, insertando el código de idioma correspondiente. Cuando se publique este contenedor, tu aplicación podrá mostrar cadenas de visualización localizadas, según el idioma del dispositivo del usuario en el entorno de ejecución.
Ten en cuenta que, si tu contenedor predeterminado necesita reglas, debes usar un archivo de contenedor binario como contenedor predeterminado.
Obtén más información para configurar reglas (Centro de ayuda).
Archivos de contenedor binarios predeterminados
Los contenedores predeterminados que necesitan reglas deben usar un archivo de contenedor binario en lugar de un archivo de lista de propiedades o un archivo JSON como contenedor predeterminado. Los contenedores binarios ofrecen compatibilidad para determinar los valores de las macros en el entorno de ejecución con las reglas de Google Tag Manager, mientras que los archivos de lista de propiedades o JSON no lo hacen.
Los archivos de contenedor binarios se pueden descargar desde la interfaz web de Google Tag Manager
y se deben agregar al paquete de tu aplicación principal siguiendo esta convención de nombres:
GTM-XXXX, donde el nombre del archivo representa tu
ID de contenedor.
En los casos en que haya un archivo de lista de propiedades o un archivo JSON, así como un archivo de contenedor binario, el SDK usará el archivo de contenedor binario como el contenedor predeterminado.
Usa macros de llamada a función
Las macros de llamada a función son macros que se establecen en el valor que se devuelve de una función especificada en tu aplicación. Las macros de llamada a función se pueden usar para incorporar valores de entorno de ejecución con tus reglas de Google Tag Manager, como determinar en el entorno de ejecución qué precio mostrar a un usuario según el idioma y la moneda configurados de un dispositivo.
Para configurar una macro de llamada a función, sigue estos pasos:
- Define la macro de llamada a función en la interfaz web de Google Tag Manager. De manera opcional, los argumentos se pueden configurar como pares clave-valor.
- Define un controlador que implemente el protocolo
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 el controlador con TAGContainer::registerFunctionCallMacroHandler:forMacro: y el nombre de la función
especificado en la interfaz de 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
Cómo usar las etiquetas de llamada a función
Las etiquetas de llamada a función permiten que se ejecuten las funciones registradas previamente cada vez que se envía un evento a la capa de datos y las reglas de la etiqueta se evalúan como true.
Para configurar una etiqueta de llamada a función, sigue estos pasos:
- Define la etiqueta de llamada a función en la interfaz web de Google Tag Manager. De manera opcional, los argumentos se pueden configurar como pares clave-valor.
- Implementa el protocolo
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 el controlador de etiquetas de llamada a función con el nombre de etiqueta configurado en la interfaz web de Google Tag Manager:
// // MyAppDelegate.h // #import <UIKit/UIKit.h> @interface MyAppDelegate : UIResponder <UIApplicationDelegate> @end // // MyAppDelegate.m // #import "MyAppDelegate.h" #import "MyFunctionCallTagHandler.h" #import "TAGContainer.h" #import "TAGContainerOpener.h" #import "TAGManager.h" @implementation MyAppDelegate - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions { // Open the container. id<TAGContainerFuture> future = [TAGContainerOpener openContainerWithId:@"GTM-XXXX" // Placeholder Container ID. tagManager:[TAGManager instance] openType:kTAGOpenTypePreferNonDefault timeout:nil]; // Method calls that don't need the container. self.container = [future get]; // Register a function call tag handler using the function name of the tag as // defined in the Google Tag Manager web interface. [self.container registerFunctionCallTagHandler:[[MyFunctionCallTagHandler alloc] init] forTag:kMyTagFunctionName]; } @end
Cómo establecer un período de actualización personalizado
El SDK de Google Tag Manager intentará recuperar
un contenedor nuevo si la antigüedad del contenedor actual supera las 12 horas. Para establecer un
período de actualización de contenedores personalizado, usa
NSTimer, como en el
siguiente ejemplo:
- (void)refreshContainer:(NSTimer *)timer { [self.container refresh]; } self.refreshTimer = [NSTimer scheduledTimerWithTimeInterval:<refresh_interval> target:self selector:@selector(refreshContainer:) userInfo:nil repeats:YES];
Depura con Logger
De forma predeterminada, el SDK de Google Tag Manager imprime errores y advertencias en los registros.
Habilitar un registro detallado puede ser útil para la depuración y es posible implementando tu propio Logger, como en este ejemplo:
// 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
O bien, puedes establecer el LogLevel del Logger existente con
TagManager::logger::setLogLevel,
como en este ejemplo:
// Change the LogLevel to INFO to enable logging at INFO and higher levels. self.tagManager = [TAGManager instance]; [self.tagManager.logger setLogLevel:kTAGLoggerLogLevelInfo];