Guía de introducción de Objective-C

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 archivos binarios de la aplicación a los mercados de aplicaciones.

Esto es útil para administrar cualquier valor o marca de configuración en tu aplicación que puedas necesitar cambiar en el futuro, incluidos los siguientes:

  • Varios parámetros de configuración de la IU y cadenas de visualización
  • Tamaños, ubicaciones o tipos de anuncios publicados en tu aplicación
  • Configuración de juegos

Los valores de configuración también se pueden evaluar en el tiempo de ejecución con reglas, lo que permite configuraciones dinámicas como las siguientes:

  • Usar el tamaño de la pantalla para determinar el tamaño del banner de anuncio
  • Usar el idioma y la ubicación para configurar elementos de la IU

Google TagManager también permite la implementación dinámica de etiquetas de seguimiento y píxeles en las aplicaciones. Los desarrolladores pueden enviar eventos importantes a una capa de datos y decidir más adelante qué etiquetas de seguimiento o píxeles se deben activar. TagManager admite las siguientes etiquetas:

  • Google Mobile App Analytics
  • Etiqueta de llamada a función personalizada

Antes de comenzar

Antes de usar esta guía de introducción, necesitarás lo siguiente:

Si es la primera vez que utilizas 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:

  1. Agrega el SDK de Google Tag Manager a tu proyecto
  2. Establece valores predeterminados del contenedor
  3. Abre el contenedor
  4. Obtén valores de configuración del contenedor
  5. Envía eventos a la capa de datos
  6. 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.

A continuación, agrega lo siguiente a las bibliotecas vinculadas del destino de tu aplicación si aún no están presentes:

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

Si deseas que tu aplicación acceda al identificador para anunciantes (IDFA) y a la marca 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.a
  • AdSupport.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:

  1. Accede a la interfaz web de Google Tag Manager.
  2. Selecciona la versión del contenedor que deseas descargar.
  3. Haz clic en el botón Descargar para recuperar el archivo binario del contenedor.
  4. Agrega el archivo binario a el directorio raíz de tu proyecto y a la carpeta "Archivos de asistencia" 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 seguir la convención de nomenclatura correcta.

Aunque se recomienda usar el archivo binario, si tu contenedor no contiene reglas ni etiquetas, puedes usar una lista de propiedades o un archivo JSON en su lugar. El archivo debe ubicarse en el paquete principal y debe seguir esta convención de nomenclatura: <Container_ID>.<plist|json>. Por ejemplo, si el ID del contenedor es GTM-1234, puedes especificar los valores predeterminados del contenedor en un archivo de lista de propiedades llamado GTM-1234.plist.

3. Abre un contenedor

Antes de recuperar valores de un contenedor, tu aplicación debe abrirlo. Si abres un contenedor, se cargará desde el disco (si está disponible) o se solicitará 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 el contenedor esté abierto, se podrán recuperar los valores de configuración con los <type>ForKey: métodos:

// 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 mostrará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. Envía valores a la capa de datos

La capa de datos es un mapa que permite que la información del tiempo de ejecución sobre 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 la capa de datos, puedes configurar etiquetas en la interfaz web de Tag Manager para activar píxeles de conversión y llamadas de seguimiento en respuesta a esas vistas de pantalla sin necesidad de codificarlas de forma rígida 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 para cada vista de pantalla creando esta 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 conversión de Google Ads) para que se active solo para vistas de pantalla específicas. Para ello, crea una regla en la que sea igual a "openScreen" && sea igual a "ConfirmationScreen".

6. Obtén una vista previa de un contenedor y publícalo

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 del 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 que deseas obtener una vista previa y, luego, selecciona Preview. Guarda esta URL de vista previa, ya que la necesitarás en pasos posteriores.

Las URLs de vista previa están disponibles en la ventana de vista previa de la interfaz web de Tag Manager.
Figura 1: Cómo obtener una URL de vista previa de la interfaz web de Tag Manager.

Para habilitar las vistas previas de contenedores, debes agregar código al archivo de implementación del delegado de tu 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 del 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 de URL 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
Registra el esquema de URL de vista previa de Tag Manager en el archivo de lista de propiedades de tu aplicación.
Figura 3: Cómo agregar el esquema de URL de vista previa de Tag Manager al archivo de lista de propiedades de tu aplicación.

