Przewodnik wprowadzający do programu Objective-C

Z tego przewodnika dla deweloperów dowiesz się, jak zaimplementować Menedżera tagów Google w aplikacji mobilnej.

Wprowadzenie

Menedżer tagów Google umożliwia deweloperom zmienianie wartości konfiguracji w aplikacjach mobilnych za pomocą interfejsu Menedżera tagów Google bez konieczności ponownego kompilowania i przesyłania plików binarnych aplikacji do sklepów z aplikacjami.

Jest to przydatne do zarządzania dowolnymi wartościami konfiguracji lub flagami w aplikacji, które mogą wymagać zmiany w przyszłości, w tym:

  • różnymi ustawieniami interfejsu i ciągami wyświetlanymi;
  • rozmiarami, lokalizacjami lub typami reklam wyświetlanych w aplikacji;
  • ustawieniami gier.

Wartości konfiguracji można też oceniać w czasie działania aplikacji za pomocą reguł, co umożliwia dynamiczne konfiguracje, takie jak:

  • określanie rozmiaru banera reklamowego na podstawie rozmiaru ekranu;
  • konfigurowanie elementów interfejsu na podstawie języka i lokalizacji.

Menedżer tagów Google umożliwia też dynamiczną implementację tagów śledzących i pikseli w aplikacjach. Deweloperzy mogą przekazywać ważne zdarzenia do warstwy danych i później decydować, które tagi lub piksele śledzące mają się uruchamiać. Menedżer tagów obsługuje te tagi:

  • Google Analytics dla aplikacji mobilnych
  • niestandardowy tag wywołania funkcji.

Zanim zaczniesz

Zanim zaczniesz korzystać z tego przewodnika, musisz mieć:

Jeśli dopiero zaczynasz korzystać z Menedżera tagów Google, przed kontynuowaniem lektury tego przewodnika zapoznaj się z informacjami o kontenerach, makrach i regułach (Centrum pomocy).

Pierwsze kroki

W tej sekcji deweloperzy dowiedzą się, jak wygląda typowy proces pracy z Menedżerem tagów:

  1. Dodaj pakiet SDK Menedżera tagów Google do projektu.
  2. Ustaw domyślne wartości kontenera.
  3. Otwórz kontener.
  4. Pobierz wartości konfiguracji z kontenera.
  5. Przekaż zdarzenia do warstwy danych.
  6. Wyświetl podgląd kontenera i opublikuj go.

1. Dodawanie pakietu SDK Menedżera tagów Google do projektu

Zanim zaczniesz korzystać z pakietu SDK Menedżera tagów Google, musisz dodać do projektu plik libGoogleAnalyticsServices.a i pliki nagłówkowe Menedżera tagów Google (GTM) z katalogu Library w pakiecie SDK.

Następnie dodaj do połączonych bibliotek docelowych aplikacji te biblioteki, jeśli nie są jeszcze obecne:

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

Jeśli chcesz, aby Twoja aplikacja miała dostęp do identyfikatora dla reklamodawców (IDFA) i flagi śledzenia udostępnianych przez ten framework za pomocą makr pakietu SDK Menedżera tagów Google, musisz też połączyć te dodatkowe biblioteki:

  • libAdIdAccess.a
  • AdSupport.framework

2. Dodawanie domyślnego pliku kontenera do projektu

Przy pierwszym uruchomieniu aplikacji Menedżer tagów Google używa domyślnego kontenera. Domyślny kontener będzie używany, dopóki aplikacja nie będzie mogła pobrać nowego kontenera przez sieć.

Aby pobrać i dodać do aplikacji domyślny plik binarny kontenera, wykonaj te czynności:

  1. Zaloguj się w interfejsie Menedżera tagów Google.
  2. Wybierz wersję kontenera, którą chcesz pobrać.
  3. Kliknij przycisk Pobierz , aby pobrać plik binarny kontenera.
  4. Dodaj plik binarny do katalogu głównego projektu i do folderu „Supporting Files” w projekcie.

Domyślna nazwa pliku powinna być identyfikatorem kontenera (np. GTM-1234). Po pobraniu pliku binarnego usuń z nazwy pliku sufiks wersji, aby zachować prawidłową konwencję nazewnictwa.

Chociaż zalecamy używanie pliku binarnego, jeśli kontener nie zawiera reguł ani tagów, możesz zamiast niego użyć pliku listy właściwości lub pliku JSON. Plik powinien znajdować się w głównym pakiecie i być zgodny z tą konwencją nazewnictwa: <Container_ID>.<plist|json>. Jeśli na przykład identyfikator kontenera to GTM-1234, możesz określić domyślne wartości kontenera w pliku listy właściwości o nazwie GTM-1234.plist.

