Guia de iniciação para Objective-C

Observação:este guia descreve a implementação antiga do Gerenciador de tags do Google em apps Android. Os novos usuários devem usar o Gerenciador de tags + Firebase para implementar o Gerenciador de tags do Google nos aplicativos iOS.

Neste guia do desenvolvedor, descrevemos como implementar o Gerenciador de tags do Google em um aplicativo para dispositivos móveis.

Introdução

Com o Gerenciador de tags do Google, os desenvolvedores podem alterar os valores de configuração nos apps para dispositivos móveis usando a interface dessa ferramenta sem precisar recriar e reenviar os binários de aplicativos aos marketplaces.

Isso é útil para gerenciar todos os valores de configuração ou sinalizações no aplicativo que você possa precisar alterar no futuro, incluindo:

• Várias configurações de interface e strings de exibição.
• Tamanhos, locais ou tipos de anúncios veiculados no seu aplicativo
• Configurações de jogos

Os valores de configuração também podem ser avaliados no ambiente de execução usando regras, permitindo configurações dinâmicas como:

• Usando o tamanho da tela para determinar o tamanho do banner do anúncio
• Como usar o idioma e o local para configurar elementos da interface

O Google TagManager também permite a implementação dinâmica de tags de acompanhamento e pixels de acompanhamento em aplicativos. Eles podem enviar eventos importantes para uma camada de dados e decidir quais pixels ou tags de acompanhamento devem ser disparados. No momento, o TagManager é compatível com as seguintes tags:

• Google Mobile App Analytics
• Tag de chamada de função personalizada

Antes de começar

Antes de usar este Guia explicativo, você precisa do seguinte:

• Uma conta do Gerenciador de tags do Google
• Uma nova macro de coleta de valores e contêiner do Gerenciador de tags
• Um aplicativo para dispositivos móveis iOS no qual implementar o Gerenciador de tags do Google
• O SDK de serviços do Google Analytics, que contém a biblioteca do Gerenciador de tags.

Se você não tem experiência com o Gerenciador de tags do Google, recomendamos que saiba mais sobre contêineres, macros e regras (Central de Ajuda) antes de continuar este guia.

Vamos começar

Esta seção orienta os desenvolvedores pelo fluxo de trabalho típico do Gerenciador de tags:

1. Adicionar o SDK do Gerenciador de tags do Google ao seu projeto
2. Definir valores de contêiner padrão
3. Abra o contêiner
4. Receber valores de configuração do contêiner
5. Enviar eventos para a DataLayer
6. Visualizar e publicar o contêiner

1. Como adicionar o SDK do Gerenciador de tags do Google ao seu projeto

Antes de usar o SDK do Gerenciador de tags do Google, você precisa adicionar libGoogleAnalyticsServices.a e os arquivos de cabeçalho do Gerenciador de tags do Google (GTM) do diretório Library do pacote do SDK ao seu projeto.

Em seguida, adicione o seguinte às bibliotecas vinculadas do destino do aplicativo, se elas ainda não estiverem presentes:

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

Se você quiser que seu aplicativo acesse o identificador de anunciantes (IDFA) e a sinalização de acompanhamento fornecidas por essa estrutura usando as macros do SDK do Gerenciador de tags do Google, também será necessário vincular estas outras bibliotecas:

• libAdIdAccess.a
• AdSupport.framework

Observação: dependendo das configurações do build, a flag do vinculador -force_load /path/to/libAdIdAccess.a pode ser necessária.

2. Como adicionar um arquivo de contêiner padrão ao seu projeto

Observação: se você ainda não configurou seu contêiner na interface da Web do Gerenciador de tags do Google, volte para esta etapa depois.

O Gerenciador de tags do Google usa um contêiner padrão na primeira execução do seu aplicativo. O contêiner padrão será usado até que o app possa recuperar um novo contêiner pela rede.

Para fazer o download e adicionar um binário de contêiner padrão ao aplicativo, siga estas etapas:

1. Faça login na interface da Web do Gerenciador de tags do Google.
2. Selecione a Versão do contêiner que você quer fazer o download.
3. Clique no botão Download para recuperar o binário do contêiner.
4. Adicione o arquivo binário ao diretório raiz do seu projeto e à pasta "Arquivos de suporte" dele.