Abre el vínculo en un emulador o dispositivo físico para obtener una vista previa del contenedor en borrador en tu app.

Cuando tengas todo listo para que los valores de configuración en borrador estén disponibles para 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 tiempo de ejecución con reglas, actualizar el contenedor de forma manual 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 brindarte 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 también 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 nuevo (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 todo el proceso de carga, openContainerById:callback: emite varias devoluciones de llamada del ciclo de vida para que tu código pueda saber cuándo comienza la solicitud de carga, si falla o tiene éxito, y por qué, y si el contenedor se cargó finalmente 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 enum como argumentos a estas devoluciones de llamada:

RefreshType

ValorDescripció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

ValorDescripción
kTAGContainerCallbackRefreshFailureNoSavedContainer No hay ningún contenedor guardado disponible.
kTAGContainerCallbackRefreshFailureIoError Un error de E/S impidió la actualización del contenedor.
kTAGContainerCallbackRefreshFailureNoNetwork No hay 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 encapsula 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 nuevo o no predeterminado.

Se recomienda kTAGOpenTypePreferNonDefault para la mayoría de las aplicaciones y se intenta mostrar 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. Si muestra un contenedor guardado obsoleto, también realizará una solicitud de red asíncrona para obtener uno nuevo. Cuando se usa kTAGOpenTypePreferNonDefault, se mostrará un contenedor predeterminado si no hay ningún otro contenedor disponible o si se supera el período de tiempo de espera.

kTAGOpenTypePreferFresh intenta mostrar un contenedor nuevo desde el disco o la red dentro del período de tiempo de espera determinado. Muestra 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 puede afectar notablemente la experiencia del usuario, como con marcas de la 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 bloqueadores. openContainerWithId:tagManager:openType:timeout: muestra un objeto TAGContainerFuture, cuyo método get muestra 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, que se llama cuando el contenedor está disponible. Ambos métodos tienen un período de tiempo de espera predeterminado de 2.0 segundos.

Evalúa macros en el tiempo de ejecución con reglas

Los contenedores pueden evaluar valores en el tiempo 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, las reglas se pueden usar para seleccionar una cadena de visualización localizada según el idioma del dispositivo en el tiempo de ejecución. Esto se puede configurar con la siguiente regla:

Se usa una regla para seleccionar cadenas de visualización según el idioma del dispositivo en el tiempo de ejecución: el idioma es igual a es. Esta regla usa la macro de idioma predefinida y un código de idioma ISO 639-1 de dos caracteres.
Figura 1:Cómo agregar una regla para habilitar una macro de recopilación de valores solo para dispositivos configurados para usar el idioma español.

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 adecuado. 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 tiempo 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 predeterminados binarios

Los contenedores predeterminados que necesitan reglas deben usar un archivo de contenedor binario en lugar de un archivo de lista de propiedades o JSON como contenedor predeterminado. Los contenedores binarios ofrecen compatibilidad para determinar los valores de las macros en el tiempo 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 principal de tu aplicación siguiendo esta convención de nomenclatura: GTM-XXXX, en la que el nombre de archivo representa el ID del 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 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 muestra una función especificada en tu aplicación. Las macros de llamada a función se pueden usar para incorporar valores de tiempo de ejecución con tus reglas de Google Tag Manager, como determinar en el tiempo 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, haz lo siguiente:

  1. 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.
  2. Define un controlador que implemente el TAGFunctionCallMacroHandler protocolo: 
    // 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 el controlador con TAGContainer::registerFunctionCallMacroHandler:forMacro: y el nombre de la función especificada 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

Usa etiquetas de llamada a función

Las etiquetas de llamada a función permiten que se ejecuten 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, haz lo siguiente:

  1. 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.
  2. 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
  3. Registra el controlador de etiquetas de llamada a función con el nombre de etiqueta configurado en la 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

Establece 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 contenedor 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

El SDK de Google Tag Manager imprime errores y advertencias en los registros de forma predeterminada. Habilitar un registro más detallado puede ser útil para la depuración y es posible si implementas 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

También 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];