3. Otwieranie kontenera

Zanim pobierzesz wartości z kontenera, musisz go otworzyć. Otwarcie kontenera spowoduje jego wczytanie z dysku (jeśli jest dostępny) lub pobranie z sieci (jeśli jest to konieczne).

Najłatwiejszym sposobem otwarcia kontenera na iOS jest użycie funkcji openContainerWithId:tagManager:openType:timeout:notifier:, jak w tym przykładzie:

// 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. Pobieranie wartości konfiguracji z kontenera

Po otwarciu kontenera wartości konfiguracji można pobierać za pomocą metod <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"];

Żądania wysyłane z nieistniejącym kluczem będą zwracać wartość domyślną odpowiednią dla żądanego typu:

// 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. Przekazywanie wartości do warstwy danych

Warstwa danych to mapa, która umożliwia udostępnianie makrom i tagom Menedżera tagów w kontenerze informacji o aplikacji w czasie działania, takich jak zdarzenia dotknięcia czy wyświetlenia ekranu.

Na przykład, przekazując informacje o wyświetleniach ekranu do mapy warstwy danych, możesz skonfigurować w interfejsie Menedżera tagów tagi, które będą uruchamiać piksele konwersji i wywołania śledzące w odpowiedzi na te wyświetlenia ekranu bez konieczności kodowania ich na stałe w aplikacji.

Zdarzenia są przekazywane do warstwy danych za pomocą funkcji 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

W interfejsie możesz teraz tworzyć tagi (np. tagi Google Analytics) które będą się uruchamiać przy każdym wyświetleniu ekranu, tworząc tę regułę: equals "openScreen". Aby przekazać nazwę ekranu do jednego z tych tagów, utwórz makro warstwy danych, które odwołuje się do klucza „screenName” w warstwie danych. Możesz też utworzyć tag (np. piksel śledzenia konwersji Google Ads), który będzie się uruchamiać tylko w przypadku określonych wyświetleń ekranu, tworząc regułę, w której equals "openScreen" && equals "ConfirmationScreen".

6. Wyświetlanie podglądu i publikowanie kontenera

Wartości makr zawsze odpowiadają bieżącej opublikowanej wersji. Zanim opublikujesz najnowszą wersję kontenera, możesz wyświetlić podgląd jego wersji roboczej.

Aby wyświetlić podgląd kontenera, wygeneruj adres URL podglądu w interfejsie Menedżera tagów Google wybierając wersję kontenera której podgląd chcesz wyświetlić, a następnie klikając Preview. Zapisz ten adres URL podglądu, ponieważ będzie Ci potrzebny w kolejnych krokach.

Adresy URL podglądu są dostępne w oknie podglądu interfejsu internetowego Menedżera tagów.
Rysunek 1. Pobieranie adresu URL podglądu z interfejsu Menedżera tagów.

Aby włączyć podgląd kontenera, musisz dodać kod do pliku implementacji delegata aplikacji i zdefiniować schemat adresu URL podglądu Menedżera tagów Google w pliku listy właściwości projektu.

Najpierw dodaj do pliku delegata aplikacji te fragmenty kodu:

@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;
}

Następnie zarejestruj ten identyfikator adresu URL i schemat URI adresu URL w kluczu typów adresów URL w pliku listy właściwości aplikacji:

URL identifier: your.package_name
URL scheme: tagmanager.c.your.package.name
Zarejestruj schemat URI adresu URL podglądu Menedżera tagów w pliku listy właściwości aplikacji.
Rysunek 3. Dodawanie schematu URI adresu URL podglądu Menedżera tagów do pliku listy właściwości aplikacji.

Otwórz link w emulatorze lub na urządzeniu fizycznym, aby wyświetlić podgląd wersji roboczej kontenera w aplikacji.

Gdy będziesz gotowy(-a) na udostępnienie wartości konfiguracji w wersji roboczej aplikacji, opublikuj kontener.

Konfiguracja zaawansowana

Menedżer tagów Google na urządzenia mobilne ma szereg zaawansowanych opcji konfiguracji, które umożliwiają wybieranie wartości na podstawie warunków w czasie działania aplikacji za pomocą reguł, ręczne odświeżanie kontenera i uzyskiwanie dodatkowych opcji otwierania kontenerów. W kolejnych sekcjach opisujemy kilka najczęstszych zaawansowanych konfiguracji.

Zaawansowane opcje otwierania kontenerów

Pakiet SDK Menedżera tagów Google udostępnia kilka metod otwierania kontenerów, które mogą zapewnić większą kontrolę nad procesem wczytywania:

openContainerById:callback:

openContainerById:callback: to interfejs API najniższego poziomu i najbardziej elastyczny do otwierania kontenera. Zwraca natychmiast domyślny kontener i asynchronicznie wczytuje kontener z dysku lub sieci, jeśli nie ma zapisanego kontenera albo jeśli zapisany kontener jest nieaktualny (starszy niż 12 godzin).

@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

Podczas procesu wczytywania funkcja openContainerById:callback: wysyła kilka wywołań zwrotnych cyklu życia, dzięki czemu Twój kod może się dowiedzieć, kiedy rozpoczyna się żądanie wczytania, czy i dlaczego się nie powiodło lub powiodło, oraz czy kontener został ostatecznie wczytany z dysku czy z sieci.

Jeśli nie akceptujesz używania wartości domyślnych w aplikacji, musisz użyć tych wywołań zwrotnych, aby wiedzieć, kiedy wczytał się zapisany lub sieciowy kontener. Pamiętaj, że nie będzie można wczytać zapisanego ani sieciowego kontenera, jeśli jest to pierwsze uruchomienie aplikacji i nie ma połączenia z siecią.

openContainerById:callback: przekazuje te wartości enum jako argumenty do tych wywołań zwrotnych:

RefreshType

WartośćOpis
kTAGContainerCallbackRefreshTypeSaved Żądanie odświeżenia wczytuje zapisany lokalnie kontener.
kTAGContainerCallbackRefreshTypeNetwork Żądanie odświeżenia wczytuje kontener przez sieć.

RefreshFailure

WartośćOpis
kTAGContainerCallbackRefreshFailureNoSavedContainer Nie ma dostępnego zapisanego kontenera.
kTAGContainerCallbackRefreshFailureIoError Błąd wejścia/wyjścia uniemożliwił odświeżenie kontenera.
kTAGContainerCallbackRefreshFailureNoNetwork Brak połączenia z siecią.
kTAGContainerCallbackRefreshFailureNetworkError Wystąpił błąd sieci.
kTAGContainerCallbackRefreshFailureServerError Wystąpił błąd serwera.
kTAGContainerCallbackRefreshFailureUnknownError Wystąpił błąd, którego nie można sklasyfikować.

Metody otwierania kontenerów innych niż domyślne i nowych

TAGContainerOpener opakowuje openContainerById:callback: i udostępnia 2 wygodne metody otwierania kontenerów: openContainerWithId:tagManager:openType:timeout:notifier: i openContainerWithId:tagManager:openType:timeout:.

Każda z tych metod przyjmuje wyliczenie, które żąda kontenera innego niż domyślny lub nowego.

kTAGOpenTypePreferNonDefault jest zalecany w przypadku większości aplikacji i próbuje zwrócić pierwszy dostępny kontener inny niż domyślny w danym okresie limitu czasu, z dysku lub sieci, nawet jeśli ten kontener jest starszy niż 12 godzin. Jeśli zwróci nieaktualny zapisany kontener, wyśle też asynchroniczne żądanie sieciowe o nowy. W przypadku użycia kTAGOpenTypePreferNonDefault zostanie zwrócony domyślny kontener, jeśli nie będzie dostępny żaden inny kontener lub jeśli zostanie przekroczony limit czasu.

kTAGOpenTypePreferFresh próbuje zwrócić nowy kontener z dysku lub sieci w danym okresie limitu czasu. Zwraca zapisany kontener, jeśli połączenie z siecią jest niedostępne lub jeśli zostanie przekroczony limit czasu.

Nie zalecamy używania kTAGOpenTypePreferFresh w miejscach, w których dłuższy czas żądania może zauważalnie wpłynąć na wygodę użytkownika, np. w przypadku flag interfejsu lub ciągów wyświetlanych. W dowolnym momencie możesz też użyć TAGContainer::refresh, aby wymusić żądanie kontenera sieciowego.

Obie te wygodne metody są nieblokujące. openContainerWithId:tagManager:openType:timeout: zwraca obiekt TAGContainerFuture, którego metoda get zwraca TAGContainer zaraz po jego wczytaniu (ale do tego czasu będzie blokować). Metoda openContainerWithId:tagManager:openType:timeout:notifier: przyjmuje pojedyncze wywołanie zwrotne, które jest wywoływane, gdy kontener jest dostępny. Obie metody mają domyślny limit czasu wynoszący 2.0 sekundy.

Ocena makr w czasie działania aplikacji za pomocą reguł

