Przewodnik wprowadzający do programu Objective-C

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

Wstęp

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

Jest to przydatne do zarządzania wszelkimi wartościami konfiguracyjnymi lub flagami w aplikacji, które w przyszłości konieczne może być zmiana, takimi jak:

  • Różne ustawienia interfejsu i wyświetlane ciągi znaków
  • rozmiary, lokalizacje lub typy reklam wyświetlanych w Twojej aplikacji;
  • Ustawienia gier

Wartości konfiguracji mogą być też oceniane w czasie działania za pomocą reguł, które włączają konfiguracje dynamiczne, takie jak:

  • Używanie rozmiaru ekranu do określania rozmiaru banera reklamowego
  • Używanie języka i lokalizacji do konfigurowania elementów interfejsu

Menedżer tagów Google umożliwia też dynamiczną implementację tagów i pikseli śledzenia w aplikacjach. Deweloperzy mogą przekazywać ważne zdarzenia do warstwy danych i później zdecydować, które tagi śledzenia lub piksele mają być uruchamiane. Menedżer tagów obsługuje obecnie następujące tagi:

  • Analytics dla aplikacji mobilnych Google
  • Tag wywołania funkcji niestandardowej

Zanim zaczniesz

Zanim zaczniesz korzystać z tego przewodnika, będziesz potrzebować:

Jeśli dopiero zaczynasz korzystać z Menedżera tagów Google, zalecamy, aby przed przejściem do kolejnego przewodnika dowiedzieć się więcej o kontenerach, makrach i regułach.

Pierwsze kroki

W tej sekcji programiści mogą wykonać typowy proces działania Menedżera tagów:

  1. Dodawanie do projektu pakietu SDK Menedżera tagów Google
  2. Ustawianie domyślnych wartości kontenerów
  3. Otwórz kontener
  4. Pobieranie wartości konfiguracyjnych z kontenera
  5. Przekazywanie zdarzeń do warstwy danych
  6. Wyświetlanie podglądu i publikowanie kontenera

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 pliki nagłówkowe libGoogleAnalyticsServices.a i Menedżera tagów Google (GTM) z katalogu Library pakietu SDK.

Następnie dodaj ten kod do połączonych bibliotek celu aplikacji, jeśli jeszcze ich nie ma:

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

Jeśli chcesz, aby Twoja aplikacja uzyskiwała dostęp do identyfikatora reklamodawcy (IDFA) i flagi śledzenia udostępnianej przez tę platformę 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

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

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

  1. Zaloguj się w interfejsie internetowym Menedżera tagów Google.
  2. Wybierz wersję kontenera, który 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ślną nazwą pliku powinien być identyfikator kontenera (np. GTM-1234). Po pobraniu pliku binarnego pamiętaj o usunięciu z nazwy pliku sufiksu wersji, aby zachować prawidłową konwencję nazewnictwa.

Zalecamy użycie pliku binarnego, ale jeśli Twój kontener nie zawiera reguł ani tagów, możesz użyć prostej 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 np. identyfikator kontenera to GTM-1234, możesz określić domyślne wartości kontenerów w pliku z listą właściwości o nazwie GTM-1234.plist.

3. Otwieranie kontenera

Przed pobraniem wartości z kontenera aplikacja musi go otworzyć. Otwarcie kontenera spowoduje wczytanie go z dysku (jeśli będzie dostępny) lub użycie go do sieci (w razie potrzeby).

Najprostszym sposobem na otwarcie kontenera na iOS jest użycie 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 konfiguracyjnych z kontenera

Po otwarciu kontenera wartości konfiguracyjne 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 wysłane przy użyciu nieistniejącego klucza będą zwracać wartość domyślną odpowiednią do żą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

Warstwy danych to mapa, dzięki której informacje o aplikacji w czasie działania, np. zdarzenia kliknięcia czy wyświetlenia ekranu, mogą być dostępne dla makr i tagów Menedżera tagów w kontenerze.

Na przykład umieszczając informacje o wyświetleniach ekranu na mapę warstw DataLayer, możesz skonfigurować w interfejsie internetowym Menedżera tagów tagi, które będą uruchamiać piksele konwersji i śledzić wywołania w odpowiedzi na te wyświetlenia ekranu bez konieczności kodowania 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 internetowym możesz teraz tworzyć tagi (np. tagi Google Analytics), które będą się uruchamiać dla każdego wyświetlenia ekranu. W tym celu utwórz następującą regułę: równa się „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 konwersji Google Ads), który będzie uruchamiany tylko w przypadku określonych wyświetleń ekranu. W tym celu utwórz regułę, w której równa się „openScreen” && równa się „ConfirmationScreen”.