O nome de arquivo padrão precisa ser o ID do contêiner (por exemplo, GTM-1234). Depois de fazer o download do arquivo binário, remova o sufixo da versão do nome do arquivo para garantir que você siga a convenção de nomenclatura correta.

Embora o uso do arquivo binário seja recomendado, se o contêiner não tiver regras ou tags, use uma lista de propriedades simples ou um arquivo JSON. O arquivo precisa estar localizado no pacote principal e seguir esta convenção de nomenclatura: <Container_ID>.<plist|json>. Por exemplo, se o ID do contêiner for GTM-1234, especifique os valores padrão do contêiner em um arquivo da lista de propriedades chamado GTM-1234.plist.

Observação: se uma lista de propriedades e um contêiner padrão JSON estiverem presentes no pacote principal, o SDK vai usar a lista de propriedades como o contêiner padrão.

3. Abrir um contêiner

Antes de recuperar valores de um contêiner, seu aplicativo precisa abrir o contêiner. Quando um contêiner é aberto, ele é carregado do disco (se disponível) ou pela rede (se necessário).

A maneira mais fácil de abrir um contêiner no iOS é usando openContainerWithId:tagManager:openType:timeout:notifier:, como no exemplo a seguir:

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

Observação: se o aplicativo depender dos valores de configuração do contêiner, exiba uma tela de apresentação ou outra visualização intermediária até que o contêiner seja carregado. Uma maneira de fazer isso é mover o código de carregamento do contêiner para seu controlador de visualização raiz. Seu controlador de visualização raiz pode apresentar uma visualização modal enquanto o contêiner é carregado.

4. Como receber valores de configuração do contêiner

Quando o contêiner é aberto, os valores de configuração podem ser recuperados usando os 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"];

As solicitações feitas com uma chave inexistente retornarão um valor padrão apropriado ao 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. Enviar valores para a DataLayer

A DataLayer é um mapa que permite que informações do ambiente de execução sobre seu app, como eventos de toque ou exibições de tela, sejam disponibilizadas para macros e tags do Gerenciador de tags em um contêiner.

Por exemplo, ao inserir informações sobre exibições de tela no mapa da DataLayer, você pode configurar tags na interface da Web do Gerenciador de tags para disparar pixels de conversão e acompanhar chamadas em resposta a essas exibições de tela sem precisar codificá-las no seu app.

Os eventos são enviados à DataLayer usando 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

Na interface da Web, agora é possível criar tags (como tags do Google Analytics) que são disparadas para cada exibição de tela. Para isso, crie esta regra: é igual a "openScreen". Para transmitir o nome da tela a uma dessas tags, crie uma macro de camada de dados que faça referência à chave "screenName" na camada de dados. Você também pode criar uma tag (como um pixel de conversão do Google Ads) para disparar somente em exibições de tela específicas. Para isso, crie uma regra em que seja igual a "openScreen" && seja igual a "ConfirmationScreen".

Observação: os valores e as chaves do evento DataLayer precisam ser usados da maneira mais consistente possível para que, neste exemplo, todas as exibições de tela usem "openScreen" como valor do evento e "screenName" como a chave do nome da tela. Isso facilita ao máximo o acesso à DataLayer e a criação de outras tags no futuro.

6. Como visualizar e publicar um contêiner

Os valores das macro sempre corresponderão à versão publicada atual. Antes de publicar a versão mais recente de um contêiner, você pode visualizar seu contêiner de rascunho.

Para gerar um URL de visualização, gere um URL de visualização na interface da Web do Gerenciador de tags do Google. Para isso, escolha a versão do contêiner que você quer visualizar e selecione Preview. Segure esse URL de visualização, porque você precisará dele nas próximas etapas.

Figura 1 : como gerar um URL de visualização na interface da Web do Gerenciador de tags.

Para ativar as visualizações de contêiner, adicione o código ao arquivo de implementação do delegado do app e defina o esquema de URL de visualização do Gerenciador de tags do Google na lista de propriedades do seu projeto.

Primeiro, adicione os seguintes snippets de código em negrito ao arquivo delegado do seu 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;
}

Em seguida, registre o identificador e o esquema de URL abaixo na chave de tipos de URL do arquivo da lista de propriedades do seu aplicativo:

URL identifier: your.package_name
URL scheme: tagmanager.c.your.package.name