Kontenery mogą oceniać wartości w czasie działania aplikacji za pomocą reguł. Reguły mogą być oparte na kryteriach takich jak język urządzenia, platforma lub dowolna inna wartość makra. Na przykład reguły mogą służyć do wybierania zlokalizowanego ciągu wyświetlanego na podstawie języka urządzenia w czasie działania aplikacji. Możesz to skonfigurować za pomocą tej reguły:

Reguła służy do wybierania ciągów wyświetlanych na podstawie języka urządzenia w czasie działania: język równy es. Ta reguła używa predefiniowanego makra języka i dwuznakowego kodu języka ISO 639-1.
Rysunek 1.Dodawanie reguły, która włącza makro do zbierania wartości tylko w przypadku urządzeń skonfigurowanych do używania języka hiszpańskiego.

Następnie możesz utworzyć makra do zbierania wartości dla każdego języka i dodać do każdego makra tę regułę, wstawiając odpowiedni kod języka. Gdy ten kontener zostanie opublikowany, Twoja aplikacja będzie mogła wyświetlać zlokalizowane ciągi wyświetlane w zależności od języka urządzenia użytkownika w czasie działania aplikacji.

Pamiętaj, że jeśli domyślny kontener wymaga reguł, musisz użyć jako domyślnego kontenera binarnego pliku kontenera.

Więcej informacji o konfigurowaniu reguł (Centrum pomocy).

Binarne domyślne pliki kontenera

Domyślne kontenery, które wymagają reguł, powinny używać jako domyślnego kontenera binarnego pliku kontenera zamiast pliku listy właściwości lub JSON file. Kontenery binarne obsługują określanie wartości makr w czasie działania aplikacji za pomocą reguł Menedżera tagów Google, natomiast pliki listy właściwości i pliki JSON nie.

Binarne pliki kontenera można pobrać z interfejsu Menedżera tagów Google i dodać do głównego pakietu aplikacji zgodnie z tą konwencją nazewnictwa: GTM-XXXX, gdzie nazwa pliku reprezentuje identyfikator kontenera.

Jeśli obecne są plik listy właściwości lub plik JSON oraz binarny plik kontenera, pakiet SDK użyje binarnego pliku kontenera jako domyślnego kontenera.

Używanie makr wywołania funkcji

Makra wywołania funkcji to makra, które są ustawione na wartość zwracaną przez określoną funkcję w aplikacji. Makra wywołania funkcji mogą służyć do uwzględniania wartości w czasie działania aplikacji w regułach Menedżera tagów Google, np. do określania w czasie działania aplikacji ceny, która ma być wyświetlana użytkownikowi, na podstawie skonfigurowanego języka i waluty urządzenia.

Aby skonfigurować makro wywołania funkcji:

  1. Zdefiniuj makro wywołania funkcji w interfejsie Menedżera tagów Google. Argumenty można opcjonalnie skonfigurować jako pary klucz-wartość.
  2. Zdefiniuj moduł obsługi, który implementuje protokół 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. Zarejestruj moduł obsługi za pomocą funkcji TAGContainer::registerFunctionCallMacroHandler:forMacro: i nazwy funkcji określonej w interfejsie Menedżera tagów 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

Używanie tagów wywołania funkcji

Tagi wywołania funkcji umożliwiają wykonywanie zarejestrowanych wcześniej funkcji za każdym razem, gdy zdarzenie jest przekazywane do warstwy danych, a reguły tagu przyjmują wartość true.

Aby skonfigurować tag wywołania funkcji:

  1. Zdefiniuj tag wywołania funkcji w interfejsie Menedżera tagów Google. Argumenty można opcjonalnie skonfigurować jako pary klucz-wartość.
  2. Zaimplementuj protokół 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. Zarejestruj moduł obsługi tagu wywołania funkcji za pomocą nazwy tagu skonfigurowanej w interfejsie Menedżera tagów 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

Ustawianie niestandardowego okresu odświeżania

Pakiet SDK Menedżera tagów Google spróbuje pobrać nowy kontener, jeśli wiek bieżącego kontenera przekroczy 12 godzin. Aby ustawić niestandardowy okres odświeżania kontenera, użyj NSTimer, jak w tym przykładzie:

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

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

Debugowanie za pomocą rejestratora

Pakiet SDK Menedżera tagów Google domyślnie zapisuje błędy i ostrzeżenia w logach. Włączenie bardziej szczegółowego logowania może być przydatne do debugowania. Można to zrobić, implementując własny Logger, jak w tym przykładzie:

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

Możesz też ustawić LogLevel istniejącego rejestratora za pomocą TagManager::logger::setLogLevel, jak w tym przykładzie:

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