6. Wyświetlanie podglądu i publikowanie kontenera

Wartości makr zawsze będą odpowiadać obecnie opublikowanej wersji. Przed opublikowaniem najnowszej wersji kontenera możesz wyświetlić jego podgląd.

Aby wyświetlić podgląd kontenera, wygeneruj adres URL podglądu w interfejsie internetowym Menedżera tagów Google. Aby to zrobić, wybierz wersję kontenera, której podgląd chcesz wyświetlić, a potem kliknij Preview. Zachowuj się nad tym adresem URL podglądu, ponieważ będziesz go potrzebować na kolejnych etapach.

Adresy URL podglądu są dostępne w oknie podglądu interfejsu internetowego Menedżera tagów
Rys. 1: Uzyskiwanie adresu URL podglądu w interfejsie internetowym Menedżera tagów.

Aby włączyć podgląd kontenerów, musisz dodać kod do pliku z przekazaniem dostępu do aplikacji i zdefiniować schemat adresu URL podglądu Menedżera tagów Google na liście usług w projekcie.

Najpierw dodaj do pliku z przekazanym dostępem do aplikacji te pogrubione 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 i schemat adresów URL w kluczu typów adresów URL pliku z listą właściwości aplikacji:

URL identifier: your.package_name
URL scheme: tagmanager.c.your.package.name
Zarejestruj schemat adresu URL podglądu menedżera tagów w pliku z listą właściwości aplikacji.
Rys. 3. Dodawanie schematu adresu URL podglądu Menedżera tagów do pliku z listą 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 wszystko będzie gotowe do udostępnienia w aplikacji wartości roboczych wersji roboczych, opublikuj kontener.

Konfiguracja zaawansowana

Menedżer tagów Google do aplikacji mobilnych ma wiele zaawansowanych opcji konfiguracji, które pozwalają wybierać wartości w zależności od warunków środowiska wykonawczego za pomocą reguł, ręcznie odświeżać kontener i uzyskiwać dodatkowe opcje otwierania kontenerów. W sekcjach poniżej opisujemy kilka najczęstszych konfiguracji zaawansowanych.

Zaawansowane opcje otwierania kontenerów

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

openContainerById:wywołanie zwrotne:

openContainerById:callback: to najniższy poziom i najbardziej elastyczny interfejs API do otwierania kontenera. Zwracany jest natychmiast z domyślnym kontenerem. Również asynchronicznie wczytuje kontener z dysku lub sieci, jeśli nie istnieje żaden zapisany kontener lub jeśli zapisany kontener nie jest aktualny (ma ponad 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

W trakcie procesu wczytywania openContainerById:callback: wysyła kilka wywołań zwrotnych cyklu życia, aby Twój kod mógł dowiedzieć się, kiedy zaczyna się żądanie wczytywania, czy i dlaczego kończy się ono niepowodzeniem oraz czy zakończyło się ono sukcesem, a także czy kontener został ostatecznie załadowany z dysku czy sieci.

O ile nie jest to dozwolone w Twojej aplikacji, musisz używać tych wywołań zwrotnych do sprawdzania, kiedy zapisany lub kontener sieci został wczytany. Jeśli aplikacja jest uruchamiana po raz pierwszy i nie ma połączenia sieciowego, nie będzie można wczytać zapisanego kontenera lub kontenera sieciowego.

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

RefreshType

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

RefreshFailure

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

Metody otwierania nowych i niedomyślnych kontenerów

TAGContainerOpener pakuje element openContainerById:callback: i zapewnia 2 wygodne metody otwierania kontenerów: openContainerWithId:tagManager:openType:timeout:notifier: i openContainerWithId:tagManager:openType:timeout:.

Każda z tych metod wymaga wyliczenia żądającego kontenera nowego lub innego niż domyślny.

Parametr kTAGOpenTypePreferNonDefault jest zalecany w przypadku większości aplikacji i próbuje zwrócić z dysku lub sieci pierwszy dostępny kontener inny niż domyślny w danym okresie czasu oczekiwania, nawet jeśli ma on więcej niż 12 godzin. Jeśli zwróci nieaktualny zapisany kontener, wyśle też asynchroniczne żądanie sieciowe na nowy. Gdy używasz kTAGOpenTypePreferNonDefault, zwracany jest domyślny kontener, jeśli nie będzie dostępny żaden inny kontener lub jeśli zostanie przekroczony limit czasu oczekiwania.

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

Nie zalecamy używania kTAGOpenTypePreferFresh w miejscach, gdzie dłuższy czas żądania może zauważalnie wpływać na wrażenia użytkownika, na przykład w przypadku flag interfejsu lub wyświetlanych ciągów. W każdej chwili możesz też użyć TAGContainer::refresh, aby wymusić wysłanie żądania kontenera sieciowego.

Obie te metody nie blokują dostępu. openContainerWithId:tagManager:openType:timeout: zwraca obiekt TAGContainerFuture, którego metoda get zwraca TAGContainer natychmiast po wczytaniu (ale do tego czasu ta metoda jest blokowana). Metoda openContainerWithId:tagManager:openType:timeout:notifier: przyjmuje jedno wywołanie zwrotne, które jest wywoływane, gdy kontener jest dostępny. Dla obu metod domyślny limit czasu oczekiwania wynosi 2.0 s.

Ocena makr w środowisku wykonawczym z użyciem reguł

Kontenery mogą oceniać wartości w czasie działania za pomocą reguł. Reguły mogą opierać się na takich kryteriach jak język urządzenia, platforma lub dowolna inna wartość makra. Za pomocą reguł można na przykład wybrać zlokalizowany wyświetlany ciąg znaków na podstawie języka urządzenia w czasie działania. Możesz to skonfigurować, korzystając z tej reguły:

Reguła służy do wybierania wyświetlanych ciągów na podstawie języka urządzenia w czasie działania: język równa się es. Ta reguła korzysta ze wstępnie zdefiniowanego makra języka i dwuznakowego kodu języka w formacie ISO 639-1.
Rysunek 1. Dodawanie reguły włączającej makro zbierania wartości tylko w przypadku urządzeń skonfigurowanych do używania języka hiszpańskiego

Następnie możesz utworzyć makra zbierania wartości dla każdego języka i dodać tę regułę do makr, wstawiając odpowiedni kod języka. Po opublikowaniu tego kontenera aplikacja będzie mogła wyświetlać zlokalizowane wyświetlane ciągi znaków w zależności od języka urządzenia użytkownika w czasie działania.

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

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

Domyślne binarne pliki kontenerów

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

Pliki kontenerów binarnych można pobierać z interfejsu internetowego Menedżera tagów Google i dodawać je do głównego pakietu aplikacji zgodnie z tą konwencją nazewnictwa: GTM-XXXX, gdzie nazwa pliku reprezentuje identyfikator kontenera.

W przypadku plików z listą właściwości lub plików JSON i binarnych kontenerów pakiet SDK użyje ich jako domyślnego kontenera.

Używanie makr wywołań funkcji

Makra wywołań funkcji to makra, które są ustawione na wartość zwracaną przez określoną funkcję w Twojej aplikacji. Makra wywołań funkcji mogą służyć do dołączania do reguł Menedżera tagów Google wartości środowiska wykonawczego, np. do określania w czasie działania 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 internetowym Menedżera tagów Google. Argumenty mogą być opcjonalnie skonfigurowane jako pary klucz-wartość.
  2. Określ 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ą klasy TAGContainer::registerFunctionCallMacroHandler:forMacro: i wybierz nazwę funkcji określoną w interfejsie Menedżera tagów Google:
    4. //
// 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ą uruchamianie wcześniej zarejestrowanych funkcji za każdym razem, gdy zdarzenie jest przekazywane do warstwy danych, a reguły tagu zwracają wartość true.

Aby skonfigurować tag wywołania funkcji:

  1. Zdefiniuj tag wywołania funkcji w interfejsie internetowym Menedżera tagów Google. Argumenty mogą być opcjonalnie skonfigurowane 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, używając nazwy tagu skonfigurowanej w interfejsie internetowym Menedżera tagów Google:
    4. //
// 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

Jeśli bieżący wiek kontenera przekroczy 12 godzin, pakiet SDK Menedżera tagów Google spróbuje pobrać nowy kontener. 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 wyświetla błędy i ostrzeżenia w dziennikach. Włączenie bardziej szczegółowego logowania może pomóc w debugowaniu. Jest też możliwe, 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ć poziom logu obecnego rejestratora za pomocą funkcji 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];