Figura 3 : como adicionar o esquema de URL de visualização do Gerenciador de tags ao arquivo da lista de propriedades do seu aplicativo.

Observação: your.package.name precisa corresponder ao nome do app usado para gerar o URL de visualização (Figura 1).

Abra o link em um emulador ou dispositivo físico para visualizar o contêiner de rascunho no seu app.

Quando estiver tudo pronto para disponibilizar os valores de configuração de rascunho no seu aplicativo, publique o contêiner.

Configuração avançada

O Gerenciador de tags do Google para dispositivos móveis tem várias opções avançadas de configuração que permitem selecionar valores com base nas condições de ambiente de execução usando regras, atualizar manualmente o contêiner e ter mais opções para abrir contêineres. As seções a seguir descrevem várias das configurações avançadas mais comuns.

Opções avançadas para abrir contêineres

O SDK do Gerenciador de tags do Google oferece vários métodos para abrir contêineres que oferecem mais controle sobre o processo de carregamento:

openContainerById:callback:

openContainerById:callback: é a API de nível mais baixo e mais flexível para abrir um contêiner. Ele retorna imediatamente com um contêiner padrão e também carrega de maneira assíncrona um contêiner do disco ou da rede se não houver um contêiner salvo ou se o contêiner salvo não for atualizado (há mais 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

Ao longo do processo de carregamento, openContainerById:callback: emite vários callbacks de ciclo de vida para que seu código possa descobrir quando a solicitação de carregamento começa, se e por que ela falha ou teve êxito e se o contêiner foi carregado do disco ou da rede.

A menos que seja aceitável que seu aplicativo use os valores padrão, você vai precisar usar esses callbacks para saber quando um contêiner salvo ou de rede foi carregado. Não será possível carregar um contêiner salvo ou de rede se esta for a primeira vez que o app for executado e não houver conexão de rede.

O openContainerById:callback: transmite os seguintes valores de enum como argumentos para esses callbacks:

RefreshType

Valor	Descrição
kTAGContainerCallbackRefreshTypeSaved	A solicitação de atualização está carregando um contêiner salvo localmente.
kTAGContainerCallbackRefreshTypeNetwork	A solicitação de atualização está carregando um contêiner na rede.

RefreshFailure

Valor	Descrição
kTAGContainerCallbackRefreshFailureNoSavedContainer	Não há contêineres salvos disponíveis.
kTAGContainerCallbackRefreshFailureIoError	Um erro de E/S impediu a atualização do contêiner.
kTAGContainerCallbackRefreshFailureNoNetwork	Não há conexão de rede disponível.
kTAGContainerCallbackRefreshFailureNetworkError	Ocorreu um erro de rede.
kTAGContainerCallbackRefreshFailureServerError	Ocorreu um erro no servidor.
kTAGContainerCallbackRefreshFailureUnknownError	Ocorreu um erro que não pode ser classificado.

Métodos para abrir contêineres novos e não padrão

TAGContainerOpener envolve openContainerById:callback: e fornece dois métodos convenientes para abrir contêineres: openContainerWithId:tagManager:openType:timeout:notifier: e openContainerWithId:tagManager:openType:timeout:.

Cada um desses métodos usa uma enumeração que solicita um contêiner não padrão ou novo.

O kTAGOpenTypePreferNonDefault é recomendado para a maioria dos aplicativos e tenta retornar o primeiro contêiner não padrão disponível dentro de um determinado período de tempo limite, seja do disco ou da rede, mesmo que esse contêiner tenha mais de 12 horas. Se ele retornar um contêiner salvo desatualizado, ele também vai fazer uma solicitação de rede assíncrona para um novo. Ao usar kTAGOpenTypePreferNonDefault, um contêiner padrão será retornado se nenhum outro contêiner estiver disponível ou se o período de tempo limite for excedido.

kTAGOpenTypePreferFresh tenta retornar um novo contêiner do disco ou da rede dentro do tempo limite especificado. Ela retorna um contêiner salvo se uma conexão de rede não estiver disponível e/ou o tempo limite for excedido.

Não é recomendado usar kTAGOpenTypePreferFresh em locais em que um tempo de solicitação mais longo pode afetar visivelmente a experiência do usuário, como em sinalizações de IU ou strings de exibição. Também é possível usar TAGContainer::refresh a qualquer momento para forçar uma solicitação de contêiner de rede.

Esses dois métodos de conveniência não causam bloqueio. openContainerWithId:tagManager:openType:timeout: retorna um objeto TAGContainerFuture, cujo método get retorna uma TAGContainer assim que é carregado (mas isso será bloqueado até lá). O método openContainerWithId:tagManager:openType:timeout:notifier: recebe um único callback, chamado quando o contêiner está disponível. Os dois métodos têm um tempo limite padrão de 2.0 segundos.

Avaliação de macros no momento da execução usando regras

Os contêineres podem avaliar os valores no ambiente de execução usando regras. As regras podem ser baseadas em critérios como idioma do dispositivo, plataforma ou qualquer outro valor macro. Por exemplo, as regras podem ser usadas para selecionar uma string de exibição localizada com base no idioma do dispositivo durante a execução. Isso pode ser configurado usando a seguinte regra:

Figura 1:como adicionar uma regra para ativar uma macro de coleta de valores somente para dispositivos configurados para usar o idioma espanhol.

Em seguida, é possível criar macros de coleta de valores para cada idioma e adicionar essa regra a cada macro, inserindo o código do idioma apropriado. Quando esse contêiner for publicado, o aplicativo poderá mostrar strings de exibição localizadas, dependendo do idioma do dispositivo do usuário durante a execução.

Se o contêiner padrão precisar de regras, será necessário usar um arquivo de contêiner binário como o contêiner padrão.

Saiba mais sobre como configurar regras (Central de Ajuda).

Arquivos de contêiner padrão binários

Os contêineres padrão que precisam de regras precisam usar um arquivo de contêiner binário em vez de um arquivo de lista de propriedades ou um arquivo JSON como o contêiner padrão. Os contêineres binários oferecem suporte para determinar valores de macro no ambiente de execução com as regras do Gerenciador de tags do Google, ao contrário da lista de propriedades ou dos arquivos JSON.

É possível fazer o download dos arquivos de contêiner binários na interface da Web do Gerenciador de tags do Google e adicionar ao pacote principal de aplicativos seguindo esta convenção de nomenclatura: GTM-XXXX, em que o nome do arquivo representa o ID do contêiner.

Quando há um arquivo de lista de propriedades e/ou JSON e um arquivo de contêiner binário, o SDK usa o arquivo de contêiner binário como o contêiner padrão.

Como usar macros de chamada de função

As macros de chamada de função são aquelas definidas como o valor de retorno de uma função especificada no aplicativo. As macros de chamada de função podem ser usadas para incorporar valores de tempo de execução às regras do Gerenciador de tags do Google. Por exemplo, determinar qual preço será exibido para um usuário com base no idioma e na moeda configurados de um dispositivo.

Para configurar uma macro de chamada de função:

1. Defina a macro de chamada de função na interface da Web do Gerenciador de tags do Google. Os argumentos podem ser configurados como pares de chave-valor.
2. Defina um gerenciador que implemente o 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
   

3. Registre o gerenciador usando TAGContainer::registerFunctionCallMacroHandler:forMacro: e o nome da função especificado na interface do Gerenciador de tags do Google:

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

Como usar tags de chamada de função

As tags de chamada de função permitem que as funções pré-registradas sejam executadas sempre que um evento for enviado à camada de dados e as regras da tag forem avaliadas como true.

Para configurar uma tag de chamada de função:

1. Defina a tag de chamada de função na interface da Web do Gerenciador de tags do Google. Os argumentos podem ser configurados como pares de chave-valor.
2. Implemente o 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. Registre o gerenciador de tags de chamada de função usando o nome da tag configurado na interface da Web do Gerenciador de tags do Google:

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

Como configurar um período de atualização personalizado

O SDK do Gerenciador de tags do Google tentará recuperar um novo contêiner se a idade atual dele exceder 12 horas. Para definir um período de atualização de contêiner personalizado, use NSTimer, como no exemplo a seguir:

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

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

Como depurar com o logger

Por padrão, o SDK do Gerenciador de tags do Google imprime erros e avisos nos registros. Ativar um registro mais detalhado pode ser útil para a depuração. Isso é possível implementando seu próprio Logger, como neste exemplo:

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

Ou defina o LogLevel do Logger atual usando TagManager::logger::setLogLevel, como neste exemplo